feedc0de/wolfssl
1
0
Fork 0
forked from wolfSSL/wolfssl
Code Pull Requests Activity

More updates from code review

Browse Source
This commit is contained in:
Martin Akman
2020-07-22 09:49:09 +10:00
parent 568ce62b81
commit d02e52e07b
3 changed files with 46 additions and 39 deletions
Download Patch File Download Diff File Expand all files Collapse all files

3
src/ssl.c
View File

@ -4992,9 +4992,6 @@ int AddCA(WOLFSSL_CERT_MANAGER* cm, DerBuffer** pDer, int type, int verify)
#elif defined(SMALL_SESSION_CACHE) #elif defined(SMALL_SESSION_CACHE)
#define SESSIONS_PER_ROW 2 #define SESSIONS_PER_ROW 2
#define SESSION_ROWS 3 #define SESSION_ROWS 3
#elif defined(VERY_SMALL_SESSION_CACHE)
#define SESSIONS_PER_ROW 2
#define SESSION_ROWS 1
#else #else
#define SESSIONS_PER_ROW 3 #define SESSIONS_PER_ROW 3
#define SESSION_ROWS 11 #define SESSION_ROWS 11

32
wolfcrypt/src/asn.c
View File

@ -6122,14 +6122,6 @@ static WC_INLINE int GetTime(int* value, const byte* date, int* idx)
int ExtractDate(const unsigned char* date, unsigned char format, int ExtractDate(const unsigned char* date, unsigned char format,
struct tm* certTime, int* idx) struct tm* certTime, int* idx)
{ {
/* Extract the time from the struct tm - 16bit processors store as uint8_t */
int tm_year = certTime->tm_year;
int tm_mon = certTime->tm_mon;
int tm_mday = certTime->tm_mday;
int tm_hour = certTime->tm_hour;
int tm_min = certTime->tm_min;
int tm_sec = certTime->tm_sec;
XMEMSET(certTime, 0, sizeof(struct tm)); XMEMSET(certTime, 0, sizeof(struct tm));
if (format == ASN_UTC_TIME) { if (format == ASN_UTC_TIME) {
@ -6143,9 +6135,16 @@ int ExtractDate(const unsigned char* date, unsigned char format,
certTime->tm_year *= 100; certTime->tm_year *= 100;
} }
/* adjust tm_year, tm_mon */ #ifdef AVR
tm_year -= 1900; /* Extract the time from the struct tm and adjust tm_year, tm_mon */
tm_mon -= 1; /* AVR libc stores these as uint8_t instead of int */
/* AVR time_t also offsets from midnight 1 Jan 2000 */
int tm_year = certTime->tm_year - 2000;
int tm_mon = certTime->tm_mon - 1;
int tm_mday = certTime->tm_mday;
int tm_hour = certTime->tm_hour;
int tm_min = certTime->tm_min;
int tm_sec = certTime->tm_sec;
if (GetTime(&tm_year, date, idx) != 0) return 0; if (GetTime(&tm_year, date, idx) != 0) return 0;
if (GetTime(&tm_mon , date, idx) != 0) return 0; if (GetTime(&tm_mon , date, idx) != 0) return 0;
@ -6161,6 +6160,17 @@ int ExtractDate(const unsigned char* date, unsigned char format,
certTime->tm_hour = tm_hour; certTime->tm_hour = tm_hour;
certTime->tm_min = tm_min; certTime->tm_min = tm_min;
certTime->tm_sec = tm_sec; certTime->tm_sec = tm_sec;
#else
/* adjust tm_year, tm_mon */
if (GetTime(&certTime->tm_year, date, idx) != 0) return 0;
certTime->tm_year -= 1900;
if (GetTime(&certTime->tm_mon , date, idx) != 0) return 0;
certTime->tm_mon -= 1;
if (GetTime(&certTime->tm_mday, date, idx) != 0) return 0;
if (GetTime(&certTime->tm_hour, date, idx) != 0) return 0;
if (GetTime(&certTime->tm_min , date, idx) != 0) return 0;
if (GetTime(&certTime->tm_sec , date, idx) != 0) return 0;
#endif
return 1; return 1;
} }

50
wolfcrypt/src/random.c
View File

@ -1102,20 +1102,20 @@ exit_rng_ht:
} }
const FLASH_QUALIFIER byte _seedA[] = { const FLASH_QUALIFIER byte seedA_data[] = {
0x63, 0x36, 0x33, 0x77, 0xe4, 0x1e, 0x86, 0x46, 0x8d, 0xeb, 0x0a, 0xb4, 0x63, 0x36, 0x33, 0x77, 0xe4, 0x1e, 0x86, 0x46, 0x8d, 0xeb, 0x0a, 0xb4,
0xa8, 0xed, 0x68, 0x3f, 0x6a, 0x13, 0x4e, 0x47, 0xe0, 0x14, 0xc7, 0x00, 0xa8, 0xed, 0x68, 0x3f, 0x6a, 0x13, 0x4e, 0x47, 0xe0, 0x14, 0xc7, 0x00,
0x45, 0x4e, 0x81, 0xe9, 0x53, 0x58, 0xa5, 0x69, 0x80, 0x8a, 0xa3, 0x8f, 0x45, 0x4e, 0x81, 0xe9, 0x53, 0x58, 0xa5, 0x69, 0x80, 0x8a, 0xa3, 0x8f,
0x2a, 0x72, 0xa6, 0x23, 0x59, 0x91, 0x5a, 0x9f, 0x8a, 0x04, 0xca, 0x68 0x2a, 0x72, 0xa6, 0x23, 0x59, 0x91, 0x5a, 0x9f, 0x8a, 0x04, 0xca, 0x68
}; };
const FLASH_QUALIFIER byte _reseedSeedA[] = { const FLASH_QUALIFIER byte reseedSeedA_data[] = {
0xe6, 0x2b, 0x8a, 0x8e, 0xe8, 0xf1, 0x41, 0xb6, 0x98, 0x05, 0x66, 0xe3, 0xe6, 0x2b, 0x8a, 0x8e, 0xe8, 0xf1, 0x41, 0xb6, 0x98, 0x05, 0x66, 0xe3,
0xbf, 0xe3, 0xc0, 0x49, 0x03, 0xda, 0xd4, 0xac, 0x2c, 0xdf, 0x9f, 0x22, 0xbf, 0xe3, 0xc0, 0x49, 0x03, 0xda, 0xd4, 0xac, 0x2c, 0xdf, 0x9f, 0x22,
0x80, 0x01, 0x0a, 0x67, 0x39, 0xbc, 0x83, 0xd3 0x80, 0x01, 0x0a, 0x67, 0x39, 0xbc, 0x83, 0xd3
}; };
const FLASH_QUALIFIER byte _outputA[] = { const FLASH_QUALIFIER byte outputA_data[] = {
0x04, 0xee, 0xc6, 0x3b, 0xb2, 0x31, 0xdf, 0x2c, 0x63, 0x0a, 0x1a, 0xfb, 0x04, 0xee, 0xc6, 0x3b, 0xb2, 0x31, 0xdf, 0x2c, 0x63, 0x0a, 0x1a, 0xfb,
0xe7, 0x24, 0x94, 0x9d, 0x00, 0x5a, 0x58, 0x78, 0x51, 0xe1, 0xaa, 0x79, 0xe7, 0x24, 0x94, 0x9d, 0x00, 0x5a, 0x58, 0x78, 0x51, 0xe1, 0xaa, 0x79,
0x5e, 0x47, 0x73, 0x47, 0xc8, 0xb0, 0x56, 0x62, 0x1c, 0x18, 0xbd, 0xdc, 0x5e, 0x47, 0x73, 0x47, 0xc8, 0xb0, 0x56, 0x62, 0x1c, 0x18, 0xbd, 0xdc,
@ -1129,7 +1129,7 @@ const FLASH_QUALIFIER byte _outputA[] = {
0xa1, 0x80, 0x18, 0x3a, 0x07, 0xdf, 0xae, 0x17 0xa1, 0x80, 0x18, 0x3a, 0x07, 0xdf, 0xae, 0x17
}; };
const FLASH_QUALIFIER byte _seedB[] = { const FLASH_QUALIFIER byte seedB_data[] = {
0xa6, 0x5a, 0xd0, 0xf3, 0x45, 0xdb, 0x4e, 0x0e, 0xff, 0xe8, 0x75, 0xc3, 0xa6, 0x5a, 0xd0, 0xf3, 0x45, 0xdb, 0x4e, 0x0e, 0xff, 0xe8, 0x75, 0xc3,
0xa2, 0xe7, 0x1f, 0x42, 0xc7, 0x12, 0x9d, 0x62, 0x0f, 0xf5, 0xc1, 0x19, 0xa2, 0xe7, 0x1f, 0x42, 0xc7, 0x12, 0x9d, 0x62, 0x0f, 0xf5, 0xc1, 0x19,
0xa9, 0xef, 0x55, 0xf0, 0x51, 0x85, 0xe0, 0xfb, /* nonce next */ 0xa9, 0xef, 0x55, 0xf0, 0x51, 0x85, 0xe0, 0xfb, /* nonce next */
@ -1137,7 +1137,7 @@ const FLASH_QUALIFIER byte _seedB[] = {
0xdb, 0xcb, 0xcc, 0x2e 0xdb, 0xcb, 0xcc, 0x2e
}; };
const FLASH_QUALIFIER byte _outputB[] = { const FLASH_QUALIFIER byte outputB_data[] = {
0xd3, 0xe1, 0x60, 0xc3, 0x5b, 0x99, 0xf3, 0x40, 0xb2, 0x62, 0x82, 0x64, 0xd3, 0xe1, 0x60, 0xc3, 0x5b, 0x99, 0xf3, 0x40, 0xb2, 0x62, 0x82, 0x64,
0xd1, 0x75, 0x10, 0x60, 0xe0, 0x04, 0x5d, 0xa3, 0x83, 0xff, 0x57, 0xa5, 0xd1, 0x75, 0x10, 0x60, 0xe0, 0x04, 0x5d, 0xa3, 0x83, 0xff, 0x57, 0xa5,
0x7d, 0x73, 0xa6, 0x73, 0xd2, 0xb8, 0xd8, 0x0d, 0xaa, 0xf6, 0xa6, 0xc3, 0x7d, 0x73, 0xa6, 0x73, 0xd2, 0xb8, 0xd8, 0x0d, 0xaa, 0xf6, 0xa6, 0xc3,
@ -1171,11 +1171,11 @@ static int wc_RNG_HealthTestLocal(int reseed)
if (reseed) { if (reseed) {
#ifdef WOLFSSL_USE_FLASHMEM #ifdef WOLFSSL_USE_FLASHMEM
byte* seedA = (byte*)XMALLOC(sizeof(_seedA), NULL, byte* seedA = (byte*)XMALLOC(sizeof(seedA_data), NULL,
DYNAMIC_TYPE_TMP_BUFFER); DYNAMIC_TYPE_TMP_BUFFER);
byte* reseedSeedA = (byte*)XMALLOC(sizeof(_reseedSeedA), NULL, byte* reseedSeedA = (byte*)XMALLOC(sizeof(reseedSeedA_data), NULL,
DYNAMIC_TYPE_TMP_BUFFER); DYNAMIC_TYPE_TMP_BUFFER);
byte* outputA = (byte*)XMALLOC(sizeof(_outputA), NULL, byte* outputA = (byte*)XMALLOC(sizeof(outputA_data), NULL,
DYNAMIC_TYPE_TMP_BUFFER); DYNAMIC_TYPE_TMP_BUFFER);
if (!seedA || !reseedSeedA || !outputA) { if (!seedA || !reseedSeedA || !outputA) {
@ -1185,16 +1185,16 @@ static int wc_RNG_HealthTestLocal(int reseed)
ret = MEMORY_E; ret = MEMORY_E;
} }
else { else {
XMEMCPY_P(seedA, _seedA, sizeof(_seedA)); XMEMCPY_P(seedA, seedA_data, sizeof(seedA_data));
XMEMCPY_P(reseedSeedA, _reseedSeedA, sizeof(_reseedSeedA)); XMEMCPY_P(reseedSeedA, reseedSeedA_data, sizeof(reseedSeedA_data));
XMEMCPY_P(outputA, _outputA, sizeof(_outputA)); XMEMCPY_P(outputA, outputA_data, sizeof(outputA_data));
#else #else
const byte* seedA = _seedA; const byte* seedA = seedA_data;
const byte* reseedSeedA = _reseedSeedA; const byte* reseedSeedA = reseedSeedA_data;
const byte* outputA = _outputA; const byte* outputA = outputA_data;
#endif #endif
ret = wc_RNG_HealthTest(1, seedA, sizeof(_seedA), ret = wc_RNG_HealthTest(1, seedA, sizeof(seedA_data),
reseedSeedA, sizeof(_reseedSeedA), reseedSeedA, sizeof(reseedSeedA_data),
check, RNG_HEALTH_TEST_CHECK_SIZE); check, RNG_HEALTH_TEST_CHECK_SIZE);
if (ret == 0) { if (ret == 0) {
if (ConstantCompare(check, outputA, if (ConstantCompare(check, outputA,
@ -1211,9 +1211,9 @@ static int wc_RNG_HealthTestLocal(int reseed)
} }
else { else {
#ifdef WOLFSSL_USE_FLASHMEM #ifdef WOLFSSL_USE_FLASHMEM
byte* seedB = (byte*)XMALLOC(sizeof(_seedB), NULL, byte* seedB = (byte*)XMALLOC(sizeof(seedB_data), NULL,
DYNAMIC_TYPE_TMP_BUFFER); DYNAMIC_TYPE_TMP_BUFFER);
byte* outputB = (byte*)XMALLOC(sizeof(_outputB), NULL, byte* outputB = (byte*)XMALLOC(sizeof(outputB_data), NULL,
DYNAMIC_TYPE_TMP_BUFFER); DYNAMIC_TYPE_TMP_BUFFER);
if (!seedB || !outputB) { if (!seedB || !outputB) {
@ -1222,13 +1222,13 @@ static int wc_RNG_HealthTestLocal(int reseed)
ret = MEMORY_E; ret = MEMORY_E;
} }
else { else {
XMEMCPY_P(seedB, _seedB, sizeof(_seedB)); XMEMCPY_P(seedB, seedB_data, sizeof(seedB_data));
XMEMCPY_P(outputB, _outputB, sizeof(_outputB)); XMEMCPY_P(outputB, outputB_data, sizeof(outputB_data));
#else #else
const byte* seedB = _seedB; const byte* seedB = seedB_data;
const byte* outputB = _outputB; const byte* outputB = outputB_data;
#endif #endif
ret = wc_RNG_HealthTest(0, seedB, sizeof(_seedB), ret = wc_RNG_HealthTest(0, seedB, sizeof(seedB_data),
NULL, 0, NULL, 0,
check, RNG_HEALTH_TEST_CHECK_SIZE); check, RNG_HEALTH_TEST_CHECK_SIZE);
if (ret == 0) { if (ret == 0) {
@ -1243,13 +1243,13 @@ static int wc_RNG_HealthTestLocal(int reseed)
* byte 32, feed them into the health test separately. */ * byte 32, feed them into the health test separately. */
if (ret == 0) { if (ret == 0) {
ret = wc_RNG_HealthTest_ex(0, ret = wc_RNG_HealthTest_ex(0,
seedB + 32, sizeof(_seedB) - 32, seedB + 32, sizeof(seedB_data) - 32,
seedB, 32, seedB, 32,
NULL, 0, NULL, 0,
check, RNG_HEALTH_TEST_CHECK_SIZE, check, RNG_HEALTH_TEST_CHECK_SIZE,
NULL, INVALID_DEVID); NULL, INVALID_DEVID);
if (ret == 0) { if (ret == 0) {
if (ConstantCompare(check, outputB, sizeof(_outputB)) != 0) if (ConstantCompare(check, outputB, sizeof(outputB_data)) != 0)
ret = -1; ret = -1;
} }
} }