Add unique errors for every FKO_ERROR_INVALID_DATA. Needed this to
authorHank Leininger <hlein@korelogic.com>
Tue, 6 Aug 2013 02:21:10 +0000 (22:21 -0400)
committerHank Leininger <hlein@korelogic.com>
Tue, 6 Aug 2013 02:21:10 +0000 (22:21 -0400)
track down mystery errors (#98).

16 files changed:
lib/fko.h
lib/fko_client_timeout.c
lib/fko_decode.c
lib/fko_digest.c
lib/fko_encode.c
lib/fko_encryption.c
lib/fko_error.c
lib/fko_funcs.c
lib/fko_hmac.c
lib/fko_message.c
lib/fko_nat_access.c
lib/fko_rand_value.c
lib/fko_server_auth.c
lib/fko_timestamp.c
lib/fko_user.c
lib/fko_util.c

index c80866c..79407ce 100644 (file)
--- a/lib/fko.h
+++ b/lib/fko.h
@@ -180,6 +180,94 @@ typedef enum {
     FKO_ERROR_GPGME_BAD_SIGNATURE,
     FKO_ERROR_GPGME_SIGNATURE_VERIFY_DISABLED,
 
+    /* Start debugging invalid data errors */
+    FKO_ERROR_INVALID_DATA_CLIENT_TIMEOUT_NEGATIVE,
+    FKO_ERROR_INVALID_DATA_DECODE_MSGLEN_VALIDFAIL,
+    FKO_ERROR_INVALID_DATA_DECODE_NON_ASCII,
+    FKO_ERROR_INVALID_DATA_DECODE_LT_MIN_FIELDS,
+    FKO_ERROR_INVALID_DATA_DECODE_ENC_MSG_LEN_MT_T_SIZE,
+    FKO_ERROR_INVALID_DATA_DECODE_RAND_MISSING,
+    FKO_ERROR_INVALID_DATA_DECODE_USERNAME_MISSING,
+    FKO_ERROR_INVALID_DATA_DECODE_USERNAME_TOOBIG,
+    FKO_ERROR_INVALID_DATA_DECODE_USERNAME_DECODEFAIL,
+    FKO_ERROR_INVALID_DATA_DECODE_USERNAME_VALIDFAIL,
+    FKO_ERROR_INVALID_DATA_DECODE_TIMESTAMP_MISSING,
+    FKO_ERROR_INVALID_DATA_DECODE_TIMESTAMP_TOOBIG,
+    FKO_ERROR_INVALID_DATA_DECODE_TIMESTAMP_DECODEFAIL,
+    FKO_ERROR_INVALID_DATA_DECODE_VERSION_MISSING,
+    FKO_ERROR_INVALID_DATA_DECODE_VERSION_TOOBIG,
+    FKO_ERROR_INVALID_DATA_DECODE_MSGTYPE_MISSING,
+    FKO_ERROR_INVALID_DATA_DECODE_MSGTYPE_TOOBIG,
+    FKO_ERROR_INVALID_DATA_DECODE_MSGTYPE_DECODEFAIL,
+    FKO_ERROR_INVALID_DATA_DECODE_MESSAGE_MISSING,
+    FKO_ERROR_INVALID_DATA_DECODE_MESSAGE_TOOBIG,
+    FKO_ERROR_INVALID_DATA_DECODE_MESSAGE_DECODEFAIL,
+    FKO_ERROR_INVALID_DATA_DECODE_MESSAGE_VALIDFAIL,
+    FKO_ERROR_INVALID_DATA_DECODE_ACCESS_VALIDFAIL,
+    FKO_ERROR_INVALID_DATA_DECODE_NATACCESS_MISSING,
+    FKO_ERROR_INVALID_DATA_DECODE_NATACCESS_TOOBIG,
+    FKO_ERROR_INVALID_DATA_DECODE_NATACCESS_DECODEFAIL,
+    FKO_ERROR_INVALID_DATA_DECODE_NATACCESS_VALIDFAIL,
+    FKO_ERROR_INVALID_DATA_DECODE_SRVAUTH_MISSING,
+    FKO_ERROR_INVALID_DATA_DECODE_SRVAUTH_DECODEFAIL,
+    FKO_ERROR_INVALID_DATA_DECODE_SPA_EXTRA_TOOBIG,
+    FKO_ERROR_INVALID_DATA_DECODE_EXTRA_TOOBIG,
+    FKO_ERROR_INVALID_DATA_DECODE_EXTRA_DECODEFAIL,
+    FKO_ERROR_INVALID_DATA_DECODE_TIMEOUT_MISSING,
+    FKO_ERROR_INVALID_DATA_DECODE_TIMEOUT_TOOBIG,
+    FKO_ERROR_INVALID_DATA_DECODE_TIMEOUT_VALIDFAIL,
+    FKO_ERROR_INVALID_DATA_DECODE_TIMEOUT_DECODEFAIL,
+    FKO_ERROR_INVALID_DATA_ENCODE_MESSAGE_TOOBIG,
+    FKO_ERROR_INVALID_DATA_ENCODE_MSGLEN_VALIDFAIL,
+    FKO_ERROR_INVALID_DATA_ENCODE_DIGEST_VALIDFAIL,
+    FKO_ERROR_INVALID_DATA_ENCODE_DIGEST_TOOBIG,
+    FKO_ERROR_INVALID_DATA_ENCRYPT_MSGLEN_VALIDFAIL,
+    FKO_ERROR_INVALID_DATA_ENCRYPT_DIGESTLEN_VALIDFAIL,
+    FKO_ERROR_INVALID_DATA_ENCRYPT_PTLEN_VALIDFAIL,
+    FKO_ERROR_INVALID_DATA_ENCRYPT_RESULT_MSGLEN_VALIDFAIL,
+    FKO_ERROR_INVALID_DATA_ENCRYPT_CIPHERLEN_DECODEFAIL,
+    FKO_ERROR_INVALID_DATA_ENCRYPT_CIPHERLEN_VALIDFAIL,
+    FKO_ERROR_INVALID_DATA_ENCRYPT_DECRYPTED_MESSAGE_MISSING,
+    FKO_ERROR_INVALID_DATA_ENCRYPT_DECRYPTED_MSGLEN_VALIDFAIL,
+    FKO_ERROR_INVALID_DATA_ENCRYPT_GPG_MESSAGE_VALIDFAIL,
+    FKO_ERROR_INVALID_DATA_ENCRYPT_GPG_DIGEST_VALIDFAIL,
+    FKO_ERROR_INVALID_DATA_ENCRYPT_GPG_MSGLEN_VALIDFAIL,
+    FKO_ERROR_INVALID_DATA_ENCRYPT_GPG_RESULT_MSGLEN_VALIDFAIL,
+    FKO_ERROR_INVALID_DATA_ENCRYPT_GPG_CIPHER_DECODEFAIL,
+    FKO_ERROR_INVALID_DATA_ENCRYPT_GPG_ENCODEDMSG_NULL,
+    FKO_ERROR_INVALID_DATA_ENCRYPT_GPG_ENCODEDMSGLEN_VALIDFAIL,
+    FKO_ERROR_INVALID_DATA_ENCRYPT_TYPE_VALIDFAIL,
+    FKO_ERROR_INVALID_DATA_ENCRYPT_MODE_VALIDFAIL,
+    FKO_ERROR_INVALID_DATA_ENCRYPT_TYPE_UNKNOWN,
+    FKO_ERROR_INVALID_DATA_FUNCS_NEW_ENCMSG_MISSING,
+    FKO_ERROR_INVALID_DATA_FUNCS_NEW_MSGLEN_VALIDFAIL,
+    FKO_ERROR_INVALID_DATA_FUNCS_GEN_KEYLEN_VALIDFAIL,
+    FKO_ERROR_INVALID_DATA_FUNCS_GEN_HMACLEN_VALIDFAIL,
+    FKO_ERROR_INVALID_DATA_FUNCS_GEN_KEY_ENCODEFAIL,
+    FKO_ERROR_INVALID_DATA_FUNCS_GEN_HMAC_ENCODEFAIL,
+    FKO_ERROR_INVALID_DATA_FUNCS_SET_MSGLEN_VALIDFAIL,
+    FKO_ERROR_INVALID_DATA_HMAC_MSGLEN_VALIDFAIL,
+    FKO_ERROR_INVALID_DATA_HMAC_ENCMSGLEN_VALIDFAIL,
+    FKO_ERROR_INVALID_DATA_HMAC_COMPAREFAIL,
+    FKO_ERROR_INVALID_DATA_HMAC_TYPE_VALIDFAIL,
+    FKO_ERROR_INVALID_DATA_HMAC_LEN_VALIDFAIL,
+    FKO_ERROR_INVALID_DATA_MESSAGE_PORT_MISSING,
+    FKO_ERROR_INVALID_DATA_MESSAGE_TYPE_VALIDFAIL,
+    FKO_ERROR_INVALID_DATA_MESSAGE_EMPTY,
+    FKO_ERROR_INVALID_DATA_MESSAGE_CMD_MISSING,
+    FKO_ERROR_INVALID_DATA_MESSAGE_ACCESS_MISSING,
+    FKO_ERROR_INVALID_DATA_MESSAGE_NAT_MISSING,
+    FKO_ERROR_INVALID_DATA_MESSAGE_PORTPROTO_MISSING,
+    FKO_ERROR_INVALID_DATA_NAT_EMPTY,
+    FKO_ERROR_INVALID_DATA_RAND_LEN_VALIDFAIL,
+    FKO_ERROR_INVALID_DATA_SRVAUTH_MISSING,
+    FKO_ERROR_INVALID_DATA_TIMESTAMP_VALIDFAIL,
+    FKO_ERROR_INVALID_DATA_USER_MISSING,
+    FKO_ERROR_INVALID_DATA_USER_FIRSTCHAR_VALIDFAIL,
+    FKO_ERROR_INVALID_DATA_USER_REMCHAR_VALIDFAIL,
+    FKO_ERROR_INVALID_DATA_UTIL_STRTOL_LT_MIN,
+    FKO_ERROR_INVALID_DATA_UTIL_STROL_GT_MAX,
+
     FKO_LAST_ERROR
 } fko_error_codes_t;
 
index d22be96..6544ead 100644 (file)
@@ -46,7 +46,7 @@ fko_set_spa_client_timeout(fko_ctx_t ctx, const int timeout)
     /* Gotta have a valid string.
     */
     if(timeout < 0)
-        return(FKO_ERROR_INVALID_DATA);
+        return(FKO_ERROR_INVALID_DATA_CLIENT_TIMEOUT_NEGATIVE);
 
     old_msg_type = ctx->message_type;
 
index cfceff7..2737140 100644 (file)
@@ -43,13 +43,13 @@ fko_decode_spa_data(fko_ctx_t ctx)
     int         t_size, i, is_err;
 
     if (! is_valid_encoded_msg_len(ctx->encoded_msg_len))
-        return(FKO_ERROR_INVALID_DATA);
+        return(FKO_ERROR_INVALID_DATA_DECODE_MSGLEN_VALIDFAIL);
 
     /* Make sure there are no non-ascii printable chars
     */
     for (i=0; i < (int)strnlen(ctx->encoded_msg, MAX_SPA_ENCODED_MSG_SIZE); i++)
         if(isprint(ctx->encoded_msg[i]) == 0)
-            return(FKO_ERROR_INVALID_DATA);
+            return(FKO_ERROR_INVALID_DATA_DECODE_NON_ASCII);
 
     /* Make sure there are enough fields in the SPA packet
      * delimited with ':' chars
@@ -65,7 +65,7 @@ fko_decode_spa_data(fko_ctx_t ctx)
     }
 
     if (i < MIN_SPA_FIELDS)
-        return(FKO_ERROR_INVALID_DATA);
+        return(FKO_ERROR_INVALID_DATA_DECODE_LT_MIN_FIELDS);
 
     t_size = strnlen(ndx, SHA512_B64_LEN+1);
 
@@ -101,7 +101,7 @@ fko_decode_spa_data(fko_ctx_t ctx)
     }
 
     if (ctx->encoded_msg_len - t_size < 0)
-        return(FKO_ERROR_INVALID_DATA);
+        return(FKO_ERROR_INVALID_DATA_DECODE_ENC_MSG_LEN_MT_T_SIZE);
 
     if(ctx->digest != NULL)
         free(ctx->digest);
@@ -170,7 +170,7 @@ fko_decode_spa_data(fko_ctx_t ctx)
     if((t_size = strcspn(ndx, ":")) < FKO_RAND_VAL_SIZE)
     {
         free(tbuf);
-        return(FKO_ERROR_INVALID_DATA);
+        return(FKO_ERROR_INVALID_DATA_DECODE_RAND_MISSING);
     }
 
     if(ctx->rand_val != NULL)
@@ -191,13 +191,13 @@ fko_decode_spa_data(fko_ctx_t ctx)
     if((t_size = strcspn(ndx, ":")) < 1)
     {
         free(tbuf);
-        return(FKO_ERROR_INVALID_DATA);
+        return(FKO_ERROR_INVALID_DATA_DECODE_USERNAME_MISSING);
     }
 
     if (t_size > MAX_SPA_USERNAME_SIZE)
     {
         free(tbuf);
-        return(FKO_ERROR_INVALID_DATA);
+        return(FKO_ERROR_INVALID_DATA_DECODE_USERNAME_TOOBIG);
     }
 
     strlcpy(tbuf, ndx, t_size+1);
@@ -215,12 +215,12 @@ fko_decode_spa_data(fko_ctx_t ctx)
     if(b64_decode(tbuf, (unsigned char*)ctx->username) < 0)
     {
         free(tbuf);
-        return(FKO_ERROR_INVALID_DATA);
+        return(FKO_ERROR_INVALID_DATA_DECODE_USERNAME_DECODEFAIL);
     }
     if(validate_username(ctx->username) != FKO_SUCCESS)
     {
         free(tbuf);
-        return(FKO_ERROR_INVALID_DATA);
+        return(FKO_ERROR_INVALID_DATA_DECODE_USERNAME_VALIDFAIL);
     }
 
     /* Extract the timestamp value.
@@ -229,13 +229,13 @@ fko_decode_spa_data(fko_ctx_t ctx)
     if((t_size = strcspn(ndx, ":")) < 1)
     {
         free(tbuf);
-        return(FKO_ERROR_INVALID_DATA);
+        return(FKO_ERROR_INVALID_DATA_DECODE_TIMESTAMP_MISSING);
     }
 
     if (t_size > MAX_SPA_TIMESTAMP_SIZE)
     {
         free(tbuf);
-        return(FKO_ERROR_INVALID_DATA);
+        return(FKO_ERROR_INVALID_DATA_DECODE_TIMESTAMP_TOOBIG);
     }
 
     strlcpy(tbuf, ndx, t_size+1);
@@ -245,7 +245,7 @@ fko_decode_spa_data(fko_ctx_t ctx)
     if(is_err != FKO_SUCCESS)
     {
         free(tbuf);
-        return(FKO_ERROR_INVALID_DATA);
+        return(FKO_ERROR_INVALID_DATA_DECODE_TIMESTAMP_DECODEFAIL);
     }
 
     /* Extract the version string.
@@ -254,13 +254,13 @@ fko_decode_spa_data(fko_ctx_t ctx)
     if((t_size = strcspn(ndx, ":")) < 1)
     {
         free(tbuf);
-        return(FKO_ERROR_INVALID_DATA);
+        return(FKO_ERROR_INVALID_DATA_DECODE_VERSION_MISSING);
     }
 
     if (t_size > MAX_SPA_VERSION_SIZE)
     {
         free(tbuf);
-        return(FKO_ERROR_INVALID_DATA);
+        return(FKO_ERROR_INVALID_DATA_DECODE_VERSION_TOOBIG);
     }
 
     if(ctx->version != NULL)
@@ -281,13 +281,13 @@ fko_decode_spa_data(fko_ctx_t ctx)
     if((t_size = strcspn(ndx, ":")) < 1)
     {
         free(tbuf);
-        return(FKO_ERROR_INVALID_DATA);
+        return(FKO_ERROR_INVALID_DATA_DECODE_MSGTYPE_MISSING);
     }
 
     if (t_size > MAX_SPA_MESSAGE_TYPE_SIZE)
     {
         free(tbuf);
-        return(FKO_ERROR_INVALID_DATA);
+        return(FKO_ERROR_INVALID_DATA_DECODE_MSGTYPE_TOOBIG);
     }
 
     strlcpy(tbuf, ndx, t_size+1);
@@ -297,7 +297,7 @@ fko_decode_spa_data(fko_ctx_t ctx)
     if(is_err != FKO_SUCCESS)
     {
         free(tbuf);
-        return(FKO_ERROR_INVALID_DATA);
+        return(FKO_ERROR_INVALID_DATA_DECODE_MSGTYPE_DECODEFAIL);
     }
 
     /* Extract the SPA message string.
@@ -306,13 +306,13 @@ fko_decode_spa_data(fko_ctx_t ctx)
     if((t_size = strcspn(ndx, ":")) < 1)
     {
         free(tbuf);
-        return(FKO_ERROR_INVALID_DATA);
+        return(FKO_ERROR_INVALID_DATA_DECODE_MESSAGE_MISSING);
     }
 
     if (t_size > MAX_SPA_MESSAGE_SIZE)
     {
         free(tbuf);
-        return(FKO_ERROR_INVALID_DATA);
+        return(FKO_ERROR_INVALID_DATA_DECODE_MESSAGE_TOOBIG);
     }
 
     strlcpy(tbuf, ndx, t_size+1);
@@ -330,7 +330,7 @@ fko_decode_spa_data(fko_ctx_t ctx)
     if(b64_decode(tbuf, (unsigned char*)ctx->message) < 0)
     {
         free(tbuf);
-        return(FKO_ERROR_INVALID_DATA);
+        return(FKO_ERROR_INVALID_DATA_DECODE_MESSAGE_DECODEFAIL);
     }
 
     if(ctx->message_type == FKO_COMMAND_MSG)
@@ -340,7 +340,7 @@ fko_decode_spa_data(fko_ctx_t ctx)
         if(validate_cmd_msg(ctx->message) != FKO_SUCCESS)
         {
             free(tbuf);
-            return(FKO_ERROR_INVALID_DATA);
+            return(FKO_ERROR_INVALID_DATA_DECODE_MESSAGE_VALIDFAIL);
         }
     }
     else
@@ -350,7 +350,7 @@ fko_decode_spa_data(fko_ctx_t ctx)
         if(validate_access_msg(ctx->message) != FKO_SUCCESS)
         {
             free(tbuf);
-            return(FKO_ERROR_INVALID_DATA);
+            return(FKO_ERROR_INVALID_DATA_DECODE_ACCESS_VALIDFAIL);
         }
     }
 
@@ -365,13 +365,13 @@ fko_decode_spa_data(fko_ctx_t ctx)
         if((t_size = strcspn(ndx, ":")) < 1)
         {
             free(tbuf);
-            return(FKO_ERROR_INVALID_DATA);
+            return(FKO_ERROR_INVALID_DATA_DECODE_NATACCESS_MISSING);
         }
 
         if (t_size > MAX_SPA_MESSAGE_SIZE)
         {
             free(tbuf);
-            return(FKO_ERROR_INVALID_DATA);
+            return(FKO_ERROR_INVALID_DATA_DECODE_NATACCESS_TOOBIG);
         }
 
         strlcpy(tbuf, ndx, t_size+1);
@@ -389,13 +389,13 @@ fko_decode_spa_data(fko_ctx_t ctx)
         if(b64_decode(tbuf, (unsigned char*)ctx->nat_access) < 0)
         {
             free(tbuf);
-            return(FKO_ERROR_INVALID_DATA);
+            return(FKO_ERROR_INVALID_DATA_DECODE_NATACCESS_DECODEFAIL);
         }
 
         if(validate_nat_access_msg(ctx->nat_access) != FKO_SUCCESS)
         {
             free(tbuf);
-            return(FKO_ERROR_INVALID_DATA);
+            return(FKO_ERROR_INVALID_DATA_DECODE_NATACCESS_VALIDFAIL);
         }
     }
 
@@ -407,7 +407,7 @@ fko_decode_spa_data(fko_ctx_t ctx)
         if (t_size > MAX_SPA_MESSAGE_SIZE)
         {
             free(tbuf);
-            return(FKO_ERROR_INVALID_DATA);
+            return(FKO_ERROR_INVALID_DATA_DECODE_SRVAUTH_MISSING);
         }
 
         /* There is data, but what is it?
@@ -433,7 +433,7 @@ fko_decode_spa_data(fko_ctx_t ctx)
             if(b64_decode(tbuf, (unsigned char*)ctx->server_auth) < 0)
             {
                 free(tbuf);
-                return(FKO_ERROR_INVALID_DATA);
+                return(FKO_ERROR_INVALID_DATA_DECODE_SRVAUTH_DECODEFAIL);
             }
 
             /* At this point we should be done.
@@ -460,7 +460,7 @@ fko_decode_spa_data(fko_ctx_t ctx)
             if (t_size > MAX_SPA_MESSAGE_SIZE)
             {
                 free(tbuf);
-                return(FKO_ERROR_INVALID_DATA);
+                return(FKO_ERROR_INVALID_DATA_DECODE_EXTRA_TOOBIG);
             }
 
             /* Looks like we have both, so assume this is the 
@@ -480,7 +480,7 @@ fko_decode_spa_data(fko_ctx_t ctx)
             if(b64_decode(tbuf, (unsigned char*)ctx->server_auth) < 0)
             {
                 free(tbuf);
-                return(FKO_ERROR_INVALID_DATA);
+                return(FKO_ERROR_INVALID_DATA_DECODE_EXTRA_DECODEFAIL);
             }
 
             ndx += t_size + 1;
@@ -495,12 +495,12 @@ fko_decode_spa_data(fko_ctx_t ctx)
             if((t_size = strlen(ndx)) < 1)
             {
                 free(tbuf);
-                return(FKO_ERROR_INVALID_DATA);
+                return(FKO_ERROR_INVALID_DATA_DECODE_TIMEOUT_MISSING);
             }
             if (t_size > MAX_SPA_MESSAGE_SIZE)
             {
                 free(tbuf);
-                return(FKO_ERROR_INVALID_DATA);
+                return(FKO_ERROR_INVALID_DATA_DECODE_TIMEOUT_TOOBIG);
             }
 
             /* Should be a number only.
@@ -508,7 +508,7 @@ fko_decode_spa_data(fko_ctx_t ctx)
             if(strspn(ndx, "0123456789") != t_size)
             {
                 free(tbuf);
-                return(FKO_ERROR_INVALID_DATA);
+                return(FKO_ERROR_INVALID_DATA_DECODE_TIMEOUT_VALIDFAIL);
             }
 
             ctx->client_timeout = (unsigned int) strtol_wrapper(ndx, 0,
@@ -516,7 +516,7 @@ fko_decode_spa_data(fko_ctx_t ctx)
             if(is_err != FKO_SUCCESS)
             {
                 free(tbuf);
-                return(FKO_ERROR_INVALID_DATA);
+                return(FKO_ERROR_INVALID_DATA_DECODE_TIMEOUT_DECODEFAIL);
             }
         }
     }
index 20314c7..81f2551 100644 (file)
@@ -46,7 +46,7 @@ set_spa_digest_type(fko_ctx_t ctx,
         return(FKO_ERROR_CTX_NOT_INITIALIZED);
 
     if(digest_type < 1 || digest_type >= FKO_LAST_DIGEST_TYPE)
-        return(FKO_ERROR_INVALID_DATA);
+        return(FKO_ERROR_INVALID_DATA_ENCODE_DIGEST_VALIDFAIL);
 
     *digest_type_field = digest_type;
 
@@ -106,7 +106,7 @@ set_digest(char *data, char **digest, short digest_type, int *digest_len)
     data_len = strnlen(data, MAX_SPA_ENCODED_MSG_SIZE);
 
     if(data_len == MAX_SPA_ENCODED_MSG_SIZE)
-        return(FKO_ERROR_INVALID_DATA);
+        return(FKO_ERROR_INVALID_DATA_ENCODE_DIGEST_TOOBIG);
 
     switch(digest_type)
     {
index d718974..c9b53cb 100644 (file)
@@ -45,7 +45,7 @@ append_b64(char* tbuf, char *str)
     char *bs;
 
     if(len >= MAX_SPA_ENCODED_MSG_SIZE)
-        return(FKO_ERROR_INVALID_DATA);
+        return(FKO_ERROR_INVALID_DATA_ENCODE_MESSAGE_TOOBIG);
 
     bs = malloc(((len/3)*4)+8);
     if(bs == NULL)
@@ -201,7 +201,7 @@ fko_encode_spa_data(fko_ctx_t ctx)
     ctx->encoded_msg_len = strnlen(ctx->encoded_msg, MAX_SPA_ENCODED_MSG_SIZE);
 
     if(! is_valid_encoded_msg_len(ctx->encoded_msg_len))
-        return(FKO_ERROR_INVALID_DATA);
+        return(FKO_ERROR_INVALID_DATA_ENCODE_MSGLEN_VALIDFAIL);
 
     /* At this point we can compute the digest for this SPA data.
     */
index 9698b16..5e82af7 100644 (file)
@@ -57,7 +57,7 @@ _rijndael_encrypt(fko_ctx_t ctx, const char *enc_key, const int enc_key_len)
         return(FKO_ERROR_INVALID_KEY_LEN);
 
     if (! is_valid_encoded_msg_len(ctx->encoded_msg_len))
-        return(FKO_ERROR_INVALID_DATA);
+        return(FKO_ERROR_INVALID_DATA_ENCRYPT_MSGLEN_VALIDFAIL);
 
     switch(ctx->digest_len)
     {
@@ -72,7 +72,7 @@ _rijndael_encrypt(fko_ctx_t ctx, const char *enc_key, const int enc_key_len)
         case SHA512_B64_LEN:
             break;
         default:
-            return(FKO_ERROR_INVALID_DATA);
+            return(FKO_ERROR_INVALID_DATA_ENCRYPT_DIGESTLEN_VALIDFAIL);
     }
 
     pt_len = ctx->encoded_msg_len + ctx->digest_len + RIJNDAEL_BLOCKSIZE + 2;
@@ -90,7 +90,7 @@ _rijndael_encrypt(fko_ctx_t ctx, const char *enc_key, const int enc_key_len)
     if(! is_valid_pt_msg_len(pt_len))
     {
         if(zero_free(plaintext, pt_len) == FKO_SUCCESS)
-            return(FKO_ERROR_INVALID_DATA);
+            return(FKO_ERROR_INVALID_DATA_ENCRYPT_PTLEN_VALIDFAIL);
         else
             return(FKO_ERROR_ZERO_OUT_DATA);
     }
@@ -150,7 +150,7 @@ _rijndael_encrypt(fko_ctx_t ctx, const char *enc_key, const int enc_key_len)
         return(FKO_ERROR_MEMORY_ALLOCATION);
 
     if(! is_valid_encoded_msg_len(ctx->encrypted_msg_len))
-        return(FKO_ERROR_INVALID_DATA);
+        return(FKO_ERROR_INVALID_DATA_ENCRYPT_RESULT_MSGLEN_VALIDFAIL);
 
     return(zero_free_rv);
 }
@@ -189,7 +189,7 @@ _rijndael_decrypt(fko_ctx_t ctx,
     if((cipher_len = b64_decode(ctx->encrypted_msg, cipher)) < 0)
     {
         if(zero_free((char *)cipher, ctx->encrypted_msg_len) == FKO_SUCCESS)
-            return(FKO_ERROR_INVALID_DATA);
+            return(FKO_ERROR_INVALID_DATA_ENCRYPT_CIPHERLEN_DECODEFAIL);
         else
             return(FKO_ERROR_ZERO_OUT_DATA);
     }
@@ -200,7 +200,7 @@ _rijndael_decrypt(fko_ctx_t ctx,
     if((cipher_len % RIJNDAEL_BLOCKSIZE) != 0)
     {
         if(zero_free((char *)cipher, ctx->encrypted_msg_len) == FKO_SUCCESS)
-            return(FKO_ERROR_INVALID_DATA);
+            return(FKO_ERROR_INVALID_DATA_ENCRYPT_CIPHERLEN_VALIDFAIL);
         else
             return(FKO_ERROR_ZERO_OUT_DATA);
     }
@@ -236,10 +236,10 @@ _rijndael_decrypt(fko_ctx_t ctx,
         return(FKO_ERROR_DECRYPTION_SIZE);
 
     if(ctx->encoded_msg == NULL)
-        return(FKO_ERROR_INVALID_DATA);
+        return(FKO_ERROR_INVALID_DATA_ENCRYPT_GPG_ENCODEDMSG_NULL);
 
     if(! is_valid_encoded_msg_len(pt_len))
-        return(FKO_ERROR_INVALID_DATA);
+        return(FKO_ERROR_INVALID_DATA_ENCRYPT_GPG_ENCODEDMSGLEN_VALIDFAIL);
 
     if(zero_free_rv != FKO_SUCCESS)
         return(zero_free_rv);
@@ -281,7 +281,7 @@ gpg_encrypt(fko_ctx_t ctx, const char *enc_key)
     char           *empty_key = "";
 
     if (! is_valid_encoded_msg_len(ctx->encoded_msg_len))
-        return(FKO_ERROR_INVALID_DATA);
+        return(FKO_ERROR_INVALID_DATA_ENCRYPT_GPG_MESSAGE_VALIDFAIL);
 
     switch(ctx->digest_len)
     {
@@ -296,7 +296,7 @@ gpg_encrypt(fko_ctx_t ctx, const char *enc_key)
         case SHA512_B64_LEN:
             break;
         default:
-            return(FKO_ERROR_INVALID_DATA);
+            return(FKO_ERROR_INVALID_DATA_ENCRYPT_GPG_DIGEST_VALIDFAIL);
     }
 
     /* First make sure we have a recipient key set.
@@ -318,7 +318,7 @@ gpg_encrypt(fko_ctx_t ctx, const char *enc_key)
     if(! is_valid_pt_msg_len(pt_len))
     {
         if(zero_free(plain, pt_len) == FKO_SUCCESS)
-            return(FKO_ERROR_INVALID_DATA);
+            return(FKO_ERROR_INVALID_DATA_ENCRYPT_GPG_MSGLEN_VALIDFAIL);
         else
             return(FKO_ERROR_ZERO_OUT_DATA);
     }
@@ -396,7 +396,7 @@ gpg_encrypt(fko_ctx_t ctx, const char *enc_key)
         return(FKO_ERROR_MEMORY_ALLOCATION);
 
     if(! is_valid_encoded_msg_len(ctx->encrypted_msg_len))
-        return(FKO_ERROR_INVALID_DATA);
+        return(FKO_ERROR_INVALID_DATA_ENCRYPT_GPG_RESULT_MSGLEN_VALIDFAIL);
 
     return(zero_free_rv);
 }
@@ -426,7 +426,7 @@ gpg_decrypt(fko_ctx_t ctx, const char *dec_key)
     if((b64_decode_len = b64_decode(ctx->encrypted_msg, cipher)) < 0)
     {
         if(zero_free((char *) cipher, ctx->encrypted_msg_len) == FKO_SUCCESS)
-            return(FKO_ERROR_INVALID_DATA);
+            return(FKO_ERROR_INVALID_DATA_ENCRYPT_GPG_CIPHER_DECODEFAIL);
         else
             return(FKO_ERROR_ZERO_OUT_DATA);
 
@@ -461,10 +461,10 @@ gpg_decrypt(fko_ctx_t ctx, const char *dec_key)
     pt_len = strnlen(ctx->encoded_msg, MAX_SPA_ENCODED_MSG_SIZE);
 
     if(ctx->encoded_msg == NULL)
-        return(FKO_ERROR_INVALID_DATA);
+        return(FKO_ERROR_INVALID_DATA_ENCRYPT_DECRYPTED_MESSAGE_MISSING);
 
     if(! is_valid_encoded_msg_len(pt_len))
-        return(FKO_ERROR_INVALID_DATA);
+        return(FKO_ERROR_INVALID_DATA_ENCRYPT_DECRYPTED_MSGLEN_VALIDFAIL);
 
     ctx->encoded_msg_len = pt_len;
 
@@ -486,7 +486,7 @@ fko_set_spa_encryption_type(fko_ctx_t ctx, const short encrypt_type)
         return(FKO_ERROR_CTX_NOT_INITIALIZED);
 
     if(encrypt_type < 0 || encrypt_type >= FKO_LAST_ENCRYPTION_TYPE)
-        return(FKO_ERROR_INVALID_DATA);
+        return(FKO_ERROR_INVALID_DATA_ENCRYPT_TYPE_VALIDFAIL);
 
     ctx->encryption_type = encrypt_type;
 
@@ -521,7 +521,7 @@ fko_set_spa_encryption_mode(fko_ctx_t ctx, const int encrypt_mode)
         return(FKO_ERROR_CTX_NOT_INITIALIZED);
 
     if(encrypt_mode < 0 || encrypt_mode >= FKO_LAST_ENC_MODE)
-        return(FKO_ERROR_INVALID_DATA);
+        return(FKO_ERROR_INVALID_DATA_ENCRYPT_MODE_VALIDFAIL);
 
     ctx->encryption_mode = encrypt_mode;
 
@@ -621,7 +621,7 @@ fko_decrypt_spa_data(fko_ctx_t ctx, const char * const dec_key, const int key_le
             dec_key, key_len, ctx->encryption_mode);
     }
     else
-        return(FKO_ERROR_INVALID_DATA);
+        return(FKO_ERROR_INVALID_DATA_ENCRYPT_TYPE_UNKNOWN);
 
     return(res);
 }
index 546e674..cf552dc 100644 (file)
@@ -57,6 +57,261 @@ fko_errstr(const int err_code)
         case FKO_ERROR_INVALID_DATA:
             return("Args contain invalid data");
 
+        case FKO_ERROR_INVALID_DATA_CLIENT_TIMEOUT_NEGATIVE:
+            return("Args contain invalid data: FKO_ERROR_INVALID_DATA_CLIENT_TIMEOUT_NEGATIVE");
+
+        case FKO_ERROR_INVALID_DATA_DECODE_MSGLEN_VALIDFAIL:
+            return("Args contain invalid data: FKO_ERROR_INVALID_DATA_DECODE_MSGLEN_VALIDFAIL");
+
+        case FKO_ERROR_INVALID_DATA_DECODE_NON_ASCII:
+            return("Args contain invalid data: FKO_ERROR_INVALID_DATA_DECODE_NON_ASCII");
+
+        case FKO_ERROR_INVALID_DATA_DECODE_LT_MIN_FIELDS:
+            return("Args contain invalid data: FKO_ERROR_INVALID_DATA_DECODE_LT_MIN_FIELDS");
+
+        case FKO_ERROR_INVALID_DATA_DECODE_ENC_MSG_LEN_MT_T_SIZE:
+            return("Args contain invalid data: FKO_ERROR_INVALID_DATA_DECODE_ENC_MSG_LEN_MT_T_SIZE");
+
+        case FKO_ERROR_INVALID_DATA_DECODE_RAND_MISSING:
+            return("Args contain invalid data: FKO_ERROR_INVALID_DATA_DECODE_RAND_MISSING");
+
+        case FKO_ERROR_INVALID_DATA_DECODE_USERNAME_MISSING:
+            return("Args contain invalid data: FKO_ERROR_INVALID_DATA_DECODE_USERNAME_MISSING");
+
+        case FKO_ERROR_INVALID_DATA_DECODE_USERNAME_TOOBIG:
+            return("Args contain invalid data: FKO_ERROR_INVALID_DATA_DECODE_USERNAME_TOOBIG");
+
+        case FKO_ERROR_INVALID_DATA_DECODE_USERNAME_DECODEFAIL:
+            return("Args contain invalid data: FKO_ERROR_INVALID_DATA_DECODE_USERNAME_DECODEFAIL");
+
+        case FKO_ERROR_INVALID_DATA_DECODE_USERNAME_VALIDFAIL:
+            return("Args contain invalid data: FKO_ERROR_INVALID_DATA_DECODE_USERNAME_VALIDFAIL");
+
+        case FKO_ERROR_INVALID_DATA_DECODE_TIMESTAMP_MISSING:
+            return("Args contain invalid data: FKO_ERROR_INVALID_DATA_DECODE_TIMESTAMP_MISSING");
+
+        case FKO_ERROR_INVALID_DATA_DECODE_TIMESTAMP_TOOBIG:
+            return("Args contain invalid data: FKO_ERROR_INVALID_DATA_DECODE_TIMESTAMP_TOOBIG");
+
+        case FKO_ERROR_INVALID_DATA_DECODE_TIMESTAMP_DECODEFAIL:
+            return("Args contain invalid data: FKO_ERROR_INVALID_DATA_DECODE_TIMESTAMP_DECODEFAIL");
+
+        case FKO_ERROR_INVALID_DATA_DECODE_VERSION_MISSING:
+            return("Args contain invalid data: FKO_ERROR_INVALID_DATA_DECODE_VERSION_MISSING");
+
+        case FKO_ERROR_INVALID_DATA_DECODE_VERSION_TOOBIG:
+            return("Args contain invalid data: FKO_ERROR_INVALID_DATA_DECODE_VERSION_TOOBIG");
+
+        case FKO_ERROR_INVALID_DATA_DECODE_MSGTYPE_MISSING:
+            return("Args contain invalid data: FKO_ERROR_INVALID_DATA_DECODE_MSGTYPE_MISSING");
+
+        case FKO_ERROR_INVALID_DATA_DECODE_MSGTYPE_TOOBIG:
+            return("Args contain invalid data: FKO_ERROR_INVALID_DATA_DECODE_MSGTYPE_TOOBIG");
+
+        case FKO_ERROR_INVALID_DATA_DECODE_MSGTYPE_DECODEFAIL:
+            return("Args contain invalid data: FKO_ERROR_INVALID_DATA_DECODE_MSGTYPE_DECODEFAIL");
+
+        case FKO_ERROR_INVALID_DATA_DECODE_MESSAGE_MISSING:
+            return("Args contain invalid data: FKO_ERROR_INVALID_DATA_DECODE_MESSAGE_MISSING");
+
+        case FKO_ERROR_INVALID_DATA_DECODE_MESSAGE_TOOBIG:
+            return("Args contain invalid data: FKO_ERROR_INVALID_DATA_DECODE_MESSAGE_TOOBIG");
+
+        case FKO_ERROR_INVALID_DATA_DECODE_MESSAGE_DECODEFAIL:
+            return("Args contain invalid data: FKO_ERROR_INVALID_DATA_DECODE_MESSAGE_DECODEFAIL");
+
+        case FKO_ERROR_INVALID_DATA_DECODE_MESSAGE_VALIDFAIL:
+            return("Args contain invalid data: FKO_ERROR_INVALID_DATA_DECODE_MESSAGE_VALIDFAIL");
+
+        case FKO_ERROR_INVALID_DATA_DECODE_ACCESS_VALIDFAIL:
+            return("Args contain invalid data: FKO_ERROR_INVALID_DATA_DECODE_ACCESS_VALIDFAIL");
+
+        case FKO_ERROR_INVALID_DATA_DECODE_NATACCESS_MISSING:
+            return("Args contain invalid data: FKO_ERROR_INVALID_DATA_DECODE_NATACCESS_MISSING");
+
+        case FKO_ERROR_INVALID_DATA_DECODE_NATACCESS_TOOBIG:
+            return("Args contain invalid data: FKO_ERROR_INVALID_DATA_DECODE_NATACCESS_TOOBIG");
+
+        case FKO_ERROR_INVALID_DATA_DECODE_NATACCESS_DECODEFAIL:
+            return("Args contain invalid data: FKO_ERROR_INVALID_DATA_DECODE_NATACCESS_DECODEFAIL");
+
+        case FKO_ERROR_INVALID_DATA_DECODE_NATACCESS_VALIDFAIL:
+            return("Args contain invalid data: FKO_ERROR_INVALID_DATA_DECODE_NATACCESS_VALIDFAIL");
+
+        case FKO_ERROR_INVALID_DATA_DECODE_SRVAUTH_MISSING:
+            return("Args contain invalid data: FKO_ERROR_INVALID_DATA_DECODE_SRVAUTH_MISSING");
+
+        case FKO_ERROR_INVALID_DATA_DECODE_SRVAUTH_DECODEFAIL:
+            return("Args contain invalid data: FKO_ERROR_INVALID_DATA_DECODE_SRVAUTH_DECODEFAIL");
+
+        case FKO_ERROR_INVALID_DATA_DECODE_SPA_EXTRA_TOOBIG:
+            return("Args contain invalid data: FKO_ERROR_INVALID_DATA_DECODE_SPA_EXTRA_TOOBIG");
+
+        case FKO_ERROR_INVALID_DATA_DECODE_EXTRA_DECODEFAIL:
+            return("Args contain invalid data: FKO_ERROR_INVALID_DATA_DECODE_EXTRA_DECODEFAIL");
+
+        case FKO_ERROR_INVALID_DATA_DECODE_TIMEOUT_MISSING:
+            return("Args contain invalid data: FKO_ERROR_INVALID_DATA_DECODE_TIMEOUT_MISSING");
+
+        case FKO_ERROR_INVALID_DATA_DECODE_TIMEOUT_TOOBIG:
+            return("Args contain invalid data: FKO_ERROR_INVALID_DATA_DECODE_TIMEOUT_TOOBIG");
+
+        case FKO_ERROR_INVALID_DATA_DECODE_TIMEOUT_VALIDFAIL:
+            return("Args contain invalid data: FKO_ERROR_INVALID_DATA_DECODE_TIMEOUT_VALIDFAIL");
+
+        case FKO_ERROR_INVALID_DATA_DECODE_TIMEOUT_DECODEFAIL:
+            return("Args contain invalid data: FKO_ERROR_INVALID_DATA_DECODE_TIMEOUT_DECODEFAIL");
+
+        case FKO_ERROR_INVALID_DATA_ENCODE_MESSAGE_TOOBIG:
+            return("Args contain invalid data: FKO_ERROR_INVALID_DATA_ENCODE_MESSAGE_TOOBIG");
+
+        case FKO_ERROR_INVALID_DATA_ENCODE_MSGLEN_VALIDFAIL:
+            return("Args contain invalid data: FKO_ERROR_INVALID_DATA_ENCODE_MSGLEN_VALIDFAIL");
+
+        case FKO_ERROR_INVALID_DATA_ENCODE_DIGEST_VALIDFAIL:
+            return("Args contain invalid data: FKO_ERROR_INVALID_DATA_ENCODE_DIGEST_VALIDFAIL");
+
+        case FKO_ERROR_INVALID_DATA_ENCODE_DIGEST_TOOBIG:
+            return("Args contain invalid data: FKO_ERROR_INVALID_DATA_ENCODE_DIGEST_TOOBIG");
+
+        case FKO_ERROR_INVALID_DATA_ENCRYPT_MSGLEN_VALIDFAIL:
+            return("Args contain invalid data: FKO_ERROR_INVALID_DATA_ENCRYPT_MSGLEN_VALIDFAIL");
+
+        case FKO_ERROR_INVALID_DATA_ENCRYPT_DIGESTLEN_VALIDFAIL:
+            return("Args contain invalid data: FKO_ERROR_INVALID_DATA_ENCRYPT_DIGESTLEN_VALIDFAIL");
+
+        case FKO_ERROR_INVALID_DATA_ENCRYPT_PTLEN_VALIDFAIL:
+            return("Args contain invalid data: FKO_ERROR_INVALID_DATA_ENCRYPT_PTLEN_VALIDFAIL");
+
+        case FKO_ERROR_INVALID_DATA_ENCRYPT_RESULT_MSGLEN_VALIDFAIL:
+            return("Args contain invalid data: FKO_ERROR_INVALID_DATA_ENCRYPT_RESULT_MSGLEN_VALIDFAIL");
+
+        case FKO_ERROR_INVALID_DATA_ENCRYPT_CIPHERLEN_DECODEFAIL:
+            return("Args contain invalid data: FKO_ERROR_INVALID_DATA_ENCRYPT_CIPHERLEN_DECODEFAIL");
+
+        case FKO_ERROR_INVALID_DATA_ENCRYPT_CIPHERLEN_VALIDFAIL:
+            return("Args contain invalid data: FKO_ERROR_INVALID_DATA_ENCRYPT_CIPHERLEN_VALIDFAIL");
+
+        case FKO_ERROR_INVALID_DATA_ENCRYPT_DECRYPTED_MESSAGE_MISSING:
+            return("Args contain invalid data: FKO_ERROR_INVALID_DATA_ENCRYPT_DECRYPTED_MESSAGE_MISSING");
+
+        case FKO_ERROR_INVALID_DATA_ENCRYPT_DECRYPTED_MSGLEN_VALIDFAIL:
+            return("Args contain invalid data: FKO_ERROR_INVALID_DATA_ENCRYPT_DECRYPTED_MSGLEN_VALIDFAIL");
+
+        case FKO_ERROR_INVALID_DATA_ENCRYPT_GPG_MESSAGE_VALIDFAIL:
+            return("Args contain invalid data: FKO_ERROR_INVALID_DATA_ENCRYPT_GPG_MESSAGE_VALIDFAIL");
+
+        case FKO_ERROR_INVALID_DATA_ENCRYPT_GPG_DIGEST_VALIDFAIL:
+            return("Args contain invalid data: FKO_ERROR_INVALID_DATA_ENCRYPT_GPG_DIGEST_VALIDFAIL");
+
+        case FKO_ERROR_INVALID_DATA_ENCRYPT_GPG_MSGLEN_VALIDFAIL:
+            return("Args contain invalid data: FKO_ERROR_INVALID_DATA_ENCRYPT_GPG_MSGLEN_VALIDFAIL");
+
+        case FKO_ERROR_INVALID_DATA_ENCRYPT_GPG_RESULT_MSGLEN_VALIDFAIL:
+            return("Args contain invalid data: FKO_ERROR_INVALID_DATA_ENCRYPT_GPG_RESULT_MSGLEN_VALIDFAIL");
+
+        case FKO_ERROR_INVALID_DATA_ENCRYPT_GPG_CIPHER_DECODEFAIL:
+            return("Args contain invalid data: FKO_ERROR_INVALID_DATA_ENCRYPT_GPG_CIPHER_DECODEFAIL");
+
+        case FKO_ERROR_INVALID_DATA_ENCRYPT_GPG_ENCODEDMSG_NULL:
+            return("Args contain invalid data: FKO_ERROR_INVALID_DATA_ENCRYPT_GPG_ENCODEDMSG_NULL");
+
+        case FKO_ERROR_INVALID_DATA_ENCRYPT_GPG_ENCODEDMSGLEN_VALIDFAIL:
+            return("Args contain invalid data: FKO_ERROR_INVALID_DATA_ENCRYPT_GPG_ENCODEDMSGLEN_VALIDFAIL");
+
+        case FKO_ERROR_INVALID_DATA_ENCRYPT_TYPE_VALIDFAIL:
+            return("Args contain invalid data: FKO_ERROR_INVALID_DATA_ENCRYPT_TYPE_VALIDFAIL");
+
+        case FKO_ERROR_INVALID_DATA_ENCRYPT_MODE_VALIDFAIL:
+            return("Args contain invalid data: FKO_ERROR_INVALID_DATA_ENCRYPT_MODE_VALIDFAIL");
+
+        case FKO_ERROR_INVALID_DATA_ENCRYPT_TYPE_UNKNOWN:
+            return("Args contain invalid data: FKO_ERROR_INVALID_DATA_ENCRYPT_TYPE_UNKNOWN");
+
+        case FKO_ERROR_INVALID_DATA_FUNCS_NEW_ENCMSG_MISSING:
+            return("Args contain invalid data: FKO_ERROR_INVALID_DATA_FUNCS_NEW_ENCMSG_MISSING");
+
+        case FKO_ERROR_INVALID_DATA_FUNCS_NEW_MSGLEN_VALIDFAIL:
+            return("Args contain invalid data: FKO_ERROR_INVALID_DATA_FUNCS_NEW_MSGLEN_VALIDFAIL");
+
+        case FKO_ERROR_INVALID_DATA_FUNCS_GEN_KEYLEN_VALIDFAIL:
+            return("Args contain invalid data: FKO_ERROR_INVALID_DATA_FUNCS_GEN_KEYLEN_VALIDFAIL");
+
+        case FKO_ERROR_INVALID_DATA_FUNCS_GEN_HMACLEN_VALIDFAIL:
+            return("Args contain invalid data: FKO_ERROR_INVALID_DATA_FUNCS_GEN_HMACLEN_VALIDFAIL");
+
+        case FKO_ERROR_INVALID_DATA_FUNCS_GEN_KEY_ENCODEFAIL:
+            return("Args contain invalid data: FKO_ERROR_INVALID_DATA_FUNCS_GEN_KEY_ENCODEFAIL");
+
+        case FKO_ERROR_INVALID_DATA_FUNCS_GEN_HMAC_ENCODEFAIL:
+            return("Args contain invalid data: FKO_ERROR_INVALID_DATA_FUNCS_GEN_HMAC_ENCODEFAIL");
+
+        case FKO_ERROR_INVALID_DATA_FUNCS_SET_MSGLEN_VALIDFAIL:
+            return("Args contain invalid data: FKO_ERROR_INVALID_DATA_FUNCS_SET_MSGLEN_VALIDFAIL");
+
+        case FKO_ERROR_INVALID_DATA_HMAC_MSGLEN_VALIDFAIL:
+            return("Args contain invalid data: FKO_ERROR_INVALID_DATA_HMAC_MSGLEN_VALIDFAIL");
+
+        case FKO_ERROR_INVALID_DATA_HMAC_ENCMSGLEN_VALIDFAIL:
+            return("Args contain invalid data: FKO_ERROR_INVALID_DATA_HMAC_ENCMSGLEN_VALIDFAIL");
+
+        case FKO_ERROR_INVALID_DATA_HMAC_COMPAREFAIL:
+            return("Args contain invalid data: FKO_ERROR_INVALID_DATA_HMAC_COMPAREFAIL");
+
+        case FKO_ERROR_INVALID_DATA_HMAC_TYPE_VALIDFAIL:
+            return("Args contain invalid data: FKO_ERROR_INVALID_DATA_HMAC_TYPE_VALIDFAIL");
+
+        case FKO_ERROR_INVALID_DATA_HMAC_LEN_VALIDFAIL:
+            return("Args contain invalid data: FKO_ERROR_INVALID_DATA_HMAC_LEN_VALIDFAIL");
+
+        case FKO_ERROR_INVALID_DATA_MESSAGE_PORT_MISSING:
+            return("Args contain invalid data: FKO_ERROR_INVALID_DATA_MESSAGE_PORT_MISSING");
+
+        case FKO_ERROR_INVALID_DATA_MESSAGE_TYPE_VALIDFAIL:
+            return("Args contain invalid data: FKO_ERROR_INVALID_DATA_MESSAGE_TYPE_VALIDFAIL");
+
+        case FKO_ERROR_INVALID_DATA_MESSAGE_EMPTY:
+            return("Args contain invalid data: FKO_ERROR_INVALID_DATA_MESSAGE_EMPTY");
+
+        case FKO_ERROR_INVALID_DATA_MESSAGE_CMD_MISSING:
+            return("Args contain invalid data: FKO_ERROR_INVALID_DATA_MESSAGE_CMD_MISSING");
+
+        case FKO_ERROR_INVALID_DATA_MESSAGE_ACCESS_MISSING:
+            return("Args contain invalid data: FKO_ERROR_INVALID_DATA_MESSAGE_ACCESS_MISSING");
+
+        case FKO_ERROR_INVALID_DATA_MESSAGE_NAT_MISSING:
+            return("Args contain invalid data: FKO_ERROR_INVALID_DATA_MESSAGE_NAT_MISSING");
+
+        case FKO_ERROR_INVALID_DATA_MESSAGE_PORTPROTO_MISSING:
+            return("Args contain invalid data: FKO_ERROR_INVALID_DATA_MESSAGE_PORTPROTO_MISSING");
+
+        case FKO_ERROR_INVALID_DATA_NAT_EMPTY:
+            return("Args contain invalid data: FKO_ERROR_INVALID_DATA_NAT_EMPTY");
+
+        case FKO_ERROR_INVALID_DATA_RAND_LEN_VALIDFAIL:
+            return("Args contain invalid data: FKO_ERROR_INVALID_DATA_RAND_LEN_VALIDFAIL");
+
+        case FKO_ERROR_INVALID_DATA_SRVAUTH_MISSING:
+            return("Args contain invalid data: FKO_ERROR_INVALID_DATA_SRVAUTH_MISSING");
+
+        case FKO_ERROR_INVALID_DATA_TIMESTAMP_VALIDFAIL:
+            return("Args contain invalid data: FKO_ERROR_INVALID_DATA_TIMESTAMP_VALIDFAIL");
+
+        case FKO_ERROR_INVALID_DATA_USER_MISSING:
+            return("Args contain invalid data: FKO_ERROR_INVALID_DATA_USER_MISSING");
+
+        case FKO_ERROR_INVALID_DATA_USER_FIRSTCHAR_VALIDFAIL:
+            return("Args contain invalid data: FKO_ERROR_INVALID_DATA_USER_FIRSTCHAR_VALIDFAIL");
+
+        case FKO_ERROR_INVALID_DATA_USER_REMCHAR_VALIDFAIL:
+            return("Args contain invalid data: FKO_ERROR_INVALID_DATA_USER_REMCHAR_VALIDFAIL");
+
+        case FKO_ERROR_INVALID_DATA_UTIL_STRTOL_LT_MIN:
+            return("Args contain invalid data: FKO_ERROR_INVALID_DATA_UTIL_STRTOL_LT_MIN");
+
+        case FKO_ERROR_INVALID_DATA_UTIL_STROL_GT_MAX:
+            return("Args contain invalid data: FKO_ERROR_INVALID_DATA_UTIL_STROL_GT_MAX");
+
         case FKO_ERROR_DATA_TOO_LARGE:
             return("Value or Size of the data exceeded the max allowed");
 
index 3ffcdfd..b8efb7d 100644 (file)
@@ -186,7 +186,7 @@ fko_new_with_data(fko_ctx_t *r_ctx, const char * const enc_msg,
     int         enc_msg_len;
 
     if(enc_msg == NULL)
-        return(FKO_ERROR_INVALID_DATA);
+        return(FKO_ERROR_INVALID_DATA_FUNCS_NEW_ENCMSG_MISSING);
 
     ctx = calloc(1, sizeof *ctx);
     if(ctx == NULL)
@@ -197,7 +197,7 @@ fko_new_with_data(fko_ctx_t *r_ctx, const char * const enc_msg,
     if(! is_valid_encoded_msg_len(enc_msg_len))
     {
         free(ctx);
-        return(FKO_ERROR_INVALID_DATA);
+        return(FKO_ERROR_INVALID_DATA_FUNCS_NEW_MSGLEN_VALIDFAIL);
     }
 
     if(ctx->encrypted_msg != NULL)
@@ -411,21 +411,21 @@ fko_key_gen(char * const key_base64, const int key_len,
     }
 
     if((klen < 1) || (klen > RIJNDAEL_MAX_KEYSIZE))
-        return(FKO_ERROR_INVALID_DATA);
+        return(FKO_ERROR_INVALID_DATA_FUNCS_GEN_KEYLEN_VALIDFAIL);
 
     if((hmac_klen < 1) || (hmac_klen > SHA512_BLOCK_LEN))
-        return(FKO_ERROR_INVALID_DATA);
+        return(FKO_ERROR_INVALID_DATA_FUNCS_GEN_HMACLEN_VALIDFAIL);
 
     get_random_data(key, klen);
     get_random_data(hmac_key, hmac_klen);
 
     b64_len = b64_encode(key, key_base64, klen);
     if(b64_len < klen)
-        return(FKO_ERROR_INVALID_DATA);
+        return(FKO_ERROR_INVALID_DATA_FUNCS_GEN_KEY_ENCODEFAIL);
 
     b64_len = b64_encode(hmac_key, hmac_key_base64, hmac_klen);
     if(b64_len < hmac_klen)
-        return(FKO_ERROR_INVALID_DATA);
+        return(FKO_ERROR_INVALID_DATA_FUNCS_GEN_HMAC_ENCODEFAIL);
 
     return(FKO_SUCCESS);
 }
@@ -554,7 +554,7 @@ fko_set_spa_data(fko_ctx_t ctx, const char * const enc_msg)
     enc_msg_len = strnlen(enc_msg, MAX_SPA_ENCODED_MSG_SIZE);
 
     if(! is_valid_encoded_msg_len(enc_msg_len))
-        return(FKO_ERROR_INVALID_DATA);
+        return(FKO_ERROR_INVALID_DATA_FUNCS_SET_MSGLEN_VALIDFAIL);
 
     if(ctx->encrypted_msg != NULL)
         free(ctx->encrypted_msg);
index fec5201..88ba553 100644 (file)
@@ -49,7 +49,7 @@ fko_verify_hmac(fko_ctx_t ctx,
         return(FKO_ERROR_CTX_NOT_INITIALIZED);
 
     if (! is_valid_encoded_msg_len(ctx->encrypted_msg_len))
-        return(FKO_ERROR_INVALID_DATA);
+        return(FKO_ERROR_INVALID_DATA_HMAC_MSGLEN_VALIDFAIL);
 
     if(hmac_key_len > MAX_DIGEST_BLOCK_LEN)
         return(FKO_ERROR_INVALID_HMAC_KEY_LEN);
@@ -69,7 +69,7 @@ fko_verify_hmac(fko_ctx_t ctx,
 
     if((ctx->encrypted_msg_len - hmac_b64_digest_len)
             < MIN_SPA_ENCODED_MSG_SIZE)
-        return(FKO_ERROR_INVALID_DATA);
+        return(FKO_ERROR_INVALID_DATA_HMAC_ENCMSGLEN_VALIDFAIL);
 
     /* Get digest value
     */
@@ -146,7 +146,7 @@ fko_verify_hmac(fko_ctx_t ctx,
             if(constant_runtime_cmp(hmac_digest_from_data,
                     ctx->msg_hmac, hmac_b64_digest_len) != 0)
             {
-                res = FKO_ERROR_INVALID_DATA;
+                res = FKO_ERROR_INVALID_DATA_HMAC_COMPAREFAIL;
             }
         }
     }
@@ -187,7 +187,7 @@ fko_set_spa_hmac_type(fko_ctx_t ctx, const short hmac_type)
         return(FKO_ERROR_CTX_NOT_INITIALIZED);
 
     if(hmac_type < 0 || hmac_type >= FKO_LAST_HMAC_MODE)
-        return(FKO_ERROR_INVALID_DATA);
+        return(FKO_ERROR_INVALID_DATA_HMAC_TYPE_VALIDFAIL);
 
     ctx->hmac_type = hmac_type;
 
@@ -296,7 +296,7 @@ int fko_set_spa_hmac(fko_ctx_t ctx,
         case SHA512_B64_LEN:
             break;
         default:
-            return(FKO_ERROR_INVALID_DATA);
+            return(FKO_ERROR_INVALID_DATA_HMAC_LEN_VALIDFAIL);
     }
 
     return FKO_SUCCESS;
index e10bcc8..fa6803b 100644 (file)
@@ -100,7 +100,7 @@ have_port(const char *msg)
     int     startlen         = strnlen(msg, MAX_SPA_MESSAGE_SIZE), port_str_len = 0;
 
     if(startlen == MAX_SPA_MESSAGE_SIZE)
-        return(FKO_ERROR_INVALID_DATA);
+        return(FKO_ERROR_INVALID_DATA_MESSAGE_PORT_MISSING);
 
     /* Must have at least one digit for the port number
     */
@@ -129,7 +129,7 @@ fko_set_spa_message_type(fko_ctx_t ctx, const short msg_type)
         return FKO_ERROR_CTX_NOT_INITIALIZED;
 
     if(msg_type < 0 || msg_type >= FKO_LAST_MSG_TYPE)
-        return(FKO_ERROR_INVALID_DATA);
+        return(FKO_ERROR_INVALID_DATA_MESSAGE_TYPE_VALIDFAIL);
 
     ctx->message_type = msg_type;
 
@@ -168,7 +168,7 @@ fko_set_spa_message(fko_ctx_t ctx, const char * const msg)
     /* Gotta have a valid string.
     */
     if(msg == NULL || strnlen(msg, MAX_SPA_MESSAGE_SIZE) == 0)
-        return(FKO_ERROR_INVALID_DATA);
+        return(FKO_ERROR_INVALID_DATA_MESSAGE_EMPTY);
 
     /* --DSS XXX: Bail out for now.  But consider just
      *            truncating in the future...
@@ -227,7 +227,7 @@ validate_cmd_msg(const char *msg)
     int     startlen    = strnlen(msg, MAX_SPA_CMD_LEN);
 
     if(startlen == MAX_SPA_CMD_LEN)
-        return(FKO_ERROR_INVALID_DATA);
+        return(FKO_ERROR_INVALID_DATA_MESSAGE_CMD_MISSING);
 
     /* Should always have a valid allow IP regardless of message type
     */
@@ -253,7 +253,7 @@ validate_access_msg(const char *msg)
     int     startlen    = strnlen(msg, MAX_SPA_MESSAGE_SIZE);
 
     if(startlen == MAX_SPA_MESSAGE_SIZE)
-        return(FKO_ERROR_INVALID_DATA);
+        return(FKO_ERROR_INVALID_DATA_MESSAGE_ACCESS_MISSING);
 
     /* Should always have a valid allow IP regardless of message type
     */
@@ -287,7 +287,7 @@ validate_nat_access_msg(const char *msg)
     int     startlen    = strnlen(msg, MAX_SPA_MESSAGE_SIZE);
 
     if(startlen == MAX_SPA_MESSAGE_SIZE)
-        return(FKO_ERROR_INVALID_DATA);
+        return(FKO_ERROR_INVALID_DATA_MESSAGE_NAT_MISSING);
 
     /* Should always have a valid allow IP regardless of message type
     */
@@ -319,7 +319,7 @@ validate_proto_port_spec(const char *msg)
     const char   *ndx   = msg;
 
     if(startlen == MAX_SPA_MESSAGE_SIZE)
-        return(FKO_ERROR_INVALID_DATA);
+        return(FKO_ERROR_INVALID_DATA_MESSAGE_PORTPROTO_MISSING);
 
     /* Now check for proto/port string.
     */
index b3b72c4..f8ebcff 100644 (file)
@@ -46,7 +46,7 @@ fko_set_spa_nat_access(fko_ctx_t ctx, const char * const msg)
     /* Gotta have a valid string.
     */
     if(msg == NULL || strnlen(msg, MAX_SPA_NAT_ACCESS_SIZE) == 0)
-        return(FKO_ERROR_INVALID_DATA);
+        return(FKO_ERROR_INVALID_DATA_NAT_EMPTY);
 
     /* --DSS XXX: Bail out for now.  But consider just
      *            truncating in the future...
index f01d560..c1876ac 100644 (file)
@@ -70,7 +70,7 @@ fko_set_rand_value(fko_ctx_t ctx, const char * const new_val)
     if(new_val != NULL)
     {
         if(strnlen(new_val, FKO_RAND_VAL_SIZE+1) != FKO_RAND_VAL_SIZE)
-            return(FKO_ERROR_INVALID_DATA);
+            return(FKO_ERROR_INVALID_DATA_RAND_LEN_VALIDFAIL);
 
         if(ctx->rand_val != NULL)
             free(ctx->rand_val);
index 6554f0e..dcb65cb 100644 (file)
@@ -51,7 +51,7 @@ fko_set_spa_server_auth(fko_ctx_t ctx, const char * const msg)
     /* Gotta have a valid string.
     */
     if(msg == NULL || strnlen(msg, MAX_SPA_SERVER_AUTH_SIZE) == 0)
-        return(FKO_ERROR_INVALID_DATA);
+        return(FKO_ERROR_INVALID_DATA_SRVAUTH_MISSING);
 
     /* --DSS XXX: Bail out for now.  But consider just
      *            truncating in the future...
index 61017cf..37bc98c 100644 (file)
@@ -47,7 +47,7 @@ fko_set_timestamp(fko_ctx_t ctx, const int offset)
     ts = time(NULL) + offset;
 
     if(ts < 0)
-        return(FKO_ERROR_INVALID_DATA);
+        return(FKO_ERROR_INVALID_DATA_TIMESTAMP_VALIDFAIL);
 
     ctx->timestamp = ts;
 
index 470b6cd..f42c89e 100644 (file)
@@ -139,17 +139,17 @@ validate_username(const char *username)
     int i;
 
     if(username == NULL || strnlen(username, MAX_SPA_USERNAME_SIZE) == 0)
-        return(FKO_ERROR_INVALID_DATA);
+        return(FKO_ERROR_INVALID_DATA_USER_MISSING);
 
     /* Make sure it is just alpha-numeric chars, dashes, dots, and underscores
     */
     if(isalnum(username[0]) == 0)
-        return(FKO_ERROR_INVALID_DATA);
+        return(FKO_ERROR_INVALID_DATA_USER_FIRSTCHAR_VALIDFAIL);
 
     for (i=1; i < (int)strnlen(username, MAX_SPA_USERNAME_SIZE); i++)
         if((isalnum(username[i]) == 0)
                 && username[i] != '-' && username[i] != '_' && username[i] != '.')
-            return(FKO_ERROR_INVALID_DATA);
+            return(FKO_ERROR_INVALID_DATA_USER_REMCHAR_VALIDFAIL);
 
     return FKO_SUCCESS;
 }
index e70e6ea..b60165b 100644 (file)
@@ -372,7 +372,7 @@ strtol_wrapper(const char * const str, const int min,
 
     if(val < min)
     {
-        *err = FKO_ERROR_INVALID_DATA;
+        *err = FKO_ERROR_INVALID_DATA_UTIL_STRTOL_LT_MIN;
         if(exit_upon_err == EXIT_UPON_ERR)
         {
             fprintf(stderr, "[*] Value %d out of range %d - %d\n",
@@ -386,7 +386,7 @@ strtol_wrapper(const char * const str, const int min,
     */
     if((max >= 0) && (val > max))
     {
-        *err = FKO_ERROR_INVALID_DATA;
+        *err = FKO_ERROR_INVALID_DATA_UTIL_STROL_GT_MAX;
         if(exit_upon_err == EXIT_UPON_ERR)
         {
             fprintf(stderr, "[*] Value %d out of range %d - %d\n",