From bc907e0b24146ba98d2aa04480a2114f1d0a06c4 Mon Sep 17 00:00:00 2001 From: Hank Leininger Date: Mon, 5 Aug 2013 22:21:10 -0400 Subject: [PATCH] Add unique errors for every FKO_ERROR_INVALID_DATA. Needed this to track down mystery errors (#98). --- lib/fko.h | 88 ++++++++++++++ lib/fko_client_timeout.c | 2 +- lib/fko_decode.c | 68 +++++------ lib/fko_digest.c | 4 +- lib/fko_encode.c | 4 +- lib/fko_encryption.c | 36 +++--- lib/fko_error.c | 255 +++++++++++++++++++++++++++++++++++++++ lib/fko_funcs.c | 14 +-- lib/fko_hmac.c | 10 +- lib/fko_message.c | 14 +-- lib/fko_nat_access.c | 2 +- lib/fko_rand_value.c | 2 +- lib/fko_server_auth.c | 2 +- lib/fko_timestamp.c | 2 +- lib/fko_user.c | 6 +- lib/fko_util.c | 4 +- 16 files changed, 428 insertions(+), 85 deletions(-) diff --git a/lib/fko.h b/lib/fko.h index c80866c3..79407cef 100644 --- 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; diff --git a/lib/fko_client_timeout.c b/lib/fko_client_timeout.c index d22be964..6544eada 100644 --- a/lib/fko_client_timeout.c +++ b/lib/fko_client_timeout.c @@ -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; diff --git a/lib/fko_decode.c b/lib/fko_decode.c index cfceff75..27371400 100644 --- a/lib/fko_decode.c +++ b/lib/fko_decode.c @@ -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); } } } diff --git a/lib/fko_digest.c b/lib/fko_digest.c index 20314c7b..81f25518 100644 --- a/lib/fko_digest.c +++ b/lib/fko_digest.c @@ -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) { diff --git a/lib/fko_encode.c b/lib/fko_encode.c index d7189744..c9b53cb3 100644 --- a/lib/fko_encode.c +++ b/lib/fko_encode.c @@ -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. */ diff --git a/lib/fko_encryption.c b/lib/fko_encryption.c index 9698b16f..5e82af76 100644 --- a/lib/fko_encryption.c +++ b/lib/fko_encryption.c @@ -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); } diff --git a/lib/fko_error.c b/lib/fko_error.c index 546e6746..cf552dcb 100644 --- a/lib/fko_error.c +++ b/lib/fko_error.c @@ -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"); diff --git a/lib/fko_funcs.c b/lib/fko_funcs.c index 3ffcdfdc..b8efb7d6 100644 --- a/lib/fko_funcs.c +++ b/lib/fko_funcs.c @@ -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); diff --git a/lib/fko_hmac.c b/lib/fko_hmac.c index fec52015..88ba553b 100644 --- a/lib/fko_hmac.c +++ b/lib/fko_hmac.c @@ -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; diff --git a/lib/fko_message.c b/lib/fko_message.c index e10bcc86..fa6803b2 100644 --- a/lib/fko_message.c +++ b/lib/fko_message.c @@ -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. */ diff --git a/lib/fko_nat_access.c b/lib/fko_nat_access.c index b3b72c47..f8ebcffb 100644 --- a/lib/fko_nat_access.c +++ b/lib/fko_nat_access.c @@ -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... diff --git a/lib/fko_rand_value.c b/lib/fko_rand_value.c index f01d5607..c1876acc 100644 --- a/lib/fko_rand_value.c +++ b/lib/fko_rand_value.c @@ -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); diff --git a/lib/fko_server_auth.c b/lib/fko_server_auth.c index 6554f0e8..dcb65cbb 100644 --- a/lib/fko_server_auth.c +++ b/lib/fko_server_auth.c @@ -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... diff --git a/lib/fko_timestamp.c b/lib/fko_timestamp.c index 61017cf9..37bc98ce 100644 --- a/lib/fko_timestamp.c +++ b/lib/fko_timestamp.c @@ -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; diff --git a/lib/fko_user.c b/lib/fko_user.c index 470b6cda..f42c89e2 100644 --- a/lib/fko_user.c +++ b/lib/fko_user.c @@ -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; } diff --git a/lib/fko_util.c b/lib/fko_util.c index e70e6eab..b60165b6 100644 --- a/lib/fko_util.c +++ b/lib/fko_util.c @@ -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",