From 9dda838075032fc1174ccc09f425b57a54d25264 Mon Sep 17 00:00:00 2001 From: kaleb-himes Date: Wed, 23 Nov 2016 22:26:51 -0700 Subject: [PATCH] x509 begin and fix mallocs with sanity checks --- wolfCLU/include/wolfssl.h | 55 ++---- wolfCLU/include/x509/wolfsslCert.h | 11 +- wolfCLU/src/benchmark/wolfsslBenchmark.c | 205 ++++++++++++++++------- wolfCLU/src/crypto/wolfsslDecrypt.c | 9 +- wolfCLU/src/crypto/wolfsslEncrypt.c | 19 ++- wolfCLU/src/crypto/wolfsslSetup.c | 16 +- wolfCLU/src/hash/wolfsslHash.c | 22 ++- wolfCLU/src/hash/wolfsslHashSetup.c | 7 +- wolfCLU/src/tools/wolfsslHexToBin.c | 16 +- wolfCLU/src/wolfsslMain.c | 17 +- wolfCLU/src/x509/wolfsslCertSetup.c | 48 +++++- 11 files changed, 291 insertions(+), 134 deletions(-) diff --git a/wolfCLU/include/wolfssl.h b/wolfCLU/include/wolfssl.h index fdf65c9d..63943a15 100644 --- a/wolfCLU/include/wolfssl.h +++ b/wolfCLU/include/wolfssl.h @@ -74,6 +74,15 @@ #define MEGABYTE (1024*1024) #define MAX_THREADS 64 +#include + +#ifdef WOLFSSL_STATIC_MEMORY + #include + static WOLFSSL_HEAP_HINT* HEAP_HINT; +#else + #define HEAP_HINT NULL +#endif + /* @VERSION * Update every time library change, * functionality shift, @@ -81,50 +90,6 @@ */ #define VERSION 0.3 -/* Enumerated types for long arguments */ -enum { - ENCRYPT = 1000, - DECRYPT, - BENCHMARK, - HASH, - INFILE, - OUTFILE, - PASSWORD, - KEY, - IV, - ALL, - SIZE, - TIME, - VERIFY, - VERBOSE, - X509 -}; - -/* Structure for holding long arguments */ -static struct option long_options[] = { - - {"encrypt", required_argument, 0, ENCRYPT }, - {"decrypt", required_argument, 0, DECRYPT }, - {"bench", required_argument, 0, BENCHMARK }, - {"hash", required_argument, 0, HASH }, - {"in", required_argument, 0, INFILE }, - {"out", required_argument, 0, OUTFILE }, - {"pwd", required_argument, 0, PASSWORD }, - {"key", required_argument, 0, KEY }, - {"iv", required_argument, 0, IV }, - {"all", 0, 0, ALL }, - {"size", required_argument, 0, SIZE }, - {"time", required_argument, 0, TIME }, - {"verify", 0, 0, VERIFY }, - {"verbose", 0, 0, VERBOSE }, - {"x509", required_argument, 0, X509 }, - {"v", 0, 0, 'v' }, - {"version", 0, 0, 'v' }, - {0, 0, 0, 0} - -}; - - /* encryption argument function * * @param argc holds all command line input @@ -239,7 +204,7 @@ int wolfsslHexToBin(const char* h1, byte** b1, word32* b1Sz, const char* h3, byte** b3, word32* b3Sz, const char* h4, byte** b4, word32* b4Sz); -/* A function to free malloced byte* buffers after conversion +/* A function to free MALLOCED buffers * * @param b1 a buffer to be freed, can be set to NULL * @param b2 a buffer to be freed, can be set to NULL diff --git a/wolfCLU/include/x509/wolfsslCert.h b/wolfCLU/include/x509/wolfsslCert.h index b32b562c..0118b505 100644 --- a/wolfCLU/include/x509/wolfsslCert.h +++ b/wolfCLU/include/x509/wolfsslCert.h @@ -19,10 +19,19 @@ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA */ +#include #include +#include + +#ifdef WOLFSSL_STATIC_MEMORY + #include + static WOLFSSL_HEAP_HINT* HEAP_HINT; +#else + #define HEAP_HINT NULL +#endif /* handles incoming arguments for certificate generation */ -int wolfsslCertSetup(int argc, char** argv, char action); +int wolfsslCertSetup(int argc, char** argv); /* print help info */ void wolfsslCertHelp(); diff --git a/wolfCLU/src/benchmark/wolfsslBenchmark.c b/wolfCLU/src/benchmark/wolfsslBenchmark.c index 06198ac5..59b428a7 100644 --- a/wolfCLU/src/benchmark/wolfsslBenchmark.c +++ b/wolfCLU/src/benchmark/wolfsslBenchmark.c @@ -21,6 +21,7 @@ #include "include/wolfssl.h" + #define DES3_BLOCK_SIZE 24 #ifdef HAVE_BLAKE2 @@ -50,13 +51,13 @@ int wolfsslBenchmark(int timer, int* option) double stop = 0.0; /* stop breaks loop */ double start; /* start time */ double currTime; /* current time*/ - + ALIGN16 byte* plain; /* plain text */ ALIGN16 byte* cipher; /* cipher */ ALIGN16 byte* key; /* key for testing */ ALIGN16 byte* iv; /* iv for initial encoding */ - + byte* digest; /* message digest */ wc_InitRng(&rng); @@ -66,10 +67,25 @@ int wolfsslBenchmark(int timer, int* option) #ifndef NO_AES /* aes test */ if (option[i] == 1) { - plain = malloc(AES_BLOCK_SIZE); - cipher = malloc(AES_BLOCK_SIZE); - key = malloc(AES_BLOCK_SIZE); - iv = malloc(AES_BLOCK_SIZE); + plain = XMALLOC(AES_BLOCK_SIZE, HEAP_HINT, DYNAMIC_TYPE_TMP_BUFFER); + if (plain == NULL) { + return MEMORY_E; + } + cipher = XMALLOC(AES_BLOCK_SIZE, HEAP_HINT, DYNAMIC_TYPE_TMP_BUFFER); + if (cipher == NULL) { + wolfsslFreeBins(plain, NULL, NULL, NULL, NULL); + return MEMORY_E; + } + key = XMALLOC(AES_BLOCK_SIZE, HEAP_HINT, DYNAMIC_TYPE_TMP_BUFFER); + if (key == NULL) { + wolfsslFreeBins(plain, cipher, NULL, NULL, NULL); + return MEMORY_E; + } + iv = XMALLOC(AES_BLOCK_SIZE, HEAP_HINT, DYNAMIC_TYPE_TMP_BUFFER); + if (iv == NULL) { + wolfsslFreeBins(plain, cipher, key, NULL, NULL); + return MEMORY_E; + } wc_RNG_GenerateBlock(&rng, plain, AES_BLOCK_SIZE); wc_RNG_GenerateBlock(&rng, cipher, AES_BLOCK_SIZE); @@ -95,10 +111,7 @@ int wolfsslBenchmark(int timer, int* option) XMEMSET(cipher, 0, AES_BLOCK_SIZE); XMEMSET(key, 0, AES_BLOCK_SIZE); XMEMSET(iv, 0, AES_BLOCK_SIZE); - free(plain); - free(cipher); - free(key); - free(iv); + wolfsslFreeBins(plain, cipher, key, iv, NULL); blocks = 0; loop = 1; } @@ -107,10 +120,25 @@ int wolfsslBenchmark(int timer, int* option) #ifdef WOLFSSL_AES_COUNTER /* aes-ctr test */ if (option[i] == 1) { - plain = malloc(AES_BLOCK_SIZE); - cipher = malloc(AES_BLOCK_SIZE); - key = malloc(AES_BLOCK_SIZE); - iv = malloc(AES_BLOCK_SIZE); + plain = XMALLOC(AES_BLOCK_SIZE, HEAP_HINT, DYNAMIC_TYPE_TMP_BUFFER); + if (plain == NULL) { + return MEMORY_E; + } + cipher = XMALLOC(AES_BLOCK_SIZE, HEAP_HINT, DYNAMIC_TYPE_TMP_BUFFER); + if (cipher == NULL) { + wolfsslFreeBins(plain, NULL, NULL, NULL, NULL); + return MEMORY_E; + } + key = XMALLOC(AES_BLOCK_SIZE, HEAP_HINT, DYNAMIC_TYPE_TMP_BUFFER); + if (key == NULL) { + wolfsslFreeBins(plain, cipher, NULL, NULL, NULL); + return MEMORY_E; + } + iv = XMALLOC(AES_BLOCK_SIZE, HEAP_HINT, DYNAMIC_TYPE_TMP_BUFFER); + if (iv == NULL) { + wolfsslFreeBins(plain, cipher, key, NULL, NULL); + return MEMORY_E; + } wc_RNG_GenerateBlock(&rng, plain, AES_BLOCK_SIZE); wc_RNG_GenerateBlock(&rng, cipher, AES_BLOCK_SIZE); @@ -134,10 +162,7 @@ int wolfsslBenchmark(int timer, int* option) XMEMSET(cipher, 0, AES_BLOCK_SIZE); XMEMSET(key, 0, AES_BLOCK_SIZE); XMEMSET(iv, 0, AES_BLOCK_SIZE); - free(plain); - free(cipher); - free(key); - free(iv); + wolfsslFreeBins(plain, cipher, key, iv, NULL); blocks = 0; loop = 1; } @@ -145,11 +170,26 @@ int wolfsslBenchmark(int timer, int* option) #endif #ifndef NO_DES3 /* 3des test */ - if (option[i] == 1) { - plain = malloc(DES3_BLOCK_SIZE); - cipher = malloc(DES3_BLOCK_SIZE); - key = malloc(DES3_BLOCK_SIZE); - iv = malloc(DES3_BLOCK_SIZE); + if (option[i] == 1) { + plain = XMALLOC(DES3_BLOCK_SIZE, HEAP_HINT, DYNAMIC_TYPE_TMP_BUFFER); + if (plain == NULL) { + return MEMORY_E; + } + cipher = XMALLOC(DES3_BLOCK_SIZE, HEAP_HINT, DYNAMIC_TYPE_TMP_BUFFER); + if (cipher == NULL) { + wolfsslFreeBins(plain, NULL, NULL, NULL, NULL); + return MEMORY_E; + } + key = XMALLOC(DES3_BLOCK_SIZE, HEAP_HINT, DYNAMIC_TYPE_TMP_BUFFER); + if (key == NULL) { + wolfsslFreeBins(plain, cipher, NULL, NULL, NULL); + return MEMORY_E; + } + iv = XMALLOC(DES3_BLOCK_SIZE, HEAP_HINT, DYNAMIC_TYPE_TMP_BUFFER); + if (iv == NULL) { + wolfsslFreeBins(plain, cipher, key, NULL, NULL); + return MEMORY_E; + } wc_RNG_GenerateBlock(&rng, plain, DES3_BLOCK_SIZE); wc_RNG_GenerateBlock(&rng, cipher, DES3_BLOCK_SIZE); @@ -174,24 +214,37 @@ int wolfsslBenchmark(int timer, int* option) XMEMSET(cipher, 0, DES3_BLOCK_SIZE); XMEMSET(key, 0, DES3_BLOCK_SIZE); XMEMSET(iv, 0, DES3_BLOCK_SIZE); - free(plain); - free(cipher); - free(key); - free(iv); + wolfsslFreeBins(plain, cipher, key, iv, NULL); blocks = 0; loop = 1; } i++; #endif #ifdef HAVE_CAMELLIA + #define CAM_SZ CAMELLIA_BLOCK_SIZE /* camellia test */ if (option[i] == 1) { Camellia camellia; - plain = malloc(CAMELLIA_BLOCK_SIZE); - cipher = malloc(CAMELLIA_BLOCK_SIZE); - key = malloc(CAMELLIA_BLOCK_SIZE); - iv = malloc(CAMELLIA_BLOCK_SIZE); + plain = XMALLOC(CAM_SZ, HEAP_HINT, DYNAMIC_TYPE_TMP_BUFFER); + if (plain == NULL) { + return MEMORY_E; + } + cipher = XMALLOC(CAM_SZ, HEAP_HINT, DYNAMIC_TYPE_TMP_BUFFER); + if (cipher == NULL) { + wolfsslFreeBins(plain, NULL, NULL, NULL, NULL); + return MEMORY_E; + } + key = XMALLOC(CAM_SZ, HEAP_HINT, DYNAMIC_TYPE_TMP_BUFFER); + if (key == NULL) { + wolfsslFreeBins(plain, cipher, NULL, NULL, NULL); + return MEMORY_E; + } + iv = XMALLOC(CAM_SZ, HEAP_HINT, DYNAMIC_TYPE_TMP_BUFFER); + if (iv == NULL) { + wolfsslFreeBins(plain, cipher, key, NULL, NULL); + return MEMORY_E; + } wc_RNG_GenerateBlock(&rng, plain, CAMELLIA_BLOCK_SIZE); wc_RNG_GenerateBlock(&rng, cipher, CAMELLIA_BLOCK_SIZE); @@ -216,10 +269,7 @@ int wolfsslBenchmark(int timer, int* option) XMEMSET(cipher, 0, CAMELLIA_BLOCK_SIZE); XMEMSET(key, 0, CAMELLIA_BLOCK_SIZE); XMEMSET(iv, 0, CAMELLIA_BLOCK_SIZE); - free(plain); - free(cipher); - free(key); - free(iv); + wolfsslFreeBins(plain, cipher, key, iv, NULL); blocks = 0; loop = 1; } @@ -230,8 +280,14 @@ int wolfsslBenchmark(int timer, int* option) if (option[i] == 1) { Md5 md5; - digest = malloc(MD5_DIGEST_SIZE); - plain = malloc(MEGABYTE); + digest = XMALLOC(MD5_DIGEST_SIZE, HEAP_HINT, DYNAMIC_TYPE_TMP_BUFFER); + if (digest == NULL) + return MEMORY_E; + plain = XMALLOC(MEGABYTE, HEAP_HINT, DYNAMIC_TYPE_TMP_BUFFER); + if (plain == NULL) { + wolfsslFreeBins(digest, NULL, NULL, NULL, NULL); + return MEMORY_E; + } wc_RNG_GenerateBlock(&rng, plain, MEGABYTE); wc_InitMd5(&md5); @@ -251,8 +307,7 @@ int wolfsslBenchmark(int timer, int* option) wolfsslStats(start, MEGABYTE, blocks); XMEMSET(plain, 0, MEGABYTE); XMEMSET(digest, 0, MD5_DIGEST_SIZE); - free(plain); - free(digest); + wolfsslFreeBins(digest, plain, NULL, NULL, NULL); blocks = 0; loop = 1; } @@ -263,8 +318,14 @@ int wolfsslBenchmark(int timer, int* option) if (option[i] == 1) { Sha sha; - digest = malloc(SHA_DIGEST_SIZE); - plain = malloc(MEGABYTE); + digest = XMALLOC(SHA_DIGEST_SIZE, HEAP_HINT, DYNAMIC_TYPE_TMP_BUFFER); + if (digest == NULL) + return MEMORY_E; + plain = XMALLOC(MEGABYTE, HEAP_HINT, DYNAMIC_TYPE_TMP_BUFFER); + if (plain == NULL) { + wolfsslFreeBins(digest, NULL, NULL, NULL, NULL); + return MEMORY_E; + } wc_RNG_GenerateBlock(&rng, plain, MEGABYTE); wc_InitSha(&sha); @@ -284,20 +345,27 @@ int wolfsslBenchmark(int timer, int* option) wolfsslStats(start, MEGABYTE, blocks); XMEMSET(plain, 0, MEGABYTE); XMEMSET(digest, 0, SHA_DIGEST_SIZE); - free(plain); - free(digest); + wolfsslFreeBins(plain, digest, NULL, NULL, NULL); blocks = 0; loop = 1; } i++; #endif #ifndef NO_SHA256 + #define SHA256_SZ SHA256_DIGEST_SIZE /* sha256 test */ if (option[i] == 1) { Sha256 sha256; - digest = malloc(SHA256_DIGEST_SIZE); - plain = malloc(MEGABYTE); + digest = XMALLOC(SHA256_SZ, HEAP_HINT, DYNAMIC_TYPE_TMP_BUFFER); + if (digest == NULL) + return MEMORY_E; + plain = XMALLOC(MEGABYTE, HEAP_HINT, DYNAMIC_TYPE_TMP_BUFFER); + if (plain == NULL) { + wolfsslFreeBins(digest, NULL, NULL, NULL, NULL); + return MEMORY_E; + } + wc_RNG_GenerateBlock(&rng, plain, MEGABYTE); wc_InitSha256(&sha256); @@ -317,8 +385,7 @@ int wolfsslBenchmark(int timer, int* option) wolfsslStats(start, MEGABYTE, blocks); XMEMSET(plain, 0, MEGABYTE); XMEMSET(digest, 0, SHA256_DIGEST_SIZE); - free(plain); - free(digest); + wolfsslFreeBins(plain, digest, NULL, NULL, NULL); /* resets used for debug, uncomment if needed */ blocks = 0; loop = 1; @@ -326,12 +393,20 @@ int wolfsslBenchmark(int timer, int* option) i++; #endif #ifdef WOLFSSL_SHA384 + #define SHA384_SZ SHA384_DIGEST_SIZE /* sha384 test */ if (option[i] == 1) { Sha384 sha384; - digest = malloc(SHA384_DIGEST_SIZE); - plain = malloc(MEGABYTE); + digest = XMALLOC(SHA384_SZ, HEAP_HINT, DYNAMIC_TYPE_TMP_BUFFER); + if (digest == NULL) + return MEMORY_E; + plain = XMALLOC(MEGABYTE, HEAP_HINT, DYNAMIC_TYPE_TMP_BUFFER); + if (plain == NULL) { + wolfsslFreeBins(digest, NULL, NULL, NULL, NULL); + return MEMORY_E; + } + wc_RNG_GenerateBlock(&rng, plain, MEGABYTE); wc_InitSha384(&sha384); @@ -351,20 +426,27 @@ int wolfsslBenchmark(int timer, int* option) wolfsslStats(start, MEGABYTE, blocks); XMEMSET(plain, 0, MEGABYTE); XMEMSET(digest, 0, SHA384_DIGEST_SIZE); - free(plain); - free(digest); + wolfsslFreeBins(plain, digest, NULL, NULL, NULL); blocks = 0; loop = 1; } i++; #endif #ifdef WOLFSSL_SHA512 + #define SHA512_SZ SHA512_DIGEST_SIZE /* sha512 test */ if (option[i] == 1) { Sha512 sha512; - digest = malloc(SHA512_DIGEST_SIZE); - plain = malloc(MEGABYTE); + digest = XMALLOC(SHA512_SZ, HEAP_HINT, DYNAMIC_TYPE_TMP_BUFFER); + if (digest == NULL) + return MEMORY_E; + plain = XMALLOC(MEGABYTE, HEAP_HINT, DYNAMIC_TYPE_TMP_BUFFER); + if (plain == NULL) { + wolfsslFreeBins(digest, NULL, NULL, NULL, NULL); + return MEMORY_E; + } + wc_RNG_GenerateBlock(&rng, plain, MEGABYTE); wc_InitSha512(&sha512); @@ -384,8 +466,7 @@ int wolfsslBenchmark(int timer, int* option) wolfsslStats(start, MEGABYTE, blocks); XMEMSET(plain, 0, MEGABYTE); XMEMSET(digest, 0, SHA512_DIGEST_SIZE); - free(plain); - free(digest); + wolfsslFreeBins(plain, digest, NULL, NULL, NULL); blocks = 0; loop = 1; } @@ -396,8 +477,15 @@ int wolfsslBenchmark(int timer, int* option) if (option[i] == 1) { Blake2b b2b; - digest = malloc(BLAKE_DIGEST_SIZE); - plain = malloc(MEGABYTE); + digest = XMALLOC(BLAKE_DIGEST_SIZE, HEAP_HINT, DYNAMIC_TYPE_TMP_BUFFER); + if (digest == NULL) + return MEMORY_E; + plain = XMALLOC(MEGABYTE, HEAP_HINT, DYNAMIC_TYPE_TMP_BUFFER); + if (plain == NULL) { + wolfsslFreeBins(digest, NULL, NULL, NULL, NULL); + return MEMORY_E; + } + wc_RNG_GenerateBlock(&rng, plain, MEGABYTE); wc_InitBlake2b(&b2b, BLAKE_DIGEST_SIZE); @@ -417,8 +505,7 @@ int wolfsslBenchmark(int timer, int* option) wolfsslStats(start, MEGABYTE, blocks); XMEMSET(plain, 0, MEGABYTE); XMEMSET(digest, 0, BLAKE_DIGEST_SIZE); - free(plain); - free(digest); + wolfsslFreeBins(digest, plain, NULL, NULL, NULL); } #endif return ret; diff --git a/wolfCLU/src/crypto/wolfsslDecrypt.c b/wolfCLU/src/crypto/wolfsslDecrypt.c index 8ad90262..9d7136dc 100644 --- a/wolfCLU/src/crypto/wolfsslDecrypt.c +++ b/wolfCLU/src/crypto/wolfsslDecrypt.c @@ -85,8 +85,13 @@ int wolfsslDecrypt(char* alg, char* mode, byte* pwdKey, byte* key, int size, lastLoopFlag = length/MAX; } - input = (byte*) malloc(MAX); - output = (byte*) malloc(MAX); + input = (byte*) XMALLOC(MAX, HEAP_HINT, DYNAMIC_TYPE_TMP_BUFFER); + if (input == NULL) + return MEMORY_E; + output = (byte*) XMALLOC(MAX, HEAP_HINT, DYNAMIC_TYPE_TMP_BUFFER); + if (output == NULL) { + wolfsslFreeBins(input, NULL, NULL, NULL, NULL); + } wc_InitRng(&rng); diff --git a/wolfCLU/src/crypto/wolfsslEncrypt.c b/wolfCLU/src/crypto/wolfsslEncrypt.c index 6d6bd1cf..d15ff015 100644 --- a/wolfCLU/src/crypto/wolfsslEncrypt.c +++ b/wolfCLU/src/crypto/wolfsslEncrypt.c @@ -69,7 +69,10 @@ int wolfsslEncrypt(char* alg, char* mode, byte* pwdKey, byte* key, int size, /* use user entered data to encrypt */ inputLength = (int) strlen(in); - userInputBuffer = (char*) malloc(inputLength); + userInputBuffer = (char*) XMALLOC(inputLength, HEAP_HINT, + DYNAMIC_TYPE_TMP_BUFFER); + if (userInputBuffer == NULL) + return MEMORY_E; /* writes the entered text to the input buffer */ XMEMCPY(userInputBuffer, in, inputLength); @@ -80,7 +83,7 @@ int wolfsslEncrypt(char* alg, char* mode, byte* pwdKey, byte* key, int size, fclose(tempInFile); /* free buffer */ - free(userInputBuffer); + XFREE(userInputBuffer, HEAP_HINT, DYNAMIC_TYPE_TMP_BUFFER); } /* open the inFile in read mode */ @@ -138,9 +141,15 @@ int wolfsslEncrypt(char* alg, char* mode, byte* pwdKey, byte* key, int size, fwrite(iv, 1, block, outFile); fclose(outFile); - /* malloc 1kB buffers */ - input = (byte*) malloc(MAX); - output = (byte*) malloc(MAX); + /* MALLOC 1kB buffers */ + input = (byte*) XMALLOC(MAX, HEAP_HINT, DYNAMIC_TYPE_TMP_BUFFER); + if (input == NULL) + return MEMORY_E; + output = (byte*) XMALLOC(MAX, HEAP_HINT, DYNAMIC_TYPE_TMP_BUFFER); + if (output == NULL) { + wolfsslFreeBins(input, NULL, NULL, NULL, NULL); + return MEMORY_E; + } /* loop, encrypt 1kB at a time till length <= 0 */ while (length > 0) { diff --git a/wolfCLU/src/crypto/wolfsslSetup.c b/wolfCLU/src/crypto/wolfsslSetup.c index 6eb5ea8d..74e42feb 100644 --- a/wolfCLU/src/crypto/wolfsslSetup.c +++ b/wolfCLU/src/crypto/wolfsslSetup.c @@ -79,9 +79,19 @@ int wolfsslSetup(int argc, char** argv, char action) block = wolfsslGetAlgo(name, &alg, &mode, &size); if (block != FATAL_ERROR) { - pwdKey = (byte*) malloc(size); - iv = (byte*) malloc(block); - key = (byte*) malloc(size); + pwdKey = (byte*) XMALLOC(size, HEAP_HINT, DYNAMIC_TYPE_TMP_BUFFER); + if (pwdKey == NULL) + return MEMORY_E; + iv = (byte*) XMALLOC(block, HEAP_HINT, DYNAMIC_TYPE_TMP_BUFFER); + if (iv == NULL) { + wolfsslFreeBins(pwdKey, NULL, NULL, NULL, NULL); + return MEMORY_E; + } + key = (byte*) XMALLOC(size, HEAP_HINT, DYNAMIC_TYPE_TMP_BUFFER); + if (key == NULL) { + wolfsslFreeBins(pwdKey, iv, NULL, NULL, NULL); + return MEMORY_E; + } /* Start at the third flag entered */ i = 3; diff --git a/wolfCLU/src/hash/wolfsslHash.c b/wolfCLU/src/hash/wolfsslHash.c index 4d838d17..5abd1cd3 100644 --- a/wolfCLU/src/hash/wolfsslHash.c +++ b/wolfCLU/src/hash/wolfsslHash.c @@ -48,7 +48,10 @@ int wolfsslHash(char* in, char* out, char* alg, int size) /* if no input file was provided */ length = LENGTH_IN; - input = malloc(length); + input = XMALLOC(length, HEAP_HINT, DYNAMIC_TYPE_TMP_BUFFER); + if (input == NULL) + return MEMORY_E; + XMEMSET(input, 0, length); for (i = 0; i < length; i++) { /* copies text from in to input */ @@ -65,7 +68,10 @@ int wolfsslHash(char* in, char* out, char* alg, int size) length = leng; - input = malloc(length+1); + input = XMALLOC(length+1, HEAP_HINT, DYNAMIC_TYPE_TMP_BUFFER); + if (input == NULL) + return MEMORY_E; + XMEMSET(input, 0, length+1); if (input == NULL) { printf("Failed to create input buffer\n"); @@ -80,7 +86,11 @@ int wolfsslHash(char* in, char* out, char* alg, int size) size = length * 4; } - output = malloc(size); + output = XMALLOC(size, HEAP_HINT, DYNAMIC_TYPE_TMP_BUFFER); + if (output == NULL) { + wolfsslFreeBins(input, NULL, NULL, NULL, NULL); + return MEMORY_E; + } XMEMSET(output, 0, size); /* hashes using accepted algorithm */ @@ -112,8 +122,11 @@ int wolfsslHash(char* in, char* out, char* alg, int size) #ifdef HAVE_BLAKE2 else if (strcmp(alg, "blake2b") == 0) { ret = wc_InitBlake2b(&hash, size); + if (ret != 0) return ret; ret = wc_Blake2bUpdate(&hash, input, length); + if (ret != 0) return ret; ret = wc_Blake2bFinal(&hash, output, size); + if (ret != 0) return ret; } #endif @@ -163,7 +176,6 @@ int wolfsslHash(char* in, char* out, char* alg, int size) /* closes the opened files and frees the memory */ XMEMSET(input, 0, length); XMEMSET(output, 0, size); - free(input); - free(output); + wolfsslFreeBins(input, output, NULL, NULL, NULL); return ret; } diff --git a/wolfCLU/src/hash/wolfsslHashSetup.c b/wolfCLU/src/hash/wolfsslHashSetup.c index 5184eb8f..a6bb02e1 100644 --- a/wolfCLU/src/hash/wolfsslHashSetup.c +++ b/wolfCLU/src/hash/wolfsslHashSetup.c @@ -93,7 +93,11 @@ int wolfsslHashSetup(int argc, char** argv) for (i = 3; i < argc; i++) { if (XSTRNCMP(argv[i], "-in", 3) == 0 && argv[i+1] != NULL) { /* input file/text */ - in = malloc(strlen(argv[i+1])+1); + in = XMALLOC(strlen(argv[i+1])+1, HEAP_HINT, + DYNAMIC_TYPE_TMP_BUFFER); + if (in == NULL) + return MEMORY_E; + XSTRNCPY(in, &argv[i+1][0], XSTRLEN(&argv[i+1][0])); in[XSTRLEN(argv[i+1])] = '\0'; inCheck = 1; @@ -154,6 +158,7 @@ int wolfsslHashSetup(int argc, char** argv) /* hashing function */ ret = wolfsslHash(in, out, alg, size); + XFREE(in, HEAP_HINT, DYNAMIC_TYPE_TMP_BUFFER); free(in); return ret; diff --git a/wolfCLU/src/tools/wolfsslHexToBin.c b/wolfCLU/src/tools/wolfsslHexToBin.c index 526550be..01035048 100644 --- a/wolfCLU/src/tools/wolfsslHexToBin.c +++ b/wolfCLU/src/tools/wolfsslHexToBin.c @@ -30,16 +30,22 @@ #include #include #include +#include "include/wolfssl.h" //#include /* free up to 5 binary buffers using wolfssl abstraction layer */ void wolfsslFreeBins(byte* b1, byte* b2, byte* b3, byte* b4, byte* b5) { - XFREE(b1, NULL, DYNAMIC_TYPE_TMP_BUFFER); - XFREE(b2, NULL, DYNAMIC_TYPE_TMP_BUFFER); - XFREE(b3, NULL, DYNAMIC_TYPE_TMP_BUFFER); - XFREE(b4, NULL, DYNAMIC_TYPE_TMP_BUFFER); - XFREE(b5, NULL, DYNAMIC_TYPE_TMP_BUFFER); + if (b1 != NULL) + XFREE(b1, HEAP_HINT, DYNAMIC_TYPE_TMP_BUFFER); + if (b2 != NULL) + XFREE(b2, HEAP_HINT, DYNAMIC_TYPE_TMP_BUFFER); + if (b3 != NULL) + XFREE(b3, HEAP_HINT, DYNAMIC_TYPE_TMP_BUFFER); + if (b4 != NULL) + XFREE(b4, HEAP_HINT, DYNAMIC_TYPE_TMP_BUFFER); + if (b5 != NULL) + XFREE(b5, HEAP_HINT, DYNAMIC_TYPE_TMP_BUFFER); } diff --git a/wolfCLU/src/wolfsslMain.c b/wolfCLU/src/wolfsslMain.c index d9b44579..0ef14f08 100644 --- a/wolfCLU/src/wolfsslMain.c +++ b/wolfCLU/src/wolfsslMain.c @@ -21,6 +21,7 @@ #include "include/wolfssl.h" #include "include/x509/wolfsslCert.h" +#include "include/optargs.h" /* enumerate optionals beyond ascii range to dis-allow use of alias IE we * do not want "-e" to work for encrypt, user must use "encrypt" @@ -40,19 +41,19 @@ int main(int argc, char** argv) switch (option) { /* Encrypt */ - case ENCRYPT: ret = wolfsslSetup(argc, argv, 'e'); + case ENCRYPT: ret = wolfsslSetup(argc, argv, 'e'); break; /* Decrypt */ - case DECRYPT: ret = wolfsslSetup(argc, argv, 'd');; + case DECRYPT: ret = wolfsslSetup(argc, argv, 'd');; break; /* Benchmark */ - case BENCHMARK:ret = wolfsslBenchSetup(argc, argv); + case BENCHMARK:ret = wolfsslBenchSetup(argc, argv); break; /* Hash */ - case HASH: ret = wolfsslHashSetup(argc, argv); + case HASH: ret = wolfsslHashSetup(argc, argv); break; - /* Certificate Stuff*/ - case X509: ret = wolfsslCertSetup(argc, argv, 'n'); + /* x509 Certificate processing */ + case X509: ret = wolfsslCertSetup(argc, argv); break; /* Ignore the following arguments for now. Will be handled by their respective @@ -76,6 +77,9 @@ int main(int argc, char** argv) case TIME: break; /* Verify results, used with -iv and -key */ case VERIFY: break; + /* Certificate Stuff*/ + case INFORM: break; + case OUTFORM: break; /* which version of clu am I using */ case VERBOSE: wolfsslVerboseHelp(); @@ -84,6 +88,7 @@ int main(int argc, char** argv) case 'v': wolfsslVersion(); return 0; + default: printf("Main help default.\n"); wolfsslHelp(); diff --git a/wolfCLU/src/x509/wolfsslCertSetup.c b/wolfCLU/src/x509/wolfsslCertSetup.c index ab422c2e..760dce51 100644 --- a/wolfCLU/src/x509/wolfsslCertSetup.c +++ b/wolfCLU/src/x509/wolfsslCertSetup.c @@ -22,23 +22,67 @@ #include #include +#include +#include "include/optargs.h" -int wolfsslCertSetup(int argc, char** argv, char action) +#ifdef WOLFSSL_STATIC_MEMORY + #include + static WOLFSSL_HEAP_HINT* HEAP_HINT; +#else + #define HEAP_HINT NULL +#endif + +int wolfsslCertSetup(int argc, char** argv) { - int i; /* loop counter */ + int i; + char* inform; + char* outform; + printf("In x509 loop\n"); for (i = 2; i < argc; i++) { + convert_to_lower(argv[i], (int) XSTRLEN(argv[i])); if (XSTRNCMP(argv[i], "-help", 5) == 0) { wolfsslCertHelp(); return 0; } else if (XSTRNCMP(argv[i], "-h", 2) == 0) { wolfsslCertHelp(); return 0; + } else if (XSTRNCMP(argv[i], "-inform", 7) == 0) { + + convert_to_lower(argv[i+1], (int) XSTRLEN(argv[i+1])); + inform = argv[i+1]; + + printf("inform is %s\n", inform); + + if (XSTRNCMP(inform, "pem", 3) == 0) + printf("IDENTIFIED PEM\n"); + if (XSTRNCMP(inform, "der", 3) == 0) + printf("IDENTIFIED DER\n"); + } else if (XSTRNCMP(argv[i], "-outform", 8) == 0) { + + convert_to_lower(argv[i+1], (int) XSTRLEN(argv[i+1])); + outform = argv[i+1]; + + printf("outform is %s\n", outform); + + if (XSTRNCMP(outform, "pem", 3) == 0) + printf("IDENTIFIED PEM\n"); + if (XSTRNCMP(outform, "der", 3) == 0) + printf("IDENTIFIED DER\n"); } } + return 0; } +void convert_to_lower(char* s, int sSz) +{ + int i; + for (i = 0; i < sSz; i++) { + s[i] = tolower(s[i]); + } +} + void wolfsslCertHelp() { printf("\n\n\nThis would be the certificate help.\n\n\n");