DeforaNetworks/fwknop
3
0
Fork 0
Code Releases Activity

Merge remote-tracking branch 'hlein/unique_errors'

Browse Source 
[libfko] (Hank Leininger) Contributed a patch to greatly extend libfko
error code descriptions at various places in order to give much better
information on what certain error conditions mean.  Closes #98.
This commit is contained in:
Michael Rash
2013-08-09 21:46:49 -04:00
parent eb7914d45c bc907e0b24
commit 4023da87d6
16 changed files with 428 additions and 85 deletions
Download Patch File Download Diff File Expand all files Collapse all files
lib/fko.h
+88
View File
@@ -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;
lib/fko_client_timeout.c
+1 -1
View 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;
lib/fko_decode.c
+34 -34
View 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);
}
}
}
lib/fko_digest.c
+2 -2
View 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)
{
lib/fko_encode.c
+2 -2
View 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.
*/
lib/fko_encryption.c
+18 -18
View 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);
}
lib/fko_error.c
+255
View 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");
lib/fko_funcs.c
+7 -7
View 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);
lib/fko_hmac.c
+5 -5
View 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;
lib/fko_message.c
+7 -7
View 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.
*/
lib/fko_nat_access.c
+1 -1
View 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...
lib/fko_rand_value.c
+1 -1
View 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);
lib/fko_server_auth.c
+1 -1
View 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...
lib/fko_timestamp.c
+1 -1
View 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;
lib/fko_user.c
+3 -3
View 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;
}
lib/fko_util.c
+2 -2
View 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",