mirror of
https://github.com/Mbed-TLS/mbedtls.git
synced 2026-03-20 19:21:09 +01:00
Removed tests depending on the _CHECK_PARAMS option
Signed-off-by: TRodziewicz <tomasz.rodziewicz@mobica.com>
This commit is contained in:
TRodziewicz
@@ -1019,13 +1019,6 @@ psa_status_t psa_wipe_key_slot( psa_key_slot_t *slot )
|
||||
{
|
||||
psa_status_t status = psa_remove_key_data_from_memory( slot );
|
||||
|
||||
/*
|
||||
* As the return error code may not be handled in case of multiple errors,
|
||||
* do our best to report an unexpected lock counter: if available
|
||||
* call MBEDTLS_PARAM_FAILED that may terminate execution (if called as
|
||||
* part of the execution of a test suite this will stop the test suite
|
||||
* execution).
|
||||
*/
|
||||
if( slot->lock_count != 1 )
|
||||
{
|
||||
status = PSA_ERROR_CORRUPTION_DETECTED;
|
||||
|
||||
@@ -181,14 +181,10 @@
|
||||
* \brief This macro tests the statement passed to it as a test step or
|
||||
* individual test in a test case. The macro assumes the test will not fail.
|
||||
*
|
||||
* It assumes the library function under test cannot return a value and
|
||||
* assumes errors can only be indicated by calls to
|
||||
* MBEDTLS_PARAM_FAILED().
|
||||
* It assumes the library function under test cannot return a value.
|
||||
*
|
||||
* This macro is intended to test that functions returning void
|
||||
* accept all of the parameter values they're supposed to accept - eg
|
||||
* that they don't call MBEDTLS_PARAM_FAILED() when a parameter
|
||||
* that's allowed to be NULL happens to be NULL.
|
||||
* accept all of the parameter values they're supposed to accept.
|
||||
*
|
||||
* Note: for functions that return something other that void,
|
||||
* checking that they accept all the parameters they're supposed to
|
||||
|
||||
@@ -206,9 +206,6 @@ void aes_crypt_xts_size( int size, int retval )
|
||||
mbedtls_aes_xts_init( &ctx );
|
||||
memset( data_unit, 0x00, sizeof( data_unit ) );
|
||||
|
||||
|
||||
/* Valid pointers are passed for builds with MBEDTLS_CHECK_PARAMS, as
|
||||
* otherwise we wouldn't get to the size check we're interested in. */
|
||||
TEST_ASSERT( mbedtls_aes_crypt_xts( &ctx, MBEDTLS_AES_ENCRYPT, length, data_unit, src, output ) == retval );
|
||||
}
|
||||
/* END_CASE */
|
||||
@@ -359,197 +356,6 @@ exit:
|
||||
}
|
||||
/* END_CASE */
|
||||
|
||||
/* BEGIN_CASE depends_on:MBEDTLS_CHECK_PARAMS:!MBEDTLS_PARAM_FAILED_ALT */
|
||||
void aes_check_params( )
|
||||
{
|
||||
mbedtls_aes_context aes_ctx;
|
||||
#if defined(MBEDTLS_CIPHER_MODE_XTS)
|
||||
mbedtls_aes_xts_context xts_ctx;
|
||||
#endif
|
||||
const unsigned char key[] = { 0x01, 0x02, 0x03, 0x04, 0x05, 0x06 };
|
||||
const unsigned char in[16] = { 0 };
|
||||
unsigned char out[16];
|
||||
size_t size;
|
||||
const int valid_mode = MBEDTLS_AES_ENCRYPT;
|
||||
const int invalid_mode = 42;
|
||||
|
||||
TEST_INVALID_PARAM( mbedtls_aes_init( NULL ) );
|
||||
#if defined(MBEDTLS_CIPHER_MODE_XTS)
|
||||
TEST_INVALID_PARAM( mbedtls_aes_xts_init( NULL ) );
|
||||
#endif
|
||||
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_AES_BAD_INPUT_DATA,
|
||||
mbedtls_aes_setkey_enc( NULL, key, 128 ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_AES_BAD_INPUT_DATA,
|
||||
mbedtls_aes_setkey_enc( &aes_ctx, NULL, 128 ) );
|
||||
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_AES_BAD_INPUT_DATA,
|
||||
mbedtls_aes_setkey_dec( NULL, key, 128 ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_AES_BAD_INPUT_DATA,
|
||||
mbedtls_aes_setkey_dec( &aes_ctx, NULL, 128 ) );
|
||||
|
||||
#if defined(MBEDTLS_CIPHER_MODE_XTS)
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_AES_BAD_INPUT_DATA,
|
||||
mbedtls_aes_xts_setkey_enc( NULL, key, 128 ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_AES_BAD_INPUT_DATA,
|
||||
mbedtls_aes_xts_setkey_enc( &xts_ctx, NULL, 128 ) );
|
||||
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_AES_BAD_INPUT_DATA,
|
||||
mbedtls_aes_xts_setkey_dec( NULL, key, 128 ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_AES_BAD_INPUT_DATA,
|
||||
mbedtls_aes_xts_setkey_dec( &xts_ctx, NULL, 128 ) );
|
||||
#endif
|
||||
|
||||
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_AES_BAD_INPUT_DATA,
|
||||
mbedtls_aes_crypt_ecb( NULL,
|
||||
valid_mode, in, out ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_AES_BAD_INPUT_DATA,
|
||||
mbedtls_aes_crypt_ecb( &aes_ctx,
|
||||
invalid_mode, in, out ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_AES_BAD_INPUT_DATA,
|
||||
mbedtls_aes_crypt_ecb( &aes_ctx,
|
||||
valid_mode, NULL, out ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_AES_BAD_INPUT_DATA,
|
||||
mbedtls_aes_crypt_ecb( &aes_ctx,
|
||||
valid_mode, in, NULL ) );
|
||||
|
||||
#if defined(MBEDTLS_CIPHER_MODE_CBC)
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_AES_BAD_INPUT_DATA,
|
||||
mbedtls_aes_crypt_cbc( NULL,
|
||||
valid_mode, 16,
|
||||
out, in, out ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_AES_BAD_INPUT_DATA,
|
||||
mbedtls_aes_crypt_cbc( &aes_ctx,
|
||||
invalid_mode, 16,
|
||||
out, in, out ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_AES_BAD_INPUT_DATA,
|
||||
mbedtls_aes_crypt_cbc( &aes_ctx,
|
||||
valid_mode, 16,
|
||||
NULL, in, out ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_AES_BAD_INPUT_DATA,
|
||||
mbedtls_aes_crypt_cbc( &aes_ctx,
|
||||
valid_mode, 16,
|
||||
out, NULL, out ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_AES_BAD_INPUT_DATA,
|
||||
mbedtls_aes_crypt_cbc( &aes_ctx,
|
||||
valid_mode, 16,
|
||||
out, in, NULL ) );
|
||||
#endif /* MBEDTLS_CIPHER_MODE_CBC */
|
||||
|
||||
#if defined(MBEDTLS_CIPHER_MODE_XTS)
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_AES_BAD_INPUT_DATA,
|
||||
mbedtls_aes_crypt_xts( NULL,
|
||||
valid_mode, 16,
|
||||
in, in, out ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_AES_BAD_INPUT_DATA,
|
||||
mbedtls_aes_crypt_xts( &xts_ctx,
|
||||
invalid_mode, 16,
|
||||
in, in, out ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_AES_BAD_INPUT_DATA,
|
||||
mbedtls_aes_crypt_xts( &xts_ctx,
|
||||
valid_mode, 16,
|
||||
NULL, in, out ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_AES_BAD_INPUT_DATA,
|
||||
mbedtls_aes_crypt_xts( &xts_ctx,
|
||||
valid_mode, 16,
|
||||
in, NULL, out ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_AES_BAD_INPUT_DATA,
|
||||
mbedtls_aes_crypt_xts( &xts_ctx,
|
||||
valid_mode, 16,
|
||||
in, in, NULL ) );
|
||||
#endif /* MBEDTLS_CIPHER_MODE_XTS */
|
||||
|
||||
#if defined(MBEDTLS_CIPHER_MODE_CFB)
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_AES_BAD_INPUT_DATA,
|
||||
mbedtls_aes_crypt_cfb128( NULL,
|
||||
valid_mode, 16,
|
||||
&size, out, in, out ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_AES_BAD_INPUT_DATA,
|
||||
mbedtls_aes_crypt_cfb128( &aes_ctx,
|
||||
invalid_mode, 16,
|
||||
&size, out, in, out ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_AES_BAD_INPUT_DATA,
|
||||
mbedtls_aes_crypt_cfb128( &aes_ctx,
|
||||
valid_mode, 16,
|
||||
NULL, out, in, out ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_AES_BAD_INPUT_DATA,
|
||||
mbedtls_aes_crypt_cfb128( &aes_ctx,
|
||||
valid_mode, 16,
|
||||
&size, NULL, in, out ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_AES_BAD_INPUT_DATA,
|
||||
mbedtls_aes_crypt_cfb128( &aes_ctx,
|
||||
valid_mode, 16,
|
||||
&size, out, NULL, out ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_AES_BAD_INPUT_DATA,
|
||||
mbedtls_aes_crypt_cfb128( &aes_ctx,
|
||||
valid_mode, 16,
|
||||
&size, out, in, NULL ) );
|
||||
|
||||
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_AES_BAD_INPUT_DATA,
|
||||
mbedtls_aes_crypt_cfb8( NULL,
|
||||
valid_mode, 16,
|
||||
out, in, out ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_AES_BAD_INPUT_DATA,
|
||||
mbedtls_aes_crypt_cfb8( &aes_ctx,
|
||||
invalid_mode, 16,
|
||||
out, in, out ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_AES_BAD_INPUT_DATA,
|
||||
mbedtls_aes_crypt_cfb8( &aes_ctx,
|
||||
valid_mode, 16,
|
||||
NULL, in, out ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_AES_BAD_INPUT_DATA,
|
||||
mbedtls_aes_crypt_cfb8( &aes_ctx,
|
||||
valid_mode, 16,
|
||||
out, NULL, out ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_AES_BAD_INPUT_DATA,
|
||||
mbedtls_aes_crypt_cfb8( &aes_ctx,
|
||||
valid_mode, 16,
|
||||
out, in, NULL ) );
|
||||
#endif /* MBEDTLS_CIPHER_MODE_CFB */
|
||||
|
||||
#if defined(MBEDTLS_CIPHER_MODE_OFB)
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_AES_BAD_INPUT_DATA,
|
||||
mbedtls_aes_crypt_ofb( NULL, 16,
|
||||
&size, out, in, out ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_AES_BAD_INPUT_DATA,
|
||||
mbedtls_aes_crypt_ofb( &aes_ctx, 16,
|
||||
NULL, out, in, out ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_AES_BAD_INPUT_DATA,
|
||||
mbedtls_aes_crypt_ofb( &aes_ctx, 16,
|
||||
&size, NULL, in, out ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_AES_BAD_INPUT_DATA,
|
||||
mbedtls_aes_crypt_ofb( &aes_ctx, 16,
|
||||
&size, out, NULL, out ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_AES_BAD_INPUT_DATA,
|
||||
mbedtls_aes_crypt_ofb( &aes_ctx, 16,
|
||||
&size, out, in, NULL ) );
|
||||
#endif /* MBEDTLS_CIPHER_MODE_OFB */
|
||||
|
||||
#if defined(MBEDTLS_CIPHER_MODE_CTR)
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_AES_BAD_INPUT_DATA,
|
||||
mbedtls_aes_crypt_ctr( NULL, 16, &size, out,
|
||||
out, in, out ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_AES_BAD_INPUT_DATA,
|
||||
mbedtls_aes_crypt_ctr( &aes_ctx, 16, NULL, out,
|
||||
out, in, out ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_AES_BAD_INPUT_DATA,
|
||||
mbedtls_aes_crypt_ctr( &aes_ctx, 16, &size, NULL,
|
||||
out, in, out ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_AES_BAD_INPUT_DATA,
|
||||
mbedtls_aes_crypt_ctr( &aes_ctx, 16, &size, out,
|
||||
NULL, in, out ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_AES_BAD_INPUT_DATA,
|
||||
mbedtls_aes_crypt_ctr( &aes_ctx, 16, &size, out,
|
||||
out, NULL, out ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_AES_BAD_INPUT_DATA,
|
||||
mbedtls_aes_crypt_ctr( &aes_ctx, 16, &size, out,
|
||||
out, in, NULL ) );
|
||||
#endif /* MBEDTLS_CIPHER_MODE_CTR */
|
||||
}
|
||||
/* END_CASE */
|
||||
|
||||
/* BEGIN_CASE */
|
||||
void aes_misc_params( )
|
||||
{
|
||||
|
||||
@@ -10,9 +10,6 @@ aes_encrypt_cbc:"000000000000000000000000000000000000000000000000000000000000000
|
||||
AES-256-CBC Decrypt (Invalid input length)
|
||||
aes_decrypt_cbc:"0000000000000000000000000000000000000000000000000000000000000000":"00000000000000000000000000000000":"623a52fcea5d443e48d9181ab32c74":"":MBEDTLS_ERR_AES_INVALID_INPUT_LENGTH
|
||||
|
||||
AES - Optional Parameter Validation (MBEDTLS_CHECK_PARAMS)
|
||||
aes_check_params:
|
||||
|
||||
AES - Mandatory Parameter Validation and Valid Parameters
|
||||
aes_misc_params:
|
||||
|
||||
|
||||
@@ -1,9 +1,6 @@
|
||||
ARIA - Valid parameters
|
||||
aria_valid_param:
|
||||
|
||||
ARIA - Invalid parameters
|
||||
aria_invalid_param:
|
||||
|
||||
ARIA-128-ECB Encrypt - RFC 5794
|
||||
aria_encrypt_ecb:"000102030405060708090a0b0c0d0e0f":"00112233445566778899aabbccddeeff":"d718fbd6ab644c739da95f3be6451778":0
|
||||
|
||||
|
||||
@@ -23,188 +23,6 @@ void aria_valid_param( )
|
||||
}
|
||||
/* END_CASE */
|
||||
|
||||
/* BEGIN_CASE depends_on:MBEDTLS_CHECK_PARAMS:!MBEDTLS_PARAM_FAILED_ALT */
|
||||
void aria_invalid_param( )
|
||||
{
|
||||
mbedtls_aria_context ctx;
|
||||
unsigned char key[128 / 8] = { 0 };
|
||||
unsigned char input[MBEDTLS_ARIA_BLOCKSIZE] = { 0 };
|
||||
unsigned char output[MBEDTLS_ARIA_BLOCKSIZE] = { 0 };
|
||||
unsigned char iv[MBEDTLS_ARIA_BLOCKSIZE] = { 0 };
|
||||
size_t iv_off = 0;
|
||||
|
||||
((void) iv_off);
|
||||
((void) iv);
|
||||
|
||||
TEST_INVALID_PARAM( mbedtls_aria_init( NULL ) );
|
||||
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ARIA_BAD_INPUT_DATA,
|
||||
mbedtls_aria_setkey_enc( NULL, key,
|
||||
sizeof( key ) ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ARIA_BAD_INPUT_DATA,
|
||||
mbedtls_aria_setkey_enc( &ctx, NULL,
|
||||
sizeof( key ) ) );
|
||||
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ARIA_BAD_INPUT_DATA,
|
||||
mbedtls_aria_setkey_dec( NULL, key,
|
||||
sizeof( key ) ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ARIA_BAD_INPUT_DATA,
|
||||
mbedtls_aria_setkey_dec( &ctx, NULL,
|
||||
sizeof( key ) ) );
|
||||
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ARIA_BAD_INPUT_DATA,
|
||||
mbedtls_aria_crypt_ecb( NULL, input, output ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ARIA_BAD_INPUT_DATA,
|
||||
mbedtls_aria_crypt_ecb( &ctx, NULL, output ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ARIA_BAD_INPUT_DATA,
|
||||
mbedtls_aria_crypt_ecb( &ctx, input, NULL ) );
|
||||
|
||||
#if defined(MBEDTLS_CIPHER_MODE_CBC)
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ARIA_BAD_INPUT_DATA,
|
||||
mbedtls_aria_crypt_cbc( NULL,
|
||||
MBEDTLS_ARIA_ENCRYPT,
|
||||
sizeof( input ),
|
||||
iv,
|
||||
input,
|
||||
output ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ARIA_BAD_INPUT_DATA,
|
||||
mbedtls_aria_crypt_cbc( &ctx,
|
||||
42 /* invalid mode */,
|
||||
sizeof( input ),
|
||||
iv,
|
||||
input,
|
||||
output ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ARIA_BAD_INPUT_DATA,
|
||||
mbedtls_aria_crypt_cbc( &ctx,
|
||||
MBEDTLS_ARIA_ENCRYPT,
|
||||
sizeof( input ),
|
||||
NULL,
|
||||
input,
|
||||
output ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ARIA_BAD_INPUT_DATA,
|
||||
mbedtls_aria_crypt_cbc( &ctx,
|
||||
MBEDTLS_ARIA_ENCRYPT,
|
||||
sizeof( input ),
|
||||
iv,
|
||||
NULL,
|
||||
output ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ARIA_BAD_INPUT_DATA,
|
||||
mbedtls_aria_crypt_cbc( &ctx,
|
||||
MBEDTLS_ARIA_ENCRYPT,
|
||||
sizeof( input ),
|
||||
iv,
|
||||
input,
|
||||
NULL ) );
|
||||
#endif /* MBEDTLS_CIPHER_MODE_CBC */
|
||||
|
||||
#if defined(MBEDTLS_CIPHER_MODE_CFB)
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ARIA_BAD_INPUT_DATA,
|
||||
mbedtls_aria_crypt_cfb128( NULL,
|
||||
MBEDTLS_ARIA_ENCRYPT,
|
||||
sizeof( input ),
|
||||
&iv_off,
|
||||
iv,
|
||||
input,
|
||||
output ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ARIA_BAD_INPUT_DATA,
|
||||
mbedtls_aria_crypt_cfb128( &ctx,
|
||||
42, /* invalid mode */
|
||||
sizeof( input ),
|
||||
&iv_off,
|
||||
iv,
|
||||
input,
|
||||
output ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ARIA_BAD_INPUT_DATA,
|
||||
mbedtls_aria_crypt_cfb128( &ctx,
|
||||
MBEDTLS_ARIA_ENCRYPT,
|
||||
sizeof( input ),
|
||||
NULL,
|
||||
iv,
|
||||
input,
|
||||
output ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ARIA_BAD_INPUT_DATA,
|
||||
mbedtls_aria_crypt_cfb128( &ctx,
|
||||
MBEDTLS_ARIA_ENCRYPT,
|
||||
sizeof( input ),
|
||||
&iv_off,
|
||||
NULL,
|
||||
input,
|
||||
output ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ARIA_BAD_INPUT_DATA,
|
||||
mbedtls_aria_crypt_cfb128( &ctx,
|
||||
MBEDTLS_ARIA_ENCRYPT,
|
||||
sizeof( input ),
|
||||
&iv_off,
|
||||
iv,
|
||||
NULL,
|
||||
output ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ARIA_BAD_INPUT_DATA,
|
||||
mbedtls_aria_crypt_cfb128( &ctx,
|
||||
MBEDTLS_ARIA_ENCRYPT,
|
||||
sizeof( input ),
|
||||
&iv_off,
|
||||
iv,
|
||||
input,
|
||||
NULL ) );
|
||||
#endif /* MBEDTLS_CIPHER_MODE_CFB */
|
||||
|
||||
#if defined(MBEDTLS_CIPHER_MODE_CTR)
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ARIA_BAD_INPUT_DATA,
|
||||
mbedtls_aria_crypt_ctr( NULL,
|
||||
sizeof( input ),
|
||||
&iv_off,
|
||||
iv,
|
||||
iv,
|
||||
input,
|
||||
output ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ARIA_BAD_INPUT_DATA,
|
||||
mbedtls_aria_crypt_ctr( &ctx,
|
||||
sizeof( input ),
|
||||
NULL,
|
||||
iv,
|
||||
iv,
|
||||
input,
|
||||
output ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ARIA_BAD_INPUT_DATA,
|
||||
mbedtls_aria_crypt_ctr( &ctx,
|
||||
sizeof( input ),
|
||||
&iv_off,
|
||||
NULL,
|
||||
iv,
|
||||
input,
|
||||
output ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ARIA_BAD_INPUT_DATA,
|
||||
mbedtls_aria_crypt_ctr( &ctx,
|
||||
sizeof( input ),
|
||||
&iv_off,
|
||||
iv,
|
||||
NULL,
|
||||
input,
|
||||
output ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ARIA_BAD_INPUT_DATA,
|
||||
mbedtls_aria_crypt_ctr( &ctx,
|
||||
sizeof( input ),
|
||||
&iv_off,
|
||||
iv,
|
||||
iv,
|
||||
NULL,
|
||||
output ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ARIA_BAD_INPUT_DATA,
|
||||
mbedtls_aria_crypt_ctr( &ctx,
|
||||
sizeof( input ),
|
||||
&iv_off,
|
||||
iv,
|
||||
iv,
|
||||
input,
|
||||
NULL ) );
|
||||
#endif /* MBEDTLS_CIPHER_MODE_CTR */
|
||||
|
||||
exit:
|
||||
return;
|
||||
|
||||
}
|
||||
/* END_CASE */
|
||||
|
||||
/* BEGIN_CASE */
|
||||
void aria_encrypt_ecb( data_t *key_str, data_t *src_str,
|
||||
data_t *expected_output, int setkey_result )
|
||||
|
||||
@@ -1,9 +1,6 @@
|
||||
BLOWFISH - Valid parameters
|
||||
blowfish_valid_param:
|
||||
|
||||
BLOWFISH - Invalid parameters
|
||||
blowfish_invalid_param:
|
||||
|
||||
BLOWFISH-ECB Encrypt SSLeay reference #1
|
||||
blowfish_encrypt_ecb:"0000000000000000":"0000000000000000":"4ef997456198dd78":0
|
||||
|
||||
|
||||
@@ -14,157 +14,6 @@ void blowfish_valid_param( )
|
||||
}
|
||||
/* END_CASE */
|
||||
|
||||
/* BEGIN_CASE depends_on:MBEDTLS_CHECK_PARAMS:!MBEDTLS_PARAM_FAILED_ALT */
|
||||
void blowfish_invalid_param( )
|
||||
{
|
||||
mbedtls_blowfish_context ctx;
|
||||
unsigned char buf[16] = { 0 };
|
||||
size_t const valid_keylength = sizeof( buf ) * 8;
|
||||
size_t valid_mode = MBEDTLS_BLOWFISH_ENCRYPT;
|
||||
size_t invalid_mode = 42;
|
||||
size_t off;
|
||||
((void) off);
|
||||
|
||||
TEST_INVALID_PARAM( mbedtls_blowfish_init( NULL ) );
|
||||
TEST_VALID_PARAM( mbedtls_blowfish_free( NULL ) );
|
||||
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_BLOWFISH_BAD_INPUT_DATA,
|
||||
mbedtls_blowfish_setkey( NULL,
|
||||
buf,
|
||||
valid_keylength ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_BLOWFISH_BAD_INPUT_DATA,
|
||||
mbedtls_blowfish_setkey( &ctx,
|
||||
NULL,
|
||||
valid_keylength ) );
|
||||
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_BLOWFISH_BAD_INPUT_DATA,
|
||||
mbedtls_blowfish_crypt_ecb( NULL,
|
||||
valid_mode,
|
||||
buf, buf ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_BLOWFISH_BAD_INPUT_DATA,
|
||||
mbedtls_blowfish_crypt_ecb( &ctx,
|
||||
invalid_mode,
|
||||
buf, buf ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_BLOWFISH_BAD_INPUT_DATA,
|
||||
mbedtls_blowfish_crypt_ecb( &ctx,
|
||||
valid_mode,
|
||||
NULL, buf ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_BLOWFISH_BAD_INPUT_DATA,
|
||||
mbedtls_blowfish_crypt_ecb( &ctx,
|
||||
valid_mode,
|
||||
buf, NULL ) );
|
||||
|
||||
#if defined(MBEDTLS_CIPHER_MODE_CBC)
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_BLOWFISH_BAD_INPUT_DATA,
|
||||
mbedtls_blowfish_crypt_cbc( NULL,
|
||||
valid_mode,
|
||||
sizeof( buf ),
|
||||
buf, buf, buf ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_BLOWFISH_BAD_INPUT_DATA,
|
||||
mbedtls_blowfish_crypt_cbc( &ctx,
|
||||
invalid_mode,
|
||||
sizeof( buf ),
|
||||
buf, buf, buf ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_BLOWFISH_BAD_INPUT_DATA,
|
||||
mbedtls_blowfish_crypt_cbc( &ctx,
|
||||
valid_mode,
|
||||
sizeof( buf ),
|
||||
NULL, buf, buf ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_BLOWFISH_BAD_INPUT_DATA,
|
||||
mbedtls_blowfish_crypt_cbc( &ctx,
|
||||
valid_mode,
|
||||
sizeof( buf ),
|
||||
buf, NULL, buf ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_BLOWFISH_BAD_INPUT_DATA,
|
||||
mbedtls_blowfish_crypt_cbc( &ctx,
|
||||
valid_mode,
|
||||
sizeof( buf ),
|
||||
buf, buf, NULL ) );
|
||||
#endif /* MBEDTLS_CIPHER_MODE_CBC */
|
||||
|
||||
#if defined(MBEDTLS_CIPHER_MODE_CFB)
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_BLOWFISH_BAD_INPUT_DATA,
|
||||
mbedtls_blowfish_crypt_cfb64( NULL,
|
||||
valid_mode,
|
||||
sizeof( buf ),
|
||||
&off, buf,
|
||||
buf, buf ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_BLOWFISH_BAD_INPUT_DATA,
|
||||
mbedtls_blowfish_crypt_cfb64( &ctx,
|
||||
invalid_mode,
|
||||
sizeof( buf ),
|
||||
&off, buf,
|
||||
buf, buf ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_BLOWFISH_BAD_INPUT_DATA,
|
||||
mbedtls_blowfish_crypt_cfb64( &ctx,
|
||||
valid_mode,
|
||||
sizeof( buf ),
|
||||
NULL, buf,
|
||||
buf, buf ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_BLOWFISH_BAD_INPUT_DATA,
|
||||
mbedtls_blowfish_crypt_cfb64( &ctx,
|
||||
valid_mode,
|
||||
sizeof( buf ),
|
||||
&off, NULL,
|
||||
buf, buf ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_BLOWFISH_BAD_INPUT_DATA,
|
||||
mbedtls_blowfish_crypt_cfb64( &ctx,
|
||||
valid_mode,
|
||||
sizeof( buf ),
|
||||
&off, buf,
|
||||
NULL, buf ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_BLOWFISH_BAD_INPUT_DATA,
|
||||
mbedtls_blowfish_crypt_cfb64( &ctx,
|
||||
valid_mode,
|
||||
sizeof( buf ),
|
||||
&off, buf,
|
||||
buf, NULL ) );
|
||||
#endif /* MBEDTLS_CIPHER_MODE_CFB */
|
||||
|
||||
#if defined(MBEDTLS_CIPHER_MODE_CTR)
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_BLOWFISH_BAD_INPUT_DATA,
|
||||
mbedtls_blowfish_crypt_ctr( NULL,
|
||||
sizeof( buf ),
|
||||
&off,
|
||||
buf, buf,
|
||||
buf, buf ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_BLOWFISH_BAD_INPUT_DATA,
|
||||
mbedtls_blowfish_crypt_ctr( &ctx,
|
||||
sizeof( buf ),
|
||||
NULL,
|
||||
buf, buf,
|
||||
buf, buf ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_BLOWFISH_BAD_INPUT_DATA,
|
||||
mbedtls_blowfish_crypt_ctr( &ctx,
|
||||
sizeof( buf ),
|
||||
&off,
|
||||
NULL, buf,
|
||||
buf, buf ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_BLOWFISH_BAD_INPUT_DATA,
|
||||
mbedtls_blowfish_crypt_ctr( &ctx,
|
||||
sizeof( buf ),
|
||||
&off,
|
||||
buf, NULL,
|
||||
buf, buf ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_BLOWFISH_BAD_INPUT_DATA,
|
||||
mbedtls_blowfish_crypt_ctr( &ctx,
|
||||
sizeof( buf ),
|
||||
&off,
|
||||
buf, buf,
|
||||
NULL, buf ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_BLOWFISH_BAD_INPUT_DATA,
|
||||
mbedtls_blowfish_crypt_ctr( &ctx,
|
||||
sizeof( buf ),
|
||||
&off,
|
||||
buf, buf,
|
||||
buf, NULL ) );
|
||||
#endif /* MBEDTLS_CIPHER_MODE_CTR */
|
||||
|
||||
exit:
|
||||
return;
|
||||
}
|
||||
/* END_CASE */
|
||||
|
||||
/* BEGIN_CASE */
|
||||
void blowfish_encrypt_ecb( data_t * key_str, data_t * src_str,
|
||||
data_t * dst, int setkey_result )
|
||||
|
||||
@@ -1,9 +1,6 @@
|
||||
Camellia - Valid parameters
|
||||
camellia_valid_param:
|
||||
|
||||
Camellia - Invalid parameters
|
||||
camellia_invalid_param:
|
||||
|
||||
Camellia-128-ECB Encrypt RFC3713 #1
|
||||
camellia_encrypt_ecb:"0123456789abcdeffedcba9876543210":"0123456789abcdeffedcba9876543210":"67673138549669730857065648eabe43":0
|
||||
|
||||
|
||||
@@ -14,165 +14,6 @@ void camellia_valid_param( )
|
||||
}
|
||||
/* END_CASE */
|
||||
|
||||
/* BEGIN_CASE depends_on:MBEDTLS_CHECK_PARAMS:!MBEDTLS_PARAM_FAILED_ALT */
|
||||
void camellia_invalid_param( )
|
||||
{
|
||||
mbedtls_camellia_context ctx;
|
||||
unsigned char buf[16] = { 0 };
|
||||
const size_t valid_keybits = 128;
|
||||
const int invalid_mode = 42;
|
||||
const int valid_mode = MBEDTLS_CAMELLIA_ENCRYPT;
|
||||
size_t off;
|
||||
((void) off);
|
||||
|
||||
TEST_INVALID_PARAM( mbedtls_camellia_init( NULL ) );
|
||||
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_CAMELLIA_BAD_INPUT_DATA,
|
||||
mbedtls_camellia_setkey_enc( NULL,
|
||||
buf,
|
||||
valid_keybits ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_CAMELLIA_BAD_INPUT_DATA,
|
||||
mbedtls_camellia_setkey_enc( &ctx,
|
||||
NULL,
|
||||
valid_keybits ) );
|
||||
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_CAMELLIA_BAD_INPUT_DATA,
|
||||
mbedtls_camellia_setkey_dec( NULL,
|
||||
buf,
|
||||
valid_keybits ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_CAMELLIA_BAD_INPUT_DATA,
|
||||
mbedtls_camellia_setkey_dec( &ctx,
|
||||
NULL,
|
||||
valid_keybits ) );
|
||||
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_CAMELLIA_BAD_INPUT_DATA,
|
||||
mbedtls_camellia_crypt_ecb( NULL,
|
||||
valid_mode,
|
||||
buf, buf ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_CAMELLIA_BAD_INPUT_DATA,
|
||||
mbedtls_camellia_crypt_ecb( &ctx,
|
||||
invalid_mode,
|
||||
buf, buf ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_CAMELLIA_BAD_INPUT_DATA,
|
||||
mbedtls_camellia_crypt_ecb( &ctx,
|
||||
valid_mode,
|
||||
NULL, buf ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_CAMELLIA_BAD_INPUT_DATA,
|
||||
mbedtls_camellia_crypt_ecb( &ctx,
|
||||
valid_mode,
|
||||
buf, NULL ) );
|
||||
|
||||
#if defined(MBEDTLS_CIPHER_MODE_CBC)
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_CAMELLIA_BAD_INPUT_DATA,
|
||||
mbedtls_camellia_crypt_cbc( NULL,
|
||||
valid_mode,
|
||||
sizeof( buf ),
|
||||
buf, buf, buf ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_CAMELLIA_BAD_INPUT_DATA,
|
||||
mbedtls_camellia_crypt_cbc( &ctx,
|
||||
invalid_mode,
|
||||
sizeof( buf ),
|
||||
buf, buf, buf ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_CAMELLIA_BAD_INPUT_DATA,
|
||||
mbedtls_camellia_crypt_cbc( &ctx,
|
||||
valid_mode,
|
||||
sizeof( buf ),
|
||||
NULL, buf, buf ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_CAMELLIA_BAD_INPUT_DATA,
|
||||
mbedtls_camellia_crypt_cbc( &ctx,
|
||||
valid_mode,
|
||||
sizeof( buf ),
|
||||
buf, NULL, buf ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_CAMELLIA_BAD_INPUT_DATA,
|
||||
mbedtls_camellia_crypt_cbc( &ctx,
|
||||
valid_mode,
|
||||
sizeof( buf ),
|
||||
buf, buf, NULL ) );
|
||||
#endif /* MBEDTLS_CIPHER_MODE_CBC */
|
||||
|
||||
#if defined(MBEDTLS_CIPHER_MODE_CFB)
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_CAMELLIA_BAD_INPUT_DATA,
|
||||
mbedtls_camellia_crypt_cfb128( NULL,
|
||||
valid_mode,
|
||||
sizeof( buf ),
|
||||
&off, buf,
|
||||
buf, buf ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_CAMELLIA_BAD_INPUT_DATA,
|
||||
mbedtls_camellia_crypt_cfb128( &ctx,
|
||||
invalid_mode,
|
||||
sizeof( buf ),
|
||||
&off, buf,
|
||||
buf, buf ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_CAMELLIA_BAD_INPUT_DATA,
|
||||
mbedtls_camellia_crypt_cfb128( &ctx,
|
||||
valid_mode,
|
||||
sizeof( buf ),
|
||||
NULL, buf,
|
||||
buf, buf ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_CAMELLIA_BAD_INPUT_DATA,
|
||||
mbedtls_camellia_crypt_cfb128( &ctx,
|
||||
valid_mode,
|
||||
sizeof( buf ),
|
||||
&off, NULL,
|
||||
buf, buf ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_CAMELLIA_BAD_INPUT_DATA,
|
||||
mbedtls_camellia_crypt_cfb128( &ctx,
|
||||
valid_mode,
|
||||
sizeof( buf ),
|
||||
&off, buf,
|
||||
NULL, buf ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_CAMELLIA_BAD_INPUT_DATA,
|
||||
mbedtls_camellia_crypt_cfb128( &ctx,
|
||||
valid_mode,
|
||||
sizeof( buf ),
|
||||
&off, buf,
|
||||
buf, NULL ) );
|
||||
#endif /* MBEDTLS_CIPHER_MODE_CFB */
|
||||
|
||||
#if defined(MBEDTLS_CIPHER_MODE_CTR)
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_CAMELLIA_BAD_INPUT_DATA,
|
||||
mbedtls_camellia_crypt_ctr( NULL,
|
||||
sizeof( buf ),
|
||||
&off,
|
||||
buf, buf,
|
||||
buf, buf ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_CAMELLIA_BAD_INPUT_DATA,
|
||||
mbedtls_camellia_crypt_ctr( &ctx,
|
||||
sizeof( buf ),
|
||||
NULL,
|
||||
buf, buf,
|
||||
buf, buf ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_CAMELLIA_BAD_INPUT_DATA,
|
||||
mbedtls_camellia_crypt_ctr( &ctx,
|
||||
sizeof( buf ),
|
||||
&off,
|
||||
NULL, buf,
|
||||
buf, buf ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_CAMELLIA_BAD_INPUT_DATA,
|
||||
mbedtls_camellia_crypt_ctr( &ctx,
|
||||
sizeof( buf ),
|
||||
&off,
|
||||
buf, NULL,
|
||||
buf, buf ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_CAMELLIA_BAD_INPUT_DATA,
|
||||
mbedtls_camellia_crypt_ctr( &ctx,
|
||||
sizeof( buf ),
|
||||
&off,
|
||||
buf, buf,
|
||||
NULL, buf ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_CAMELLIA_BAD_INPUT_DATA,
|
||||
mbedtls_camellia_crypt_ctr( &ctx,
|
||||
sizeof( buf ),
|
||||
&off,
|
||||
buf, buf,
|
||||
buf, NULL ) );
|
||||
#endif /* MBEDTLS_CIPHER_MODE_CTR */
|
||||
|
||||
exit:
|
||||
return;
|
||||
}
|
||||
/* END_CASE */
|
||||
|
||||
/* BEGIN_CASE */
|
||||
void camellia_encrypt_ecb( data_t * key_str, data_t * src_str,
|
||||
data_t * dst, int setkey_result )
|
||||
|
||||
@@ -1,9 +1,6 @@
|
||||
CCM self test
|
||||
mbedtls_ccm_self_test:
|
||||
|
||||
CCM - Invalid parameters
|
||||
ccm_invalid_param:
|
||||
|
||||
CCM - Valid parameters
|
||||
ccm_valid_param:
|
||||
|
||||
|
||||
@@ -292,210 +292,6 @@ exit:
|
||||
}
|
||||
/* END_CASE */
|
||||
|
||||
/* BEGIN_CASE depends_on:MBEDTLS_CHECK_PARAMS:!MBEDTLS_PARAM_FAILED_ALT */
|
||||
void ccm_invalid_param( )
|
||||
{
|
||||
struct mbedtls_ccm_context ctx;
|
||||
unsigned char valid_buffer[] = { 0x01, 0x02, 0x03, 0x04, 0x05, 0x06 };
|
||||
mbedtls_cipher_id_t valid_cipher = MBEDTLS_CIPHER_ID_AES;
|
||||
int valid_len = sizeof(valid_buffer);
|
||||
int valid_bitlen = valid_len * 8;
|
||||
|
||||
mbedtls_ccm_init( &ctx );
|
||||
|
||||
/* mbedtls_ccm_init() */
|
||||
TEST_INVALID_PARAM( mbedtls_ccm_init( NULL ) );
|
||||
|
||||
/* mbedtls_ccm_setkey() */
|
||||
TEST_INVALID_PARAM_RET(
|
||||
MBEDTLS_ERR_CCM_BAD_INPUT,
|
||||
mbedtls_ccm_setkey( NULL, valid_cipher, valid_buffer, valid_bitlen ) );
|
||||
TEST_INVALID_PARAM_RET(
|
||||
MBEDTLS_ERR_CCM_BAD_INPUT,
|
||||
mbedtls_ccm_setkey( &ctx, valid_cipher, NULL, valid_bitlen ) );
|
||||
|
||||
/* mbedtls_ccm_encrypt_and_tag() */
|
||||
TEST_INVALID_PARAM_RET(
|
||||
MBEDTLS_ERR_CCM_BAD_INPUT,
|
||||
mbedtls_ccm_encrypt_and_tag( NULL, valid_len,
|
||||
valid_buffer, valid_len,
|
||||
valid_buffer, valid_len,
|
||||
valid_buffer, valid_buffer,
|
||||
valid_buffer, valid_len ) );
|
||||
TEST_INVALID_PARAM_RET(
|
||||
MBEDTLS_ERR_CCM_BAD_INPUT,
|
||||
mbedtls_ccm_encrypt_and_tag( &ctx, valid_len,
|
||||
NULL, valid_len,
|
||||
valid_buffer, valid_len,
|
||||
valid_buffer, valid_buffer,
|
||||
valid_buffer, valid_len ) );
|
||||
TEST_INVALID_PARAM_RET(
|
||||
MBEDTLS_ERR_CCM_BAD_INPUT,
|
||||
mbedtls_ccm_encrypt_and_tag( &ctx, valid_len,
|
||||
valid_buffer, valid_len,
|
||||
NULL, valid_len,
|
||||
valid_buffer, valid_buffer,
|
||||
valid_buffer, valid_len ) );
|
||||
TEST_INVALID_PARAM_RET(
|
||||
MBEDTLS_ERR_CCM_BAD_INPUT,
|
||||
mbedtls_ccm_encrypt_and_tag( &ctx, valid_len,
|
||||
valid_buffer, valid_len,
|
||||
valid_buffer, valid_len,
|
||||
NULL, valid_buffer,
|
||||
valid_buffer, valid_len ) );
|
||||
TEST_INVALID_PARAM_RET(
|
||||
MBEDTLS_ERR_CCM_BAD_INPUT,
|
||||
mbedtls_ccm_encrypt_and_tag( &ctx, valid_len,
|
||||
valid_buffer, valid_len,
|
||||
valid_buffer, valid_len,
|
||||
valid_buffer, NULL,
|
||||
valid_buffer, valid_len ) );
|
||||
TEST_INVALID_PARAM_RET(
|
||||
MBEDTLS_ERR_CCM_BAD_INPUT,
|
||||
mbedtls_ccm_encrypt_and_tag( &ctx, valid_len,
|
||||
valid_buffer, valid_len,
|
||||
valid_buffer, valid_len,
|
||||
valid_buffer, valid_buffer,
|
||||
NULL, valid_len ) );
|
||||
|
||||
/* mbedtls_ccm_star_encrypt_and_tag() */
|
||||
TEST_INVALID_PARAM_RET(
|
||||
MBEDTLS_ERR_CCM_BAD_INPUT,
|
||||
mbedtls_ccm_star_encrypt_and_tag( NULL, valid_len,
|
||||
valid_buffer, valid_len,
|
||||
valid_buffer, valid_len,
|
||||
valid_buffer, valid_buffer,
|
||||
valid_buffer, valid_len) );
|
||||
TEST_INVALID_PARAM_RET(
|
||||
MBEDTLS_ERR_CCM_BAD_INPUT,
|
||||
mbedtls_ccm_star_encrypt_and_tag( &ctx, valid_len,
|
||||
NULL, valid_len,
|
||||
valid_buffer, valid_len,
|
||||
valid_buffer, valid_buffer,
|
||||
valid_buffer, valid_len ) );
|
||||
TEST_INVALID_PARAM_RET(
|
||||
MBEDTLS_ERR_CCM_BAD_INPUT,
|
||||
mbedtls_ccm_star_encrypt_and_tag( &ctx, valid_len,
|
||||
valid_buffer, valid_len,
|
||||
NULL, valid_len,
|
||||
valid_buffer, valid_buffer,
|
||||
valid_buffer, valid_len ) );
|
||||
TEST_INVALID_PARAM_RET(
|
||||
MBEDTLS_ERR_CCM_BAD_INPUT,
|
||||
mbedtls_ccm_star_encrypt_and_tag( &ctx, valid_len,
|
||||
valid_buffer, valid_len,
|
||||
valid_buffer, valid_len,
|
||||
NULL, valid_buffer,
|
||||
valid_buffer, valid_len ) );
|
||||
TEST_INVALID_PARAM_RET(
|
||||
MBEDTLS_ERR_CCM_BAD_INPUT,
|
||||
mbedtls_ccm_star_encrypt_and_tag( &ctx, valid_len,
|
||||
valid_buffer, valid_len,
|
||||
valid_buffer, valid_len,
|
||||
valid_buffer, NULL,
|
||||
valid_buffer, valid_len ) );
|
||||
TEST_INVALID_PARAM_RET(
|
||||
MBEDTLS_ERR_CCM_BAD_INPUT,
|
||||
mbedtls_ccm_star_encrypt_and_tag( &ctx, valid_len,
|
||||
valid_buffer, valid_len,
|
||||
valid_buffer, valid_len,
|
||||
valid_buffer, valid_buffer,
|
||||
NULL, valid_len ) );
|
||||
|
||||
/* mbedtls_ccm_auth_decrypt() */
|
||||
TEST_INVALID_PARAM_RET(
|
||||
MBEDTLS_ERR_CCM_BAD_INPUT,
|
||||
mbedtls_ccm_auth_decrypt( NULL, valid_len,
|
||||
valid_buffer, valid_len,
|
||||
valid_buffer, valid_len,
|
||||
valid_buffer, valid_buffer,
|
||||
valid_buffer, valid_len ) );
|
||||
TEST_INVALID_PARAM_RET(
|
||||
MBEDTLS_ERR_CCM_BAD_INPUT,
|
||||
mbedtls_ccm_auth_decrypt( &ctx, valid_len,
|
||||
NULL, valid_len,
|
||||
valid_buffer, valid_len,
|
||||
valid_buffer, valid_buffer,
|
||||
valid_buffer, valid_len ) );
|
||||
TEST_INVALID_PARAM_RET(
|
||||
MBEDTLS_ERR_CCM_BAD_INPUT,
|
||||
mbedtls_ccm_auth_decrypt( &ctx, valid_len,
|
||||
valid_buffer, valid_len,
|
||||
NULL, valid_len,
|
||||
valid_buffer, valid_buffer,
|
||||
valid_buffer, valid_len ) );
|
||||
TEST_INVALID_PARAM_RET(
|
||||
MBEDTLS_ERR_CCM_BAD_INPUT,
|
||||
mbedtls_ccm_auth_decrypt( &ctx, valid_len,
|
||||
valid_buffer, valid_len,
|
||||
valid_buffer, valid_len,
|
||||
NULL, valid_buffer,
|
||||
valid_buffer, valid_len ) );
|
||||
TEST_INVALID_PARAM_RET(
|
||||
MBEDTLS_ERR_CCM_BAD_INPUT,
|
||||
mbedtls_ccm_auth_decrypt( &ctx, valid_len,
|
||||
valid_buffer, valid_len,
|
||||
valid_buffer, valid_len,
|
||||
valid_buffer, NULL,
|
||||
valid_buffer, valid_len ) );
|
||||
TEST_INVALID_PARAM_RET(
|
||||
MBEDTLS_ERR_CCM_BAD_INPUT,
|
||||
mbedtls_ccm_auth_decrypt( &ctx, valid_len,
|
||||
valid_buffer, valid_len,
|
||||
valid_buffer, valid_len,
|
||||
valid_buffer, valid_buffer,
|
||||
NULL, valid_len ) );
|
||||
|
||||
/* mbedtls_ccm_star_auth_decrypt() */
|
||||
TEST_INVALID_PARAM_RET(
|
||||
MBEDTLS_ERR_CCM_BAD_INPUT,
|
||||
mbedtls_ccm_star_auth_decrypt( NULL, valid_len,
|
||||
valid_buffer, valid_len,
|
||||
valid_buffer, valid_len,
|
||||
valid_buffer, valid_buffer,
|
||||
valid_buffer, valid_len ) );
|
||||
TEST_INVALID_PARAM_RET(
|
||||
MBEDTLS_ERR_CCM_BAD_INPUT,
|
||||
mbedtls_ccm_star_auth_decrypt( &ctx, valid_len,
|
||||
NULL, valid_len,
|
||||
valid_buffer, valid_len,
|
||||
valid_buffer, valid_buffer,
|
||||
valid_buffer, valid_len ) );
|
||||
TEST_INVALID_PARAM_RET(
|
||||
MBEDTLS_ERR_CCM_BAD_INPUT,
|
||||
mbedtls_ccm_star_auth_decrypt( &ctx, valid_len,
|
||||
valid_buffer, valid_len,
|
||||
NULL, valid_len,
|
||||
valid_buffer, valid_buffer,
|
||||
valid_buffer, valid_len ) );
|
||||
TEST_INVALID_PARAM_RET(
|
||||
MBEDTLS_ERR_CCM_BAD_INPUT,
|
||||
mbedtls_ccm_star_auth_decrypt( &ctx, valid_len,
|
||||
valid_buffer, valid_len,
|
||||
valid_buffer, valid_len,
|
||||
NULL, valid_buffer,
|
||||
valid_buffer, valid_len ) );
|
||||
TEST_INVALID_PARAM_RET(
|
||||
MBEDTLS_ERR_CCM_BAD_INPUT,
|
||||
mbedtls_ccm_star_auth_decrypt( &ctx, valid_len,
|
||||
valid_buffer, valid_len,
|
||||
valid_buffer, valid_len,
|
||||
valid_buffer, NULL,
|
||||
valid_buffer, valid_len ) );
|
||||
TEST_INVALID_PARAM_RET(
|
||||
MBEDTLS_ERR_CCM_BAD_INPUT,
|
||||
mbedtls_ccm_star_auth_decrypt( &ctx, valid_len,
|
||||
valid_buffer, valid_len,
|
||||
valid_buffer, valid_len,
|
||||
valid_buffer, valid_buffer,
|
||||
NULL, valid_len ) );
|
||||
|
||||
exit:
|
||||
mbedtls_ccm_free( &ctx );
|
||||
return;
|
||||
}
|
||||
/* END_CASE */
|
||||
|
||||
/* BEGIN_CASE */
|
||||
void ccm_valid_param( )
|
||||
{
|
||||
|
||||
@@ -22,8 +22,5 @@ chacha20_crypt:"1c9240a5eb55d38af333888604f6b5f0473917c1402b80099dca5cbc207075c0
|
||||
ChaCha20 RFC 7539 Test Vector #3 (Decrypt)
|
||||
chacha20_crypt:"1c9240a5eb55d38af333888604f6b5f0473917c1402b80099dca5cbc207075c0":"000000000000000000000002":42:"62e6347f95ed87a45ffae7426f27a1df5fb69110044c0d73118effa95b01e5cf166d3df2d721caf9b21e5fb14c616871fd84c54f9d65b283196c7fe4f60553ebf39c6402c42234e32a356b3e764312a61a5532055716ead6962568f87d3f3f7704c6a8d1bcd1bf4d50d6154b6da731b187b58dfd728afa36757a797ac188d1":"2754776173206272696c6c69672c20616e642074686520736c6974687920746f7665730a446964206779726520616e642067696d626c6520696e2074686520776162653a0a416c6c206d696d737920776572652074686520626f726f676f7665732c0a416e6420746865206d6f6d65207261746873206f757467726162652e"
|
||||
|
||||
ChaCha20 Paremeter Validation
|
||||
chacha20_bad_params:
|
||||
|
||||
ChaCha20 Selftest
|
||||
chacha20_self_test:
|
||||
|
||||
@@ -66,52 +66,6 @@ void chacha20_crypt( data_t *key_str,
|
||||
}
|
||||
/* END_CASE */
|
||||
|
||||
/* BEGIN_CASE depends_on:MBEDTLS_CHECK_PARAMS:!MBEDTLS_PARAM_FAILED_ALT */
|
||||
void chacha20_bad_params()
|
||||
{
|
||||
unsigned char key[32];
|
||||
unsigned char nonce[12];
|
||||
unsigned char src[1];
|
||||
unsigned char dst[1];
|
||||
uint32_t counter = 0;
|
||||
size_t len = sizeof( src );
|
||||
mbedtls_chacha20_context ctx;
|
||||
|
||||
TEST_INVALID_PARAM( mbedtls_chacha20_init( NULL ) );
|
||||
TEST_VALID_PARAM( mbedtls_chacha20_free( NULL ) );
|
||||
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_CHACHA20_BAD_INPUT_DATA,
|
||||
mbedtls_chacha20_setkey( NULL, key ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_CHACHA20_BAD_INPUT_DATA,
|
||||
mbedtls_chacha20_setkey( &ctx, NULL ) );
|
||||
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_CHACHA20_BAD_INPUT_DATA,
|
||||
mbedtls_chacha20_starts( NULL, nonce, counter ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_CHACHA20_BAD_INPUT_DATA,
|
||||
mbedtls_chacha20_starts( &ctx, NULL, counter ) );
|
||||
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_CHACHA20_BAD_INPUT_DATA,
|
||||
mbedtls_chacha20_update( NULL, 0, src, dst ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_CHACHA20_BAD_INPUT_DATA,
|
||||
mbedtls_chacha20_update( &ctx, len, NULL, dst ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_CHACHA20_BAD_INPUT_DATA,
|
||||
mbedtls_chacha20_update( &ctx, len, src, NULL ) );
|
||||
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_CHACHA20_BAD_INPUT_DATA,
|
||||
mbedtls_chacha20_crypt( NULL, nonce, counter, 0, src, dst ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_CHACHA20_BAD_INPUT_DATA,
|
||||
mbedtls_chacha20_crypt( key, NULL, counter, 0, src, dst ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_CHACHA20_BAD_INPUT_DATA,
|
||||
mbedtls_chacha20_crypt( key, nonce, counter, len, NULL, dst ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_CHACHA20_BAD_INPUT_DATA,
|
||||
mbedtls_chacha20_crypt( key, nonce, counter, len, src, NULL ) );
|
||||
|
||||
exit:
|
||||
return;
|
||||
|
||||
}
|
||||
/* END_CASE */
|
||||
|
||||
/* BEGIN_CASE depends_on:MBEDTLS_SELF_TEST */
|
||||
void chacha20_self_test()
|
||||
{
|
||||
|
||||
@@ -19,9 +19,6 @@ mbedtls_chachapoly_dec:"1c9240a5eb55d38af333888604f6b5f0473917c1402b80099dca5cbc
|
||||
ChaCha20-Poly1305 State Flow
|
||||
chachapoly_state:
|
||||
|
||||
ChaCha20-Poly1305 Parameter Validation
|
||||
chachapoly_bad_params:
|
||||
|
||||
ChaCha20-Poly1305 Selftest
|
||||
depends_on:MBEDTLS_SELF_TEST
|
||||
chachapoly_selftest:
|
||||
|
||||
@@ -66,137 +66,6 @@ exit:
|
||||
}
|
||||
/* END_CASE */
|
||||
|
||||
/* BEGIN_CASE depends_on:MBEDTLS_CHECK_PARAMS:!MBEDTLS_PARAM_FAILED_ALT */
|
||||
void chachapoly_bad_params()
|
||||
{
|
||||
unsigned char key[32];
|
||||
unsigned char nonce[12];
|
||||
unsigned char aad[1];
|
||||
unsigned char input[1];
|
||||
unsigned char output[1];
|
||||
unsigned char mac[16];
|
||||
size_t input_len = sizeof( input );
|
||||
size_t aad_len = sizeof( aad );
|
||||
mbedtls_chachapoly_context ctx;
|
||||
|
||||
memset( key, 0x00, sizeof( key ) );
|
||||
memset( nonce, 0x00, sizeof( nonce ) );
|
||||
memset( aad, 0x00, sizeof( aad ) );
|
||||
memset( input, 0x00, sizeof( input ) );
|
||||
memset( output, 0x00, sizeof( output ) );
|
||||
memset( mac, 0x00, sizeof( mac ) );
|
||||
|
||||
TEST_INVALID_PARAM( mbedtls_chachapoly_init( NULL ) );
|
||||
TEST_VALID_PARAM( mbedtls_chachapoly_free( NULL ) );
|
||||
|
||||
/* setkey */
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_POLY1305_BAD_INPUT_DATA,
|
||||
mbedtls_chachapoly_setkey( NULL, key ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_POLY1305_BAD_INPUT_DATA,
|
||||
mbedtls_chachapoly_setkey( &ctx, NULL ) );
|
||||
|
||||
/* encrypt_and_tag */
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_POLY1305_BAD_INPUT_DATA,
|
||||
mbedtls_chachapoly_encrypt_and_tag( NULL,
|
||||
0, nonce,
|
||||
aad, 0,
|
||||
input, output, mac ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_POLY1305_BAD_INPUT_DATA,
|
||||
mbedtls_chachapoly_encrypt_and_tag( &ctx,
|
||||
0, NULL,
|
||||
aad, 0,
|
||||
input, output, mac ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_POLY1305_BAD_INPUT_DATA,
|
||||
mbedtls_chachapoly_encrypt_and_tag( &ctx,
|
||||
0, nonce,
|
||||
NULL, aad_len,
|
||||
input, output, mac ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_POLY1305_BAD_INPUT_DATA,
|
||||
mbedtls_chachapoly_encrypt_and_tag( &ctx,
|
||||
input_len, nonce,
|
||||
aad, 0,
|
||||
NULL, output, mac ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_POLY1305_BAD_INPUT_DATA,
|
||||
mbedtls_chachapoly_encrypt_and_tag( &ctx,
|
||||
input_len, nonce,
|
||||
aad, 0,
|
||||
input, NULL, mac ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_POLY1305_BAD_INPUT_DATA,
|
||||
mbedtls_chachapoly_encrypt_and_tag( &ctx,
|
||||
0, nonce,
|
||||
aad, 0,
|
||||
input, output, NULL ) );
|
||||
|
||||
/* auth_decrypt */
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_POLY1305_BAD_INPUT_DATA,
|
||||
mbedtls_chachapoly_auth_decrypt( NULL,
|
||||
0, nonce,
|
||||
aad, 0,
|
||||
mac, input, output ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_POLY1305_BAD_INPUT_DATA,
|
||||
mbedtls_chachapoly_auth_decrypt( &ctx,
|
||||
0, NULL,
|
||||
aad, 0,
|
||||
mac, input, output ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_POLY1305_BAD_INPUT_DATA,
|
||||
mbedtls_chachapoly_auth_decrypt( &ctx,
|
||||
0, nonce,
|
||||
NULL, aad_len,
|
||||
mac, input, output ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_POLY1305_BAD_INPUT_DATA,
|
||||
mbedtls_chachapoly_auth_decrypt( &ctx,
|
||||
0, nonce,
|
||||
aad, 0,
|
||||
NULL, input, output ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_POLY1305_BAD_INPUT_DATA,
|
||||
mbedtls_chachapoly_auth_decrypt( &ctx,
|
||||
input_len, nonce,
|
||||
aad, 0,
|
||||
mac, NULL, output ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_POLY1305_BAD_INPUT_DATA,
|
||||
mbedtls_chachapoly_auth_decrypt( &ctx,
|
||||
input_len, nonce,
|
||||
aad, 0,
|
||||
mac, input, NULL ) );
|
||||
|
||||
/* starts */
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_POLY1305_BAD_INPUT_DATA,
|
||||
mbedtls_chachapoly_starts( NULL, nonce,
|
||||
MBEDTLS_CHACHAPOLY_ENCRYPT ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_POLY1305_BAD_INPUT_DATA,
|
||||
mbedtls_chachapoly_starts( &ctx, NULL,
|
||||
MBEDTLS_CHACHAPOLY_ENCRYPT ) );
|
||||
|
||||
/* update_aad */
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_POLY1305_BAD_INPUT_DATA,
|
||||
mbedtls_chachapoly_update_aad( NULL, aad,
|
||||
aad_len ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_POLY1305_BAD_INPUT_DATA,
|
||||
mbedtls_chachapoly_update_aad( &ctx, NULL,
|
||||
aad_len ) );
|
||||
|
||||
/* update */
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_POLY1305_BAD_INPUT_DATA,
|
||||
mbedtls_chachapoly_update( NULL, input_len,
|
||||
input, output ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_POLY1305_BAD_INPUT_DATA,
|
||||
mbedtls_chachapoly_update( &ctx, input_len,
|
||||
NULL, output ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_POLY1305_BAD_INPUT_DATA,
|
||||
mbedtls_chachapoly_update( &ctx, input_len,
|
||||
input, NULL ) );
|
||||
|
||||
/* finish */
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_POLY1305_BAD_INPUT_DATA,
|
||||
mbedtls_chachapoly_finish( NULL, mac ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_POLY1305_BAD_INPUT_DATA,
|
||||
mbedtls_chachapoly_finish( &ctx, NULL ) );
|
||||
|
||||
exit:
|
||||
return;
|
||||
}
|
||||
/* END_CASE */
|
||||
|
||||
/* BEGIN_CASE */
|
||||
void chachapoly_state()
|
||||
{
|
||||
|
||||
@@ -207,330 +207,6 @@ exit:
|
||||
}
|
||||
/* END_CASE */
|
||||
|
||||
/* BEGIN_CASE depends_on:MBEDTLS_CHECK_PARAMS:!MBEDTLS_PARAM_FAILED_ALT */
|
||||
void cipher_invalid_param_conditional( )
|
||||
{
|
||||
mbedtls_cipher_context_t valid_ctx;
|
||||
|
||||
mbedtls_operation_t valid_operation = MBEDTLS_ENCRYPT;
|
||||
mbedtls_operation_t invalid_operation = 100;
|
||||
mbedtls_cipher_padding_t valid_mode = MBEDTLS_PADDING_ZEROS;
|
||||
unsigned char valid_buffer[] = { 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07 };
|
||||
int valid_size = sizeof(valid_buffer);
|
||||
int valid_bitlen = valid_size * 8;
|
||||
const mbedtls_cipher_info_t *valid_info = mbedtls_cipher_info_from_type(
|
||||
*( mbedtls_cipher_list() ) );
|
||||
|
||||
size_t size_t_var;
|
||||
|
||||
(void)valid_mode; /* In some configurations this is unused */
|
||||
|
||||
/* mbedtls_cipher_init() */
|
||||
TEST_VALID_PARAM( mbedtls_cipher_init( &valid_ctx ) );
|
||||
TEST_INVALID_PARAM( mbedtls_cipher_init( NULL ) );
|
||||
|
||||
/* mbedtls_cipher_setup() */
|
||||
TEST_VALID_PARAM( mbedtls_cipher_setup( &valid_ctx, valid_info ) );
|
||||
TEST_INVALID_PARAM_RET(
|
||||
MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA,
|
||||
mbedtls_cipher_setup( NULL, valid_info ) );
|
||||
|
||||
/* mbedtls_cipher_get_block_size() */
|
||||
TEST_INVALID_PARAM_RET( 0, mbedtls_cipher_get_block_size( NULL ) );
|
||||
|
||||
/* mbedtls_cipher_get_cipher_mode() */
|
||||
TEST_INVALID_PARAM_RET(
|
||||
MBEDTLS_MODE_NONE,
|
||||
mbedtls_cipher_get_cipher_mode( NULL ) );
|
||||
|
||||
/* mbedtls_cipher_get_iv_size() */
|
||||
TEST_INVALID_PARAM_RET( 0, mbedtls_cipher_get_iv_size( NULL ) );
|
||||
|
||||
/* mbedtls_cipher_get_type() */
|
||||
TEST_INVALID_PARAM_RET(
|
||||
MBEDTLS_CIPHER_NONE,
|
||||
mbedtls_cipher_get_type( NULL ) );
|
||||
|
||||
/* mbedtls_cipher_get_name() */
|
||||
TEST_INVALID_PARAM_RET( 0, mbedtls_cipher_get_name( NULL ) );
|
||||
|
||||
/* mbedtls_cipher_get_key_bitlen() */
|
||||
TEST_INVALID_PARAM_RET(
|
||||
MBEDTLS_KEY_LENGTH_NONE,
|
||||
mbedtls_cipher_get_key_bitlen( NULL ) );
|
||||
|
||||
/* mbedtls_cipher_get_operation() */
|
||||
TEST_INVALID_PARAM_RET(
|
||||
MBEDTLS_OPERATION_NONE,
|
||||
mbedtls_cipher_get_operation( NULL ) );
|
||||
|
||||
/* mbedtls_cipher_setkey() */
|
||||
TEST_INVALID_PARAM_RET(
|
||||
MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA,
|
||||
mbedtls_cipher_setkey( NULL,
|
||||
valid_buffer,
|
||||
valid_bitlen,
|
||||
valid_operation ) );
|
||||
TEST_INVALID_PARAM_RET(
|
||||
MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA,
|
||||
mbedtls_cipher_setkey( &valid_ctx,
|
||||
NULL,
|
||||
valid_bitlen,
|
||||
valid_operation ) );
|
||||
TEST_INVALID_PARAM_RET(
|
||||
MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA,
|
||||
mbedtls_cipher_setkey( &valid_ctx,
|
||||
valid_buffer,
|
||||
valid_bitlen,
|
||||
invalid_operation ) );
|
||||
|
||||
/* mbedtls_cipher_set_iv() */
|
||||
TEST_INVALID_PARAM_RET(
|
||||
MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA,
|
||||
mbedtls_cipher_set_iv( NULL,
|
||||
valid_buffer,
|
||||
valid_size ) );
|
||||
TEST_INVALID_PARAM_RET(
|
||||
MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA,
|
||||
mbedtls_cipher_set_iv( &valid_ctx,
|
||||
NULL,
|
||||
valid_size ) );
|
||||
|
||||
/* mbedtls_cipher_reset() */
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA,
|
||||
mbedtls_cipher_reset( NULL ) );
|
||||
|
||||
#if defined(MBEDTLS_GCM_C) || defined(MBEDTLS_CHACHAPOLY_C)
|
||||
/* mbedtls_cipher_update_ad() */
|
||||
TEST_INVALID_PARAM_RET(
|
||||
MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA,
|
||||
mbedtls_cipher_update_ad( NULL,
|
||||
valid_buffer,
|
||||
valid_size ) );
|
||||
TEST_INVALID_PARAM_RET(
|
||||
MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA,
|
||||
mbedtls_cipher_update_ad( &valid_ctx,
|
||||
NULL,
|
||||
valid_size ) );
|
||||
#endif /* defined(MBEDTLS_GCM_C) || defined(MBEDTLS_CHACHAPOLY_C) */
|
||||
|
||||
#if defined(MBEDTLS_CIPHER_MODE_WITH_PADDING)
|
||||
/* mbedtls_cipher_set_padding_mode() */
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA,
|
||||
mbedtls_cipher_set_padding_mode( NULL, valid_mode ) );
|
||||
#endif
|
||||
|
||||
/* mbedtls_cipher_update() */
|
||||
TEST_INVALID_PARAM_RET(
|
||||
MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA,
|
||||
mbedtls_cipher_update( NULL,
|
||||
valid_buffer,
|
||||
valid_size,
|
||||
valid_buffer,
|
||||
&size_t_var ) );
|
||||
TEST_INVALID_PARAM_RET(
|
||||
MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA,
|
||||
mbedtls_cipher_update( &valid_ctx,
|
||||
NULL, valid_size,
|
||||
valid_buffer,
|
||||
&size_t_var ) );
|
||||
TEST_INVALID_PARAM_RET(
|
||||
MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA,
|
||||
mbedtls_cipher_update( &valid_ctx,
|
||||
valid_buffer, valid_size,
|
||||
NULL,
|
||||
&size_t_var ) );
|
||||
TEST_INVALID_PARAM_RET(
|
||||
MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA,
|
||||
mbedtls_cipher_update( &valid_ctx,
|
||||
valid_buffer, valid_size,
|
||||
valid_buffer,
|
||||
NULL ) );
|
||||
|
||||
/* mbedtls_cipher_finish() */
|
||||
TEST_INVALID_PARAM_RET(
|
||||
MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA,
|
||||
mbedtls_cipher_finish( NULL,
|
||||
valid_buffer,
|
||||
&size_t_var ) );
|
||||
TEST_INVALID_PARAM_RET(
|
||||
MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA,
|
||||
mbedtls_cipher_finish( &valid_ctx,
|
||||
NULL,
|
||||
&size_t_var ) );
|
||||
TEST_INVALID_PARAM_RET(
|
||||
MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA,
|
||||
mbedtls_cipher_finish( &valid_ctx,
|
||||
valid_buffer,
|
||||
NULL ) );
|
||||
|
||||
#if defined(MBEDTLS_GCM_C) || defined(MBEDTLS_CHACHAPOLY_C)
|
||||
/* mbedtls_cipher_write_tag() */
|
||||
TEST_INVALID_PARAM_RET(
|
||||
MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA,
|
||||
mbedtls_cipher_write_tag( NULL,
|
||||
valid_buffer,
|
||||
valid_size ) );
|
||||
TEST_INVALID_PARAM_RET(
|
||||
MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA,
|
||||
mbedtls_cipher_write_tag( &valid_ctx,
|
||||
NULL,
|
||||
valid_size ) );
|
||||
|
||||
/* mbedtls_cipher_check_tag() */
|
||||
TEST_INVALID_PARAM_RET(
|
||||
MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA,
|
||||
mbedtls_cipher_check_tag( NULL,
|
||||
valid_buffer,
|
||||
valid_size ) );
|
||||
TEST_INVALID_PARAM_RET(
|
||||
MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA,
|
||||
mbedtls_cipher_check_tag( &valid_ctx,
|
||||
NULL,
|
||||
valid_size ) );
|
||||
#endif /* defined(MBEDTLS_GCM_C) || defined(MBEDTLS_CHACHAPOLY_C) */
|
||||
|
||||
/* mbedtls_cipher_crypt() */
|
||||
TEST_INVALID_PARAM_RET(
|
||||
MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA,
|
||||
mbedtls_cipher_crypt( NULL,
|
||||
valid_buffer, valid_size,
|
||||
valid_buffer, valid_size,
|
||||
valid_buffer, &size_t_var ) );
|
||||
TEST_INVALID_PARAM_RET(
|
||||
MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA,
|
||||
mbedtls_cipher_crypt( &valid_ctx,
|
||||
NULL, valid_size,
|
||||
valid_buffer, valid_size,
|
||||
valid_buffer, &size_t_var ) );
|
||||
TEST_INVALID_PARAM_RET(
|
||||
MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA,
|
||||
mbedtls_cipher_crypt( &valid_ctx,
|
||||
valid_buffer, valid_size,
|
||||
NULL, valid_size,
|
||||
valid_buffer, &size_t_var ) );
|
||||
TEST_INVALID_PARAM_RET(
|
||||
MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA,
|
||||
mbedtls_cipher_crypt( &valid_ctx,
|
||||
valid_buffer, valid_size,
|
||||
valid_buffer, valid_size,
|
||||
NULL, &size_t_var ) );
|
||||
TEST_INVALID_PARAM_RET(
|
||||
MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA,
|
||||
mbedtls_cipher_crypt( &valid_ctx,
|
||||
valid_buffer, valid_size,
|
||||
valid_buffer, valid_size,
|
||||
valid_buffer, NULL ) );
|
||||
|
||||
#if defined(MBEDTLS_CIPHER_MODE_AEAD) || defined(MBEDTLS_NIST_KW_C)
|
||||
/* mbedtls_cipher_auth_encrypt_ext */
|
||||
TEST_INVALID_PARAM_RET(
|
||||
MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA,
|
||||
mbedtls_cipher_auth_encrypt_ext( NULL,
|
||||
valid_buffer, valid_size,
|
||||
valid_buffer, valid_size,
|
||||
valid_buffer, valid_size,
|
||||
valid_buffer, valid_size, &size_t_var,
|
||||
valid_size ) );
|
||||
TEST_INVALID_PARAM_RET(
|
||||
MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA,
|
||||
mbedtls_cipher_auth_encrypt_ext( &valid_ctx,
|
||||
NULL, valid_size,
|
||||
valid_buffer, valid_size,
|
||||
valid_buffer, valid_size,
|
||||
valid_buffer, valid_size, &size_t_var,
|
||||
valid_size ) );
|
||||
TEST_INVALID_PARAM_RET(
|
||||
MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA,
|
||||
mbedtls_cipher_auth_encrypt_ext( &valid_ctx,
|
||||
valid_buffer, valid_size,
|
||||
NULL, valid_size,
|
||||
valid_buffer, valid_size,
|
||||
valid_buffer, valid_size, &size_t_var,
|
||||
valid_size ) );
|
||||
TEST_INVALID_PARAM_RET(
|
||||
MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA,
|
||||
mbedtls_cipher_auth_encrypt_ext( &valid_ctx,
|
||||
valid_buffer, valid_size,
|
||||
valid_buffer, valid_size,
|
||||
NULL, valid_size,
|
||||
valid_buffer, valid_size, &size_t_var,
|
||||
valid_size ) );
|
||||
TEST_INVALID_PARAM_RET(
|
||||
MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA,
|
||||
mbedtls_cipher_auth_encrypt_ext( &valid_ctx,
|
||||
valid_buffer, valid_size,
|
||||
valid_buffer, valid_size,
|
||||
valid_buffer, valid_size,
|
||||
NULL, valid_size, &size_t_var,
|
||||
valid_size ) );
|
||||
TEST_INVALID_PARAM_RET(
|
||||
MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA,
|
||||
mbedtls_cipher_auth_encrypt_ext( &valid_ctx,
|
||||
valid_buffer, valid_size,
|
||||
valid_buffer, valid_size,
|
||||
valid_buffer, valid_size,
|
||||
valid_buffer, valid_size, NULL,
|
||||
valid_size ) );
|
||||
|
||||
/* mbedtls_cipher_auth_decrypt_ext */
|
||||
TEST_INVALID_PARAM_RET(
|
||||
MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA,
|
||||
mbedtls_cipher_auth_decrypt_ext( NULL,
|
||||
valid_buffer, valid_size,
|
||||
valid_buffer, valid_size,
|
||||
valid_buffer, valid_size,
|
||||
valid_buffer, valid_size, &size_t_var,
|
||||
valid_size ) );
|
||||
TEST_INVALID_PARAM_RET(
|
||||
MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA,
|
||||
mbedtls_cipher_auth_decrypt_ext( &valid_ctx,
|
||||
NULL, valid_size,
|
||||
valid_buffer, valid_size,
|
||||
valid_buffer, valid_size,
|
||||
valid_buffer, valid_size, &size_t_var,
|
||||
valid_size ) );
|
||||
TEST_INVALID_PARAM_RET(
|
||||
MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA,
|
||||
mbedtls_cipher_auth_decrypt_ext( &valid_ctx,
|
||||
valid_buffer, valid_size,
|
||||
NULL, valid_size,
|
||||
valid_buffer, valid_size,
|
||||
valid_buffer, valid_size, &size_t_var,
|
||||
valid_size ) );
|
||||
TEST_INVALID_PARAM_RET(
|
||||
MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA,
|
||||
mbedtls_cipher_auth_decrypt_ext( &valid_ctx,
|
||||
valid_buffer, valid_size,
|
||||
valid_buffer, valid_size,
|
||||
NULL, valid_size,
|
||||
valid_buffer, valid_size, &size_t_var,
|
||||
valid_size ) );
|
||||
TEST_INVALID_PARAM_RET(
|
||||
MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA,
|
||||
mbedtls_cipher_auth_decrypt_ext( &valid_ctx,
|
||||
valid_buffer, valid_size,
|
||||
valid_buffer, valid_size,
|
||||
valid_buffer, valid_size,
|
||||
NULL, valid_size, &size_t_var,
|
||||
valid_size ) );
|
||||
TEST_INVALID_PARAM_RET(
|
||||
MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA,
|
||||
mbedtls_cipher_auth_decrypt_ext( &valid_ctx,
|
||||
valid_buffer, valid_size,
|
||||
valid_buffer, valid_size,
|
||||
valid_buffer, valid_size,
|
||||
valid_buffer, valid_size, NULL,
|
||||
valid_size ) );
|
||||
#endif /* MBEDTLS_CIPHER_MODE_AEAD || MBEDTLS_NIST_KW_C */
|
||||
|
||||
/* mbedtls_cipher_free() */
|
||||
TEST_VALID_PARAM( mbedtls_cipher_free( NULL ) );
|
||||
exit:
|
||||
TEST_VALID_PARAM( mbedtls_cipher_free( &valid_ctx ) );
|
||||
}
|
||||
/* END_CASE */
|
||||
|
||||
/* BEGIN_CASE depends_on:MBEDTLS_AES_C */
|
||||
void cipher_special_behaviours( )
|
||||
{
|
||||
|
||||
@@ -1,5 +1,2 @@
|
||||
CIPHER - Conditional invalid parameter checks
|
||||
cipher_invalid_param_conditional:
|
||||
|
||||
CIPHER - Unconditional invalid parameter checks
|
||||
cipher_invalid_param_unconditional:
|
||||
|
||||
@@ -1,6 +1,3 @@
|
||||
Diffie-Hellman parameter validation
|
||||
dhm_invalid_params:
|
||||
|
||||
Diffie-Hellman full exchange #1
|
||||
dhm_do_dhm:10:"23":10:"5":0
|
||||
|
||||
|
||||
@@ -7,113 +7,6 @@
|
||||
* END_DEPENDENCIES
|
||||
*/
|
||||
|
||||
/* BEGIN_CASE depends_on:MBEDTLS_CHECK_PARAMS:!MBEDTLS_PARAM_FAILED_ALT */
|
||||
void dhm_invalid_params( )
|
||||
{
|
||||
mbedtls_dhm_context ctx;
|
||||
unsigned char buf[42] = { 0 };
|
||||
unsigned char *buf_null = NULL;
|
||||
mbedtls_mpi X;
|
||||
size_t const buflen = sizeof( buf );
|
||||
size_t len;
|
||||
|
||||
TEST_INVALID_PARAM( mbedtls_dhm_init( NULL ) );
|
||||
TEST_VALID_PARAM( mbedtls_dhm_free( NULL ) );
|
||||
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_DHM_BAD_INPUT_DATA,
|
||||
mbedtls_dhm_read_params( NULL,
|
||||
(unsigned char**) &buf,
|
||||
buf ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_DHM_BAD_INPUT_DATA,
|
||||
mbedtls_dhm_read_params( &ctx, &buf_null, buf ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_DHM_BAD_INPUT_DATA,
|
||||
mbedtls_dhm_read_params( &ctx, NULL, buf ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_DHM_BAD_INPUT_DATA,
|
||||
mbedtls_dhm_read_params( &ctx,
|
||||
(unsigned char**) &buf,
|
||||
NULL ) );
|
||||
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_DHM_BAD_INPUT_DATA,
|
||||
mbedtls_dhm_make_params( NULL, buflen,
|
||||
buf, &len,
|
||||
mbedtls_test_rnd_std_rand,
|
||||
NULL ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_DHM_BAD_INPUT_DATA,
|
||||
mbedtls_dhm_make_params( &ctx, buflen,
|
||||
NULL, &len,
|
||||
mbedtls_test_rnd_std_rand,
|
||||
NULL ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_DHM_BAD_INPUT_DATA,
|
||||
mbedtls_dhm_make_params( &ctx, buflen,
|
||||
buf, NULL,
|
||||
mbedtls_test_rnd_std_rand,
|
||||
NULL ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_DHM_BAD_INPUT_DATA,
|
||||
mbedtls_dhm_make_params( &ctx, buflen,
|
||||
buf, &len,
|
||||
NULL,
|
||||
NULL ) );
|
||||
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_DHM_BAD_INPUT_DATA,
|
||||
mbedtls_dhm_set_group( NULL, &X, &X ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_DHM_BAD_INPUT_DATA,
|
||||
mbedtls_dhm_set_group( &ctx, NULL, &X ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_DHM_BAD_INPUT_DATA,
|
||||
mbedtls_dhm_set_group( &ctx, &X, NULL ) );
|
||||
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_DHM_BAD_INPUT_DATA,
|
||||
mbedtls_dhm_read_public( NULL, buf, buflen ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_DHM_BAD_INPUT_DATA,
|
||||
mbedtls_dhm_read_public( &ctx, NULL, buflen ) );
|
||||
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_DHM_BAD_INPUT_DATA,
|
||||
mbedtls_dhm_make_public( NULL, buflen,
|
||||
buf, buflen,
|
||||
mbedtls_test_rnd_std_rand,
|
||||
NULL ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_DHM_BAD_INPUT_DATA,
|
||||
mbedtls_dhm_make_public( &ctx, buflen,
|
||||
NULL, buflen,
|
||||
mbedtls_test_rnd_std_rand,
|
||||
NULL ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_DHM_BAD_INPUT_DATA,
|
||||
mbedtls_dhm_make_public( &ctx, buflen,
|
||||
buf, buflen,
|
||||
NULL,
|
||||
NULL ) );
|
||||
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_DHM_BAD_INPUT_DATA,
|
||||
mbedtls_dhm_calc_secret( NULL, buf, buflen, &len,
|
||||
mbedtls_test_rnd_std_rand,
|
||||
NULL ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_DHM_BAD_INPUT_DATA,
|
||||
mbedtls_dhm_calc_secret( &ctx, NULL, buflen, &len,
|
||||
mbedtls_test_rnd_std_rand,
|
||||
NULL ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_DHM_BAD_INPUT_DATA,
|
||||
mbedtls_dhm_calc_secret( &ctx, buf, buflen, NULL,
|
||||
mbedtls_test_rnd_std_rand,
|
||||
NULL ) );
|
||||
|
||||
#if defined(MBEDTLS_ASN1_PARSE_C)
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_DHM_BAD_INPUT_DATA,
|
||||
mbedtls_dhm_parse_dhm( NULL, buf, buflen ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_DHM_BAD_INPUT_DATA,
|
||||
mbedtls_dhm_parse_dhm( &ctx, NULL, buflen ) );
|
||||
|
||||
#if defined(MBEDTLS_FS_IO)
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_DHM_BAD_INPUT_DATA,
|
||||
mbedtls_dhm_parse_dhmfile( NULL, "" ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_DHM_BAD_INPUT_DATA,
|
||||
mbedtls_dhm_parse_dhmfile( &ctx, NULL ) );
|
||||
#endif /* MBEDTLS_FS_IO */
|
||||
#endif /* MBEDTLS_ASN1_PARSE_C */
|
||||
|
||||
exit:
|
||||
return;
|
||||
}
|
||||
/* END_CASE */
|
||||
|
||||
/* BEGIN_CASE */
|
||||
void dhm_do_dhm( int radix_P, char *input_P,
|
||||
int radix_G, char *input_G, int result )
|
||||
|
||||
@@ -1,9 +1,6 @@
|
||||
ECDH - Valid parameters
|
||||
ecdh_valid_param:
|
||||
|
||||
ECDH - Invalid parameters
|
||||
ecdh_invalid_param:
|
||||
|
||||
ECDH primitive random #1
|
||||
depends_on:MBEDTLS_ECP_DP_SECP192R1_ENABLED
|
||||
ecdh_primitive_random:MBEDTLS_ECP_DP_SECP192R1
|
||||
|
||||
@@ -50,139 +50,6 @@ void ecdh_valid_param( )
|
||||
}
|
||||
/* END_CASE */
|
||||
|
||||
/* BEGIN_CASE depends_on:MBEDTLS_CHECK_PARAMS:!MBEDTLS_PARAM_FAILED_ALT */
|
||||
void ecdh_invalid_param( )
|
||||
{
|
||||
mbedtls_ecp_group grp;
|
||||
mbedtls_ecdh_context ctx;
|
||||
mbedtls_mpi m;
|
||||
mbedtls_ecp_point P;
|
||||
mbedtls_ecp_keypair kp;
|
||||
size_t olen;
|
||||
unsigned char buf[42] = { 0 };
|
||||
const unsigned char *buf_null = NULL;
|
||||
size_t const buflen = sizeof( buf );
|
||||
int invalid_side = 42;
|
||||
mbedtls_ecp_group_id valid_grp = MBEDTLS_ECP_DP_SECP192R1;
|
||||
|
||||
TEST_INVALID_PARAM( mbedtls_ecdh_init( NULL ) );
|
||||
|
||||
#if defined(MBEDTLS_ECP_RESTARTABLE)
|
||||
TEST_INVALID_PARAM( mbedtls_ecdh_enable_restart( NULL ) );
|
||||
#endif /* MBEDTLS_ECP_RESTARTABLE */
|
||||
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
|
||||
mbedtls_ecdh_gen_public( NULL, &m, &P,
|
||||
mbedtls_test_rnd_std_rand,
|
||||
NULL ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
|
||||
mbedtls_ecdh_gen_public( &grp, NULL, &P,
|
||||
mbedtls_test_rnd_std_rand,
|
||||
NULL ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
|
||||
mbedtls_ecdh_gen_public( &grp, &m, NULL,
|
||||
mbedtls_test_rnd_std_rand,
|
||||
NULL ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
|
||||
mbedtls_ecdh_gen_public( &grp, &m, &P,
|
||||
NULL, NULL ) );
|
||||
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
|
||||
mbedtls_ecdh_compute_shared( NULL, &m, &P, &m,
|
||||
mbedtls_test_rnd_std_rand,
|
||||
NULL ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
|
||||
mbedtls_ecdh_compute_shared( &grp, NULL, &P, &m,
|
||||
mbedtls_test_rnd_std_rand,
|
||||
NULL ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
|
||||
mbedtls_ecdh_compute_shared( &grp, &m, NULL, &m,
|
||||
mbedtls_test_rnd_std_rand,
|
||||
NULL ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
|
||||
mbedtls_ecdh_compute_shared( &grp, &m, &P, NULL,
|
||||
mbedtls_test_rnd_std_rand,
|
||||
NULL ) );
|
||||
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
|
||||
mbedtls_ecdh_setup( NULL, valid_grp ) );
|
||||
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
|
||||
mbedtls_ecdh_make_params( NULL, &olen, buf, buflen,
|
||||
mbedtls_test_rnd_std_rand, NULL ) );
|
||||
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
|
||||
mbedtls_ecdh_make_params( &ctx, NULL, buf, buflen,
|
||||
mbedtls_test_rnd_std_rand, NULL ) );
|
||||
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
|
||||
mbedtls_ecdh_make_params( &ctx, &olen, NULL, buflen,
|
||||
mbedtls_test_rnd_std_rand, NULL ) );
|
||||
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
|
||||
mbedtls_ecdh_make_params( &ctx, &olen, buf, buflen, NULL, NULL ) );
|
||||
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
|
||||
mbedtls_ecdh_read_params( NULL,
|
||||
(const unsigned char**) &buf,
|
||||
buf ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
|
||||
mbedtls_ecdh_read_params( &ctx, &buf_null,
|
||||
buf ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
|
||||
mbedtls_ecdh_read_params( &ctx, NULL, buf ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
|
||||
mbedtls_ecdh_read_params( &ctx,
|
||||
(const unsigned char**) &buf,
|
||||
NULL ) );
|
||||
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
|
||||
mbedtls_ecdh_get_params( NULL, &kp,
|
||||
MBEDTLS_ECDH_OURS ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
|
||||
mbedtls_ecdh_get_params( &ctx, NULL,
|
||||
MBEDTLS_ECDH_OURS ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
|
||||
mbedtls_ecdh_get_params( &ctx, &kp,
|
||||
invalid_side ) );
|
||||
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
|
||||
mbedtls_ecdh_make_public( NULL, &olen, buf, buflen,
|
||||
mbedtls_test_rnd_std_rand, NULL ) );
|
||||
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
|
||||
mbedtls_ecdh_make_public( &ctx, NULL, buf, buflen,
|
||||
mbedtls_test_rnd_std_rand, NULL ) );
|
||||
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
|
||||
mbedtls_ecdh_make_public( &ctx, &olen, NULL, buflen,
|
||||
mbedtls_test_rnd_std_rand, NULL ) );
|
||||
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
|
||||
mbedtls_ecdh_make_public( &ctx, &olen, buf, buflen, NULL, NULL ) );
|
||||
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
|
||||
mbedtls_ecdh_read_public( NULL, buf, buflen ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
|
||||
mbedtls_ecdh_read_public( &ctx, NULL, buflen ) );
|
||||
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
|
||||
mbedtls_ecdh_calc_secret( NULL, &olen, buf, buflen,
|
||||
mbedtls_test_rnd_std_rand, NULL ) );
|
||||
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
|
||||
mbedtls_ecdh_calc_secret( &ctx, NULL, buf, buflen,
|
||||
mbedtls_test_rnd_std_rand, NULL ) );
|
||||
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
|
||||
mbedtls_ecdh_calc_secret( &ctx, &olen, NULL, buflen,
|
||||
mbedtls_test_rnd_std_rand, NULL ) );
|
||||
|
||||
exit:
|
||||
return;
|
||||
}
|
||||
/* END_CASE */
|
||||
|
||||
/* BEGIN_CASE */
|
||||
void ecdh_primitive_random( int id )
|
||||
{
|
||||
|
||||
@@ -1,6 +1,3 @@
|
||||
ECDSA Parameter validation
|
||||
ecdsa_invalid_param:
|
||||
|
||||
ECDSA primitive hash zero #1
|
||||
depends_on:MBEDTLS_ECP_DP_SECP192R1_ENABLED
|
||||
ecdsa_prim_zero:MBEDTLS_ECP_DP_SECP192R1
|
||||
|
||||
@@ -7,203 +7,6 @@
|
||||
* END_DEPENDENCIES
|
||||
*/
|
||||
|
||||
/* BEGIN_CASE depends_on:MBEDTLS_CHECK_PARAMS:!MBEDTLS_PARAM_FAILED_ALT */
|
||||
void ecdsa_invalid_param( )
|
||||
{
|
||||
mbedtls_ecdsa_context ctx;
|
||||
mbedtls_ecp_keypair key;
|
||||
mbedtls_ecp_group grp;
|
||||
mbedtls_ecp_group_id valid_group = MBEDTLS_ECP_DP_SECP192R1;
|
||||
mbedtls_ecp_point P;
|
||||
mbedtls_md_type_t valid_md = MBEDTLS_MD_SHA256;
|
||||
mbedtls_mpi m;
|
||||
size_t slen;
|
||||
unsigned char buf[42] = { 0 };
|
||||
|
||||
TEST_INVALID_PARAM( mbedtls_ecdsa_init( NULL ) );
|
||||
TEST_VALID_PARAM( mbedtls_ecdsa_free( NULL ) );
|
||||
|
||||
#if defined(MBEDTLS_ECP_RESTARTABLE)
|
||||
TEST_INVALID_PARAM( mbedtls_ecdsa_restart_init( NULL ) );
|
||||
TEST_VALID_PARAM( mbedtls_ecdsa_restart_free( NULL ) );
|
||||
#endif /* MBEDTLS_ECP_RESTARTABLE */
|
||||
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
|
||||
mbedtls_ecdsa_sign( NULL, &m, &m, &m,
|
||||
buf, sizeof( buf ),
|
||||
mbedtls_test_rnd_std_rand,
|
||||
NULL ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
|
||||
mbedtls_ecdsa_sign( &grp, NULL, &m, &m,
|
||||
buf, sizeof( buf ),
|
||||
mbedtls_test_rnd_std_rand,
|
||||
NULL ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
|
||||
mbedtls_ecdsa_sign( &grp, &m, NULL, &m,
|
||||
buf, sizeof( buf ),
|
||||
mbedtls_test_rnd_std_rand,
|
||||
NULL ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
|
||||
mbedtls_ecdsa_sign( &grp, &m, &m, NULL,
|
||||
buf, sizeof( buf ),
|
||||
mbedtls_test_rnd_std_rand,
|
||||
NULL ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
|
||||
mbedtls_ecdsa_sign( &grp, &m, &m, &m,
|
||||
NULL, sizeof( buf ),
|
||||
mbedtls_test_rnd_std_rand,
|
||||
NULL ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
|
||||
mbedtls_ecdsa_sign( &grp, &m, &m, &m,
|
||||
buf, sizeof( buf ),
|
||||
NULL, NULL ) );
|
||||
|
||||
#if defined(MBEDTLS_ECDSA_DETERMINISTIC)
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
|
||||
mbedtls_ecdsa_sign_det_ext( NULL, &m, &m, &m,
|
||||
buf, sizeof( buf ),
|
||||
valid_md,
|
||||
mbedtls_test_rnd_std_rand,
|
||||
NULL ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
|
||||
mbedtls_ecdsa_sign_det_ext( &grp, NULL, &m, &m,
|
||||
buf, sizeof( buf ),
|
||||
valid_md,
|
||||
mbedtls_test_rnd_std_rand,
|
||||
NULL ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
|
||||
mbedtls_ecdsa_sign_det_ext( &grp, &m, NULL, &m,
|
||||
buf, sizeof( buf ),
|
||||
valid_md,
|
||||
mbedtls_test_rnd_std_rand,
|
||||
NULL ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
|
||||
mbedtls_ecdsa_sign_det_ext( &grp, &m, &m, NULL,
|
||||
buf, sizeof( buf ),
|
||||
valid_md,
|
||||
mbedtls_test_rnd_std_rand,
|
||||
NULL ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
|
||||
mbedtls_ecdsa_sign_det_ext( &grp, &m, &m, &m,
|
||||
NULL, sizeof( buf ),
|
||||
valid_md,
|
||||
mbedtls_test_rnd_std_rand,
|
||||
NULL ) );
|
||||
#endif /* MBEDTLS_ECDSA_DETERMINISTIC */
|
||||
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
|
||||
mbedtls_ecdsa_verify( NULL,
|
||||
buf, sizeof( buf ),
|
||||
&P, &m, &m ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
|
||||
mbedtls_ecdsa_verify( &grp,
|
||||
NULL, sizeof( buf ),
|
||||
&P, &m, &m ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
|
||||
mbedtls_ecdsa_verify( &grp,
|
||||
buf, sizeof( buf ),
|
||||
NULL, &m, &m ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
|
||||
mbedtls_ecdsa_verify( &grp,
|
||||
buf, sizeof( buf ),
|
||||
&P, NULL, &m ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
|
||||
mbedtls_ecdsa_verify( &grp,
|
||||
buf, sizeof( buf ),
|
||||
&P, &m, NULL ) );
|
||||
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
|
||||
mbedtls_ecdsa_write_signature( NULL, valid_md, buf, sizeof( buf ),
|
||||
buf, &slen, mbedtls_test_rnd_std_rand,
|
||||
NULL ) );
|
||||
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
|
||||
mbedtls_ecdsa_write_signature( &ctx, valid_md, NULL, sizeof( buf ),
|
||||
buf, &slen, mbedtls_test_rnd_std_rand,
|
||||
NULL ) );
|
||||
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
|
||||
mbedtls_ecdsa_write_signature( &ctx, valid_md, buf, sizeof( buf ),
|
||||
NULL, &slen, mbedtls_test_rnd_std_rand,
|
||||
NULL ) );
|
||||
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
|
||||
mbedtls_ecdsa_write_signature( &ctx, valid_md, buf, sizeof( buf ),
|
||||
buf, NULL, mbedtls_test_rnd_std_rand,
|
||||
NULL ) );
|
||||
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
|
||||
mbedtls_ecdsa_write_signature_restartable( NULL, valid_md, buf,
|
||||
sizeof( buf ), buf, &slen,
|
||||
mbedtls_test_rnd_std_rand,
|
||||
NULL, NULL ) );
|
||||
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
|
||||
mbedtls_ecdsa_write_signature_restartable( &ctx, valid_md, NULL,
|
||||
sizeof( buf ), buf, &slen,
|
||||
mbedtls_test_rnd_std_rand,
|
||||
NULL, NULL ) );
|
||||
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
|
||||
mbedtls_ecdsa_write_signature_restartable( &ctx, valid_md, buf,
|
||||
sizeof( buf ), NULL, &slen,
|
||||
mbedtls_test_rnd_std_rand,
|
||||
NULL, NULL ) );
|
||||
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
|
||||
mbedtls_ecdsa_write_signature_restartable( &ctx, valid_md, buf,
|
||||
sizeof( buf ), buf, NULL,
|
||||
mbedtls_test_rnd_std_rand,
|
||||
NULL, NULL ) );
|
||||
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
|
||||
mbedtls_ecdsa_read_signature( NULL,
|
||||
buf, sizeof( buf ),
|
||||
buf, sizeof( buf ) ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
|
||||
mbedtls_ecdsa_read_signature( &ctx,
|
||||
NULL, sizeof( buf ),
|
||||
buf, sizeof( buf ) ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
|
||||
mbedtls_ecdsa_read_signature( &ctx,
|
||||
buf, sizeof( buf ),
|
||||
NULL, sizeof( buf ) ) );
|
||||
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
|
||||
mbedtls_ecdsa_read_signature_restartable( NULL,
|
||||
buf, sizeof( buf ),
|
||||
buf, sizeof( buf ),
|
||||
NULL ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
|
||||
mbedtls_ecdsa_read_signature_restartable( &ctx,
|
||||
NULL, sizeof( buf ),
|
||||
buf, sizeof( buf ),
|
||||
NULL ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
|
||||
mbedtls_ecdsa_read_signature_restartable( &ctx,
|
||||
buf, sizeof( buf ),
|
||||
NULL, sizeof( buf ),
|
||||
NULL ) );
|
||||
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
|
||||
mbedtls_ecdsa_genkey( NULL, valid_group,
|
||||
mbedtls_test_rnd_std_rand,
|
||||
NULL ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
|
||||
mbedtls_ecdsa_genkey( &ctx, valid_group,
|
||||
NULL, NULL ) );
|
||||
|
||||
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
|
||||
mbedtls_ecdsa_from_keypair( NULL, &key ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
|
||||
mbedtls_ecdsa_from_keypair( &ctx, NULL ) );
|
||||
|
||||
exit:
|
||||
return;
|
||||
}
|
||||
/* END_CASE */
|
||||
|
||||
/* BEGIN_CASE */
|
||||
void ecdsa_prim_zero( int id )
|
||||
{
|
||||
|
||||
@@ -1,6 +1,3 @@
|
||||
ECJPAKE parameter validation
|
||||
ecjpake_invalid_param:
|
||||
|
||||
ECJPAKE selftest
|
||||
ecjpake_selftest:
|
||||
|
||||
|
||||
@@ -98,106 +98,6 @@ cleanup:
|
||||
* END_DEPENDENCIES
|
||||
*/
|
||||
|
||||
/* BEGIN_CASE depends_on:MBEDTLS_CHECK_PARAMS:!MBEDTLS_PARAM_FAILED_ALT */
|
||||
void ecjpake_invalid_param( )
|
||||
{
|
||||
mbedtls_ecjpake_context ctx;
|
||||
unsigned char buf[42] = { 0 };
|
||||
size_t olen;
|
||||
size_t const len = sizeof( buf );
|
||||
mbedtls_ecjpake_role valid_role = MBEDTLS_ECJPAKE_SERVER;
|
||||
mbedtls_ecjpake_role invalid_role = (mbedtls_ecjpake_role) 42;
|
||||
mbedtls_md_type_t valid_md = MBEDTLS_MD_SHA256;
|
||||
mbedtls_ecp_group_id valid_group = MBEDTLS_ECP_DP_SECP256R1;
|
||||
|
||||
TEST_INVALID_PARAM( mbedtls_ecjpake_init( NULL ) );
|
||||
TEST_VALID_PARAM( mbedtls_ecjpake_free( NULL ) );
|
||||
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
|
||||
mbedtls_ecjpake_setup( NULL,
|
||||
valid_role,
|
||||
valid_md,
|
||||
valid_group,
|
||||
buf, len ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
|
||||
mbedtls_ecjpake_setup( &ctx,
|
||||
invalid_role,
|
||||
valid_md,
|
||||
valid_group,
|
||||
buf, len ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
|
||||
mbedtls_ecjpake_setup( &ctx,
|
||||
valid_role,
|
||||
valid_md,
|
||||
valid_group,
|
||||
NULL, len ) );
|
||||
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
|
||||
mbedtls_ecjpake_check( NULL ) );
|
||||
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
|
||||
mbedtls_ecjpake_write_round_one( NULL, buf, len, &olen,
|
||||
mbedtls_test_rnd_std_rand, NULL ) );
|
||||
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
|
||||
mbedtls_ecjpake_write_round_one( &ctx, NULL, len, &olen,
|
||||
mbedtls_test_rnd_std_rand, NULL ) );
|
||||
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
|
||||
mbedtls_ecjpake_write_round_one( &ctx, buf, len, NULL,
|
||||
mbedtls_test_rnd_std_rand, NULL ) );
|
||||
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
|
||||
mbedtls_ecjpake_write_round_one( &ctx, buf, len, &olen, NULL, NULL ) );
|
||||
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
|
||||
mbedtls_ecjpake_write_round_two( NULL, buf, len, &olen,
|
||||
mbedtls_test_rnd_std_rand, NULL ) );
|
||||
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
|
||||
mbedtls_ecjpake_write_round_two( &ctx, NULL, len, &olen,
|
||||
mbedtls_test_rnd_std_rand, NULL ) );
|
||||
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
|
||||
mbedtls_ecjpake_write_round_two( &ctx, buf, len, NULL,
|
||||
mbedtls_test_rnd_std_rand, NULL ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
|
||||
mbedtls_ecjpake_write_round_two( &ctx, buf, len, &olen, NULL, NULL ) );
|
||||
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
|
||||
mbedtls_ecjpake_read_round_one( NULL,
|
||||
buf, len ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
|
||||
mbedtls_ecjpake_read_round_one( &ctx,
|
||||
NULL, len ) );
|
||||
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
|
||||
mbedtls_ecjpake_read_round_two( NULL,
|
||||
buf, len ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
|
||||
mbedtls_ecjpake_read_round_two( &ctx,
|
||||
NULL, len ) );
|
||||
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
|
||||
mbedtls_ecjpake_derive_secret( NULL, buf, len, &olen,
|
||||
mbedtls_test_rnd_std_rand, NULL ) );
|
||||
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
|
||||
mbedtls_ecjpake_derive_secret( &ctx, NULL, len, &olen,
|
||||
mbedtls_test_rnd_std_rand, NULL ) );
|
||||
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
|
||||
mbedtls_ecjpake_derive_secret( &ctx, buf, len, NULL,
|
||||
mbedtls_test_rnd_std_rand, NULL ) );
|
||||
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
|
||||
mbedtls_ecjpake_derive_secret( &ctx, buf, len, &olen, NULL, NULL ) );
|
||||
|
||||
exit:
|
||||
return;
|
||||
}
|
||||
/* END_CASE */
|
||||
|
||||
/* BEGIN_CASE depends_on:MBEDTLS_SELF_TEST */
|
||||
void ecjpake_selftest( )
|
||||
{
|
||||
|
||||
@@ -1,9 +1,6 @@
|
||||
ECP valid params
|
||||
ecp_valid_param:
|
||||
|
||||
ECP invalid params
|
||||
ecp_invalid_param:
|
||||
|
||||
ECP curve info #1
|
||||
depends_on:MBEDTLS_ECP_DP_BP512R1_ENABLED
|
||||
mbedtls_ecp_curve_info:MBEDTLS_ECP_DP_BP512R1:28:512:"brainpoolP512r1"
|
||||
|
||||
@@ -38,337 +38,6 @@ exit:
|
||||
}
|
||||
/* END_CASE */
|
||||
|
||||
/* BEGIN_CASE depends_on:MBEDTLS_CHECK_PARAMS:!MBEDTLS_PARAM_FAILED_ALT */
|
||||
void ecp_invalid_param( )
|
||||
{
|
||||
mbedtls_ecp_group grp;
|
||||
mbedtls_ecp_keypair kp;
|
||||
mbedtls_ecp_point P;
|
||||
mbedtls_mpi m;
|
||||
const char *x = "deadbeef";
|
||||
int valid_fmt = MBEDTLS_ECP_PF_UNCOMPRESSED;
|
||||
int invalid_fmt = 42;
|
||||
size_t olen;
|
||||
unsigned char buf[42] = { 0 };
|
||||
const unsigned char *null_buf = NULL;
|
||||
mbedtls_ecp_group_id valid_group = MBEDTLS_ECP_DP_SECP192R1;
|
||||
#if defined(MBEDTLS_ECP_RESTARTABLE)
|
||||
mbedtls_ecp_restart_ctx restart_ctx;
|
||||
#endif /* MBEDTLS_ECP_RESTARTABLE */
|
||||
|
||||
TEST_INVALID_PARAM( mbedtls_ecp_point_init( NULL ) );
|
||||
TEST_INVALID_PARAM( mbedtls_ecp_keypair_init( NULL ) );
|
||||
TEST_INVALID_PARAM( mbedtls_ecp_group_init( NULL ) );
|
||||
|
||||
#if defined(MBEDTLS_ECP_RESTARTABLE)
|
||||
TEST_INVALID_PARAM( mbedtls_ecp_restart_init( NULL ) );
|
||||
TEST_INVALID_PARAM( mbedtls_ecp_check_budget( NULL, &restart_ctx, 42 ) );
|
||||
#endif /* MBEDTLS_ECP_RESTARTABLE */
|
||||
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
|
||||
mbedtls_ecp_copy( NULL, &P ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
|
||||
mbedtls_ecp_copy( &P, NULL ) );
|
||||
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
|
||||
mbedtls_ecp_group_copy( NULL, &grp ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
|
||||
mbedtls_ecp_group_copy( &grp, NULL ) );
|
||||
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
|
||||
mbedtls_ecp_gen_privkey( NULL,
|
||||
&m,
|
||||
mbedtls_test_rnd_std_rand,
|
||||
NULL ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
|
||||
mbedtls_ecp_gen_privkey( &grp,
|
||||
NULL,
|
||||
mbedtls_test_rnd_std_rand,
|
||||
NULL ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
|
||||
mbedtls_ecp_gen_privkey( &grp,
|
||||
&m,
|
||||
NULL,
|
||||
NULL ) );
|
||||
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
|
||||
mbedtls_ecp_set_zero( NULL ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
|
||||
mbedtls_ecp_is_zero( NULL ) );
|
||||
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
|
||||
mbedtls_ecp_point_cmp( NULL, &P ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
|
||||
mbedtls_ecp_point_cmp( &P, NULL ) );
|
||||
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
|
||||
mbedtls_ecp_point_read_string( NULL, 2,
|
||||
x, x ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
|
||||
mbedtls_ecp_point_read_string( &P, 2,
|
||||
NULL, x ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
|
||||
mbedtls_ecp_point_read_string( &P, 2,
|
||||
x, NULL ) );
|
||||
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
|
||||
mbedtls_ecp_point_write_binary( NULL, &P,
|
||||
valid_fmt,
|
||||
&olen,
|
||||
buf, sizeof( buf ) ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
|
||||
mbedtls_ecp_point_write_binary( &grp, NULL,
|
||||
valid_fmt,
|
||||
&olen,
|
||||
buf, sizeof( buf ) ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
|
||||
mbedtls_ecp_point_write_binary( &grp, &P,
|
||||
invalid_fmt,
|
||||
&olen,
|
||||
buf, sizeof( buf ) ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
|
||||
mbedtls_ecp_point_write_binary( &grp, &P,
|
||||
valid_fmt,
|
||||
NULL,
|
||||
buf, sizeof( buf ) ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
|
||||
mbedtls_ecp_point_write_binary( &grp, &P,
|
||||
valid_fmt,
|
||||
&olen,
|
||||
NULL, sizeof( buf ) ) );
|
||||
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
|
||||
mbedtls_ecp_point_read_binary( NULL, &P, buf,
|
||||
sizeof( buf ) ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
|
||||
mbedtls_ecp_point_read_binary( &grp, NULL, buf,
|
||||
sizeof( buf ) ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
|
||||
mbedtls_ecp_point_read_binary( &grp, &P, NULL,
|
||||
sizeof( buf ) ) );
|
||||
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
|
||||
mbedtls_ecp_tls_read_point( NULL, &P,
|
||||
(const unsigned char **) &buf,
|
||||
sizeof( buf ) ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
|
||||
mbedtls_ecp_tls_read_point( &grp, NULL,
|
||||
(const unsigned char **) &buf,
|
||||
sizeof( buf ) ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
|
||||
mbedtls_ecp_tls_read_point( &grp, &P, &null_buf,
|
||||
sizeof( buf ) ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
|
||||
mbedtls_ecp_tls_read_point( &grp, &P, NULL,
|
||||
sizeof( buf ) ) );
|
||||
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
|
||||
mbedtls_ecp_tls_write_point( NULL, &P,
|
||||
valid_fmt,
|
||||
&olen,
|
||||
buf,
|
||||
sizeof( buf ) ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
|
||||
mbedtls_ecp_tls_write_point( &grp, NULL,
|
||||
valid_fmt,
|
||||
&olen,
|
||||
buf,
|
||||
sizeof( buf ) ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
|
||||
mbedtls_ecp_tls_write_point( &grp, &P,
|
||||
invalid_fmt,
|
||||
&olen,
|
||||
buf,
|
||||
sizeof( buf ) ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
|
||||
mbedtls_ecp_tls_write_point( &grp, &P,
|
||||
valid_fmt,
|
||||
NULL,
|
||||
buf,
|
||||
sizeof( buf ) ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
|
||||
mbedtls_ecp_tls_write_point( &grp, &P,
|
||||
valid_fmt,
|
||||
&olen,
|
||||
NULL,
|
||||
sizeof( buf ) ) );
|
||||
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
|
||||
mbedtls_ecp_group_load( NULL, valid_group ) );
|
||||
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
|
||||
mbedtls_ecp_tls_read_group( NULL,
|
||||
(const unsigned char **) &buf,
|
||||
sizeof( buf ) ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
|
||||
mbedtls_ecp_tls_read_group( &grp, NULL,
|
||||
sizeof( buf ) ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
|
||||
mbedtls_ecp_tls_read_group( &grp, &null_buf,
|
||||
sizeof( buf ) ) );
|
||||
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
|
||||
mbedtls_ecp_tls_read_group_id( NULL,
|
||||
(const unsigned char **) &buf,
|
||||
sizeof( buf ) ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
|
||||
mbedtls_ecp_tls_read_group_id( &valid_group, NULL,
|
||||
sizeof( buf ) ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
|
||||
mbedtls_ecp_tls_read_group_id( &valid_group,
|
||||
&null_buf,
|
||||
sizeof( buf ) ) );
|
||||
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
|
||||
mbedtls_ecp_tls_write_group( NULL, &olen,
|
||||
buf, sizeof( buf ) ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
|
||||
mbedtls_ecp_tls_write_group( &grp, NULL,
|
||||
buf, sizeof( buf ) ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
|
||||
mbedtls_ecp_tls_write_group( &grp, &olen,
|
||||
NULL, sizeof( buf ) ) );
|
||||
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
|
||||
mbedtls_ecp_mul( NULL, &P, &m, &P,
|
||||
mbedtls_test_rnd_std_rand,
|
||||
NULL ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
|
||||
mbedtls_ecp_mul( &grp, NULL, &m, &P,
|
||||
mbedtls_test_rnd_std_rand,
|
||||
NULL ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
|
||||
mbedtls_ecp_mul( &grp, &P, NULL, &P,
|
||||
mbedtls_test_rnd_std_rand,
|
||||
NULL ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
|
||||
mbedtls_ecp_mul( &grp, &P, &m, NULL,
|
||||
mbedtls_test_rnd_std_rand,
|
||||
NULL ) );
|
||||
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
|
||||
mbedtls_ecp_mul_restartable( NULL, &P, &m, &P,
|
||||
mbedtls_test_rnd_std_rand,
|
||||
NULL , NULL ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
|
||||
mbedtls_ecp_mul_restartable( &grp, NULL, &m, &P,
|
||||
mbedtls_test_rnd_std_rand,
|
||||
NULL , NULL ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
|
||||
mbedtls_ecp_mul_restartable( &grp, &P, NULL, &P,
|
||||
mbedtls_test_rnd_std_rand,
|
||||
NULL , NULL ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
|
||||
mbedtls_ecp_mul_restartable( &grp, &P, &m, NULL,
|
||||
mbedtls_test_rnd_std_rand,
|
||||
NULL , NULL ) );
|
||||
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
|
||||
mbedtls_ecp_muladd( NULL, &P, &m, &P,
|
||||
&m, &P ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
|
||||
mbedtls_ecp_muladd( &grp, NULL, &m, &P,
|
||||
&m, &P ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
|
||||
mbedtls_ecp_muladd( &grp, &P, NULL, &P,
|
||||
&m, &P ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
|
||||
mbedtls_ecp_muladd( &grp, &P, &m, NULL,
|
||||
&m, &P ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
|
||||
mbedtls_ecp_muladd( &grp, &P, &m, &P,
|
||||
NULL, &P ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
|
||||
mbedtls_ecp_muladd( &grp, &P, &m, &P,
|
||||
&m, NULL ) );
|
||||
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
|
||||
mbedtls_ecp_muladd_restartable( NULL, &P, &m, &P,
|
||||
&m, &P, NULL ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
|
||||
mbedtls_ecp_muladd_restartable( &grp, NULL, &m, &P,
|
||||
&m, &P, NULL ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
|
||||
mbedtls_ecp_muladd_restartable( &grp, &P, NULL, &P,
|
||||
&m, &P, NULL ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
|
||||
mbedtls_ecp_muladd_restartable( &grp, &P, &m, NULL,
|
||||
&m, &P, NULL ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
|
||||
mbedtls_ecp_muladd_restartable( &grp, &P, &m, &P,
|
||||
NULL, &P, NULL ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
|
||||
mbedtls_ecp_muladd_restartable( &grp, &P, &m, &P,
|
||||
&m, NULL, NULL ) );
|
||||
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
|
||||
mbedtls_ecp_check_pubkey( NULL, &P ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
|
||||
mbedtls_ecp_check_pubkey( &grp, NULL ) );
|
||||
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
|
||||
mbedtls_ecp_check_pub_priv( NULL, &kp ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
|
||||
mbedtls_ecp_check_pub_priv( &kp, NULL ) );
|
||||
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
|
||||
mbedtls_ecp_check_privkey( NULL, &m ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
|
||||
mbedtls_ecp_check_privkey( &grp, NULL ) );
|
||||
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
|
||||
mbedtls_ecp_gen_keypair_base( NULL, &P, &m, &P,
|
||||
mbedtls_test_rnd_std_rand, NULL ) );
|
||||
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
|
||||
mbedtls_ecp_gen_keypair_base( &grp, NULL, &m, &P,
|
||||
mbedtls_test_rnd_std_rand, NULL ) );
|
||||
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
|
||||
mbedtls_ecp_gen_keypair_base( &grp, &P, NULL, &P,
|
||||
mbedtls_test_rnd_std_rand, NULL ) );
|
||||
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
|
||||
mbedtls_ecp_gen_keypair_base( &grp, &P, &m, NULL,
|
||||
mbedtls_test_rnd_std_rand, NULL ) );
|
||||
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
|
||||
mbedtls_ecp_gen_keypair_base( &grp, &P, &m, &P, NULL, NULL ) );
|
||||
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
|
||||
mbedtls_ecp_gen_keypair( NULL,
|
||||
&m, &P,
|
||||
mbedtls_test_rnd_std_rand,
|
||||
NULL ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
|
||||
mbedtls_ecp_gen_keypair( &grp,
|
||||
NULL, &P,
|
||||
mbedtls_test_rnd_std_rand,
|
||||
NULL ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
|
||||
mbedtls_ecp_gen_keypair( &grp,
|
||||
&m, NULL,
|
||||
mbedtls_test_rnd_std_rand,
|
||||
NULL ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
|
||||
mbedtls_ecp_gen_keypair( &grp,
|
||||
&m, &P,
|
||||
NULL,
|
||||
NULL ) );
|
||||
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
|
||||
mbedtls_ecp_gen_key( valid_group, NULL,
|
||||
mbedtls_test_rnd_std_rand,
|
||||
NULL ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
|
||||
mbedtls_ecp_gen_key( valid_group, &kp,
|
||||
NULL, NULL ) );
|
||||
|
||||
exit:
|
||||
return;
|
||||
}
|
||||
/* END_CASE */
|
||||
|
||||
/* BEGIN_CASE */
|
||||
void mbedtls_ecp_curve_info( int id, int tls_id, int size, char * name )
|
||||
{
|
||||
|
||||
@@ -107,166 +107,6 @@ exit:
|
||||
}
|
||||
/* END_CASE */
|
||||
|
||||
/* BEGIN_CASE depends_on:MBEDTLS_CHECK_PARAMS:!MBEDTLS_PARAM_FAILED_ALT */
|
||||
void gcm_invalid_param( )
|
||||
{
|
||||
mbedtls_gcm_context ctx;
|
||||
unsigned char valid_buffer[] = { 0x01, 0x02, 0x03, 0x04, 0x05, 0x06 };
|
||||
mbedtls_cipher_id_t valid_cipher = MBEDTLS_CIPHER_ID_AES;
|
||||
int valid_mode = MBEDTLS_GCM_ENCRYPT;
|
||||
int valid_len = sizeof(valid_buffer);
|
||||
int valid_bitlen = 128, invalid_bitlen = 1;
|
||||
|
||||
mbedtls_gcm_init( &ctx );
|
||||
|
||||
/* mbedtls_gcm_init() */
|
||||
TEST_INVALID_PARAM( mbedtls_gcm_init( NULL ) );
|
||||
|
||||
/* mbedtls_gcm_setkey */
|
||||
TEST_INVALID_PARAM_RET(
|
||||
MBEDTLS_ERR_GCM_BAD_INPUT,
|
||||
mbedtls_gcm_setkey( NULL, valid_cipher, valid_buffer, valid_bitlen ) );
|
||||
TEST_INVALID_PARAM_RET(
|
||||
MBEDTLS_ERR_GCM_BAD_INPUT,
|
||||
mbedtls_gcm_setkey( &ctx, valid_cipher, NULL, valid_bitlen ) );
|
||||
TEST_INVALID_PARAM_RET(
|
||||
MBEDTLS_ERR_GCM_BAD_INPUT,
|
||||
mbedtls_gcm_setkey( &ctx, valid_cipher, valid_buffer, invalid_bitlen ) );
|
||||
|
||||
/* mbedtls_gcm_crypt_and_tag() */
|
||||
TEST_INVALID_PARAM_RET(
|
||||
MBEDTLS_ERR_GCM_BAD_INPUT,
|
||||
mbedtls_gcm_crypt_and_tag( NULL, valid_mode, valid_len,
|
||||
valid_buffer, valid_len,
|
||||
valid_buffer, valid_len,
|
||||
valid_buffer, valid_buffer,
|
||||
valid_len, valid_buffer ) );
|
||||
TEST_INVALID_PARAM_RET(
|
||||
MBEDTLS_ERR_GCM_BAD_INPUT,
|
||||
mbedtls_gcm_crypt_and_tag( &ctx, valid_mode, valid_len,
|
||||
NULL, valid_len,
|
||||
valid_buffer, valid_len,
|
||||
valid_buffer, valid_buffer,
|
||||
valid_len, valid_buffer ) );
|
||||
TEST_INVALID_PARAM_RET(
|
||||
MBEDTLS_ERR_GCM_BAD_INPUT,
|
||||
mbedtls_gcm_crypt_and_tag( &ctx, valid_mode, valid_len,
|
||||
valid_buffer, valid_len,
|
||||
NULL, valid_len,
|
||||
valid_buffer, valid_buffer,
|
||||
valid_len, valid_buffer ) );
|
||||
TEST_INVALID_PARAM_RET(
|
||||
MBEDTLS_ERR_GCM_BAD_INPUT,
|
||||
mbedtls_gcm_crypt_and_tag( &ctx, valid_mode, valid_len,
|
||||
valid_buffer, valid_len,
|
||||
valid_buffer, valid_len,
|
||||
NULL, valid_buffer,
|
||||
valid_len, valid_buffer ) );
|
||||
TEST_INVALID_PARAM_RET(
|
||||
MBEDTLS_ERR_GCM_BAD_INPUT,
|
||||
mbedtls_gcm_crypt_and_tag( &ctx, valid_mode, valid_len,
|
||||
valid_buffer, valid_len,
|
||||
valid_buffer, valid_len,
|
||||
valid_buffer, NULL,
|
||||
valid_len, valid_buffer ) );
|
||||
TEST_INVALID_PARAM_RET(
|
||||
MBEDTLS_ERR_GCM_BAD_INPUT,
|
||||
mbedtls_gcm_crypt_and_tag( &ctx, valid_mode, valid_len,
|
||||
valid_buffer, valid_len,
|
||||
valid_buffer, valid_len,
|
||||
valid_buffer, valid_buffer,
|
||||
valid_len, NULL ) );
|
||||
|
||||
/* mbedtls_gcm_auth_decrypt() */
|
||||
TEST_INVALID_PARAM_RET(
|
||||
MBEDTLS_ERR_GCM_BAD_INPUT,
|
||||
mbedtls_gcm_auth_decrypt( NULL, valid_len,
|
||||
valid_buffer, valid_len,
|
||||
valid_buffer, valid_len,
|
||||
valid_buffer, valid_len,
|
||||
valid_buffer, valid_buffer) );
|
||||
TEST_INVALID_PARAM_RET(
|
||||
MBEDTLS_ERR_GCM_BAD_INPUT,
|
||||
mbedtls_gcm_auth_decrypt( &ctx, valid_len,
|
||||
NULL, valid_len,
|
||||
valid_buffer, valid_len,
|
||||
valid_buffer, valid_len,
|
||||
valid_buffer, valid_buffer) );
|
||||
TEST_INVALID_PARAM_RET(
|
||||
MBEDTLS_ERR_GCM_BAD_INPUT,
|
||||
mbedtls_gcm_auth_decrypt( &ctx, valid_len,
|
||||
valid_buffer, valid_len,
|
||||
NULL, valid_len,
|
||||
valid_buffer, valid_len,
|
||||
valid_buffer, valid_buffer) );
|
||||
TEST_INVALID_PARAM_RET(
|
||||
MBEDTLS_ERR_GCM_BAD_INPUT,
|
||||
mbedtls_gcm_auth_decrypt( &ctx, valid_len,
|
||||
valid_buffer, valid_len,
|
||||
valid_buffer, valid_len,
|
||||
NULL, valid_len,
|
||||
valid_buffer, valid_buffer) );
|
||||
TEST_INVALID_PARAM_RET(
|
||||
MBEDTLS_ERR_GCM_BAD_INPUT,
|
||||
mbedtls_gcm_auth_decrypt( &ctx, valid_len,
|
||||
valid_buffer, valid_len,
|
||||
valid_buffer, valid_len,
|
||||
valid_buffer, valid_len,
|
||||
NULL, valid_buffer) );
|
||||
TEST_INVALID_PARAM_RET(
|
||||
MBEDTLS_ERR_GCM_BAD_INPUT,
|
||||
mbedtls_gcm_auth_decrypt( &ctx, valid_len,
|
||||
valid_buffer, valid_len,
|
||||
valid_buffer, valid_len,
|
||||
valid_buffer, valid_len,
|
||||
valid_buffer, NULL) );
|
||||
|
||||
/* mbedtls_gcm_starts() */
|
||||
TEST_INVALID_PARAM_RET(
|
||||
MBEDTLS_ERR_GCM_BAD_INPUT,
|
||||
mbedtls_gcm_starts( NULL, valid_mode,
|
||||
valid_buffer, valid_len,
|
||||
valid_buffer, valid_len ) );
|
||||
|
||||
TEST_INVALID_PARAM_RET(
|
||||
MBEDTLS_ERR_GCM_BAD_INPUT,
|
||||
mbedtls_gcm_starts( &ctx, valid_mode,
|
||||
NULL, valid_len,
|
||||
valid_buffer, valid_len ) );
|
||||
|
||||
TEST_INVALID_PARAM_RET(
|
||||
MBEDTLS_ERR_GCM_BAD_INPUT,
|
||||
mbedtls_gcm_starts( &ctx, valid_mode,
|
||||
valid_buffer, valid_len,
|
||||
NULL, valid_len ) );
|
||||
|
||||
/* mbedtls_gcm_update() */
|
||||
TEST_INVALID_PARAM_RET(
|
||||
MBEDTLS_ERR_GCM_BAD_INPUT,
|
||||
mbedtls_gcm_update( NULL, valid_len,
|
||||
valid_buffer, valid_buffer ) );
|
||||
TEST_INVALID_PARAM_RET(
|
||||
MBEDTLS_ERR_GCM_BAD_INPUT,
|
||||
mbedtls_gcm_update( &ctx, valid_len,
|
||||
NULL, valid_buffer ) );
|
||||
TEST_INVALID_PARAM_RET(
|
||||
MBEDTLS_ERR_GCM_BAD_INPUT,
|
||||
mbedtls_gcm_update( &ctx, valid_len,
|
||||
valid_buffer, NULL ) );
|
||||
|
||||
/* mbedtls_gcm_finish() */
|
||||
TEST_INVALID_PARAM_RET(
|
||||
MBEDTLS_ERR_GCM_BAD_INPUT,
|
||||
mbedtls_gcm_finish( NULL, valid_buffer, valid_len ) );
|
||||
TEST_INVALID_PARAM_RET(
|
||||
MBEDTLS_ERR_GCM_BAD_INPUT,
|
||||
mbedtls_gcm_finish( &ctx, NULL, valid_len ) );
|
||||
|
||||
exit:
|
||||
mbedtls_gcm_free( &ctx );
|
||||
}
|
||||
/* END_CASE */
|
||||
|
||||
/* BEGIN_CASE */
|
||||
void gcm_valid_param( )
|
||||
{
|
||||
|
||||
@@ -1,5 +1,2 @@
|
||||
GCM - Invalid parameters
|
||||
gcm_invalid_param:
|
||||
|
||||
GCM - Valid parameters
|
||||
gcm_valid_param:
|
||||
|
||||
@@ -1,9 +1,6 @@
|
||||
MPI - Valid parameters
|
||||
mpi_valid_param:
|
||||
|
||||
MPI - Invalid parameters
|
||||
mpi_invalid_param:
|
||||
|
||||
Arguments with no value
|
||||
mpi_null:
|
||||
|
||||
|
||||
@@ -78,214 +78,6 @@ void mpi_valid_param( )
|
||||
}
|
||||
/* END_CASE */
|
||||
|
||||
/* BEGIN_CASE depends_on:MBEDTLS_CHECK_PARAMS:!MBEDTLS_PARAM_FAILED_ALT */
|
||||
void mpi_invalid_param( )
|
||||
{
|
||||
mbedtls_mpi X;
|
||||
const char *s_in = "00101000101010";
|
||||
char s_out[16] = { 0 };
|
||||
unsigned char u_out[16] = { 0 };
|
||||
unsigned char u_in[16] = { 0 };
|
||||
size_t olen;
|
||||
mbedtls_mpi_uint mpi_uint;
|
||||
|
||||
TEST_INVALID_PARAM( mbedtls_mpi_init( NULL ) );
|
||||
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_MPI_BAD_INPUT_DATA,
|
||||
mbedtls_mpi_grow( NULL, 42 ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_MPI_BAD_INPUT_DATA,
|
||||
mbedtls_mpi_copy( NULL, &X ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_MPI_BAD_INPUT_DATA,
|
||||
mbedtls_mpi_copy( &X, NULL ) );
|
||||
|
||||
TEST_INVALID_PARAM( mbedtls_mpi_swap( NULL, &X ) );
|
||||
TEST_INVALID_PARAM( mbedtls_mpi_swap( &X, NULL ) );
|
||||
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_MPI_BAD_INPUT_DATA,
|
||||
mbedtls_mpi_safe_cond_assign( NULL, &X, 0 ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_MPI_BAD_INPUT_DATA,
|
||||
mbedtls_mpi_safe_cond_assign( &X, NULL, 0 ) );
|
||||
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_MPI_BAD_INPUT_DATA,
|
||||
mbedtls_mpi_safe_cond_swap( NULL, &X, 0 ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_MPI_BAD_INPUT_DATA,
|
||||
mbedtls_mpi_safe_cond_swap( &X, NULL, 0 ) );
|
||||
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_MPI_BAD_INPUT_DATA,
|
||||
mbedtls_mpi_lset( NULL, 42 ) );
|
||||
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_MPI_BAD_INPUT_DATA,
|
||||
mbedtls_mpi_get_bit( NULL, 42 ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_MPI_BAD_INPUT_DATA,
|
||||
mbedtls_mpi_set_bit( NULL, 42, 0 ) );
|
||||
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_MPI_BAD_INPUT_DATA,
|
||||
mbedtls_mpi_read_string( NULL, 2, s_in ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_MPI_BAD_INPUT_DATA,
|
||||
mbedtls_mpi_read_string( &X, 2, NULL ) );
|
||||
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_MPI_BAD_INPUT_DATA,
|
||||
mbedtls_mpi_write_string( NULL, 2,
|
||||
s_out, sizeof( s_out ),
|
||||
&olen ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_MPI_BAD_INPUT_DATA,
|
||||
mbedtls_mpi_write_string( &X, 2,
|
||||
NULL, sizeof( s_out ),
|
||||
&olen ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_MPI_BAD_INPUT_DATA,
|
||||
mbedtls_mpi_write_string( &X, 2,
|
||||
s_out, sizeof( s_out ),
|
||||
NULL ) );
|
||||
|
||||
#if defined(MBEDTLS_FS_IO)
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_MPI_BAD_INPUT_DATA,
|
||||
mbedtls_mpi_read_file( NULL, 2, stdin ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_MPI_BAD_INPUT_DATA,
|
||||
mbedtls_mpi_read_file( &X, 2, NULL ) );
|
||||
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_MPI_BAD_INPUT_DATA,
|
||||
mbedtls_mpi_write_file( "", NULL, 2, NULL ) );
|
||||
#endif /* MBEDTLS_FS_IO */
|
||||
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_MPI_BAD_INPUT_DATA,
|
||||
mbedtls_mpi_read_binary( NULL, u_in,
|
||||
sizeof( u_in ) ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_MPI_BAD_INPUT_DATA,
|
||||
mbedtls_mpi_read_binary( &X, NULL,
|
||||
sizeof( u_in ) ) );
|
||||
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_MPI_BAD_INPUT_DATA,
|
||||
mbedtls_mpi_write_binary( NULL, u_out,
|
||||
sizeof( u_out ) ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_MPI_BAD_INPUT_DATA,
|
||||
mbedtls_mpi_write_binary( &X, NULL,
|
||||
sizeof( u_out ) ) );
|
||||
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_MPI_BAD_INPUT_DATA,
|
||||
mbedtls_mpi_shift_l( NULL, 42 ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_MPI_BAD_INPUT_DATA,
|
||||
mbedtls_mpi_shift_r( NULL, 42 ) );
|
||||
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_MPI_BAD_INPUT_DATA,
|
||||
mbedtls_mpi_cmp_abs( NULL, &X ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_MPI_BAD_INPUT_DATA,
|
||||
mbedtls_mpi_cmp_abs( &X, NULL ) );
|
||||
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_MPI_BAD_INPUT_DATA,
|
||||
mbedtls_mpi_cmp_mpi( NULL, &X ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_MPI_BAD_INPUT_DATA,
|
||||
mbedtls_mpi_cmp_mpi( &X, NULL ) );
|
||||
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_MPI_BAD_INPUT_DATA,
|
||||
mbedtls_mpi_cmp_int( NULL, 42 ) );
|
||||
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_MPI_BAD_INPUT_DATA,
|
||||
mbedtls_mpi_add_abs( NULL, &X, &X ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_MPI_BAD_INPUT_DATA,
|
||||
mbedtls_mpi_add_abs( &X, NULL, &X ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_MPI_BAD_INPUT_DATA,
|
||||
mbedtls_mpi_add_abs( &X, &X, NULL ) );
|
||||
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_MPI_BAD_INPUT_DATA,
|
||||
mbedtls_mpi_sub_abs( NULL, &X, &X ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_MPI_BAD_INPUT_DATA,
|
||||
mbedtls_mpi_sub_abs( &X, NULL, &X ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_MPI_BAD_INPUT_DATA,
|
||||
mbedtls_mpi_sub_abs( &X, &X, NULL ) );
|
||||
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_MPI_BAD_INPUT_DATA,
|
||||
mbedtls_mpi_add_mpi( NULL, &X, &X ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_MPI_BAD_INPUT_DATA,
|
||||
mbedtls_mpi_add_mpi( &X, NULL, &X ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_MPI_BAD_INPUT_DATA,
|
||||
mbedtls_mpi_add_mpi( &X, &X, NULL ) );
|
||||
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_MPI_BAD_INPUT_DATA,
|
||||
mbedtls_mpi_sub_mpi( NULL, &X, &X ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_MPI_BAD_INPUT_DATA,
|
||||
mbedtls_mpi_sub_mpi( &X, NULL, &X ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_MPI_BAD_INPUT_DATA,
|
||||
mbedtls_mpi_sub_mpi( &X, &X, NULL ) );
|
||||
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_MPI_BAD_INPUT_DATA,
|
||||
mbedtls_mpi_add_int( NULL, &X, 42 ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_MPI_BAD_INPUT_DATA,
|
||||
mbedtls_mpi_add_int( &X, NULL, 42 ) );
|
||||
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_MPI_BAD_INPUT_DATA,
|
||||
mbedtls_mpi_sub_int( NULL, &X, 42 ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_MPI_BAD_INPUT_DATA,
|
||||
mbedtls_mpi_sub_int( &X, NULL, 42 ) );
|
||||
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_MPI_BAD_INPUT_DATA,
|
||||
mbedtls_mpi_mul_mpi( NULL, &X, &X ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_MPI_BAD_INPUT_DATA,
|
||||
mbedtls_mpi_mul_mpi( &X, NULL, &X ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_MPI_BAD_INPUT_DATA,
|
||||
mbedtls_mpi_mul_mpi( &X, &X, NULL ) );
|
||||
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_MPI_BAD_INPUT_DATA,
|
||||
mbedtls_mpi_mul_int( NULL, &X, 42 ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_MPI_BAD_INPUT_DATA,
|
||||
mbedtls_mpi_mul_int( &X, NULL, 42 ) );
|
||||
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_MPI_BAD_INPUT_DATA,
|
||||
mbedtls_mpi_div_mpi( &X, &X, NULL, &X ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_MPI_BAD_INPUT_DATA,
|
||||
mbedtls_mpi_div_mpi( &X, &X, &X, NULL ) );
|
||||
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_MPI_BAD_INPUT_DATA,
|
||||
mbedtls_mpi_div_int( &X, &X, NULL, 42 ) );
|
||||
|
||||
TEST_INVALID_PARAM_RET( 0, mbedtls_mpi_lsb( NULL ) );
|
||||
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_MPI_BAD_INPUT_DATA,
|
||||
mbedtls_mpi_mod_mpi( NULL, &X, &X ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_MPI_BAD_INPUT_DATA,
|
||||
mbedtls_mpi_mod_mpi( &X, NULL, &X ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_MPI_BAD_INPUT_DATA,
|
||||
mbedtls_mpi_mod_mpi( &X, &X, NULL ) );
|
||||
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_MPI_BAD_INPUT_DATA,
|
||||
mbedtls_mpi_mod_int( NULL, &X, 42 ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_MPI_BAD_INPUT_DATA,
|
||||
mbedtls_mpi_mod_int( &mpi_uint, NULL, 42 ) );
|
||||
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_MPI_BAD_INPUT_DATA,
|
||||
mbedtls_mpi_exp_mod( NULL, &X, &X, &X, NULL ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_MPI_BAD_INPUT_DATA,
|
||||
mbedtls_mpi_exp_mod( &X, NULL, &X, &X, NULL ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_MPI_BAD_INPUT_DATA,
|
||||
mbedtls_mpi_exp_mod( &X, &X, NULL, &X, NULL ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_MPI_BAD_INPUT_DATA,
|
||||
mbedtls_mpi_exp_mod( &X, &X, &X, NULL, NULL ) );
|
||||
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_MPI_BAD_INPUT_DATA,
|
||||
mbedtls_mpi_fill_random( NULL, 42,
|
||||
mbedtls_test_rnd_std_rand,
|
||||
NULL ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_MPI_BAD_INPUT_DATA,
|
||||
mbedtls_mpi_fill_random( &X, 42, NULL, NULL ) );
|
||||
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_MPI_BAD_INPUT_DATA,
|
||||
mbedtls_mpi_gcd( NULL, &X, &X ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_MPI_BAD_INPUT_DATA,
|
||||
mbedtls_mpi_gcd( &X, NULL, &X ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_MPI_BAD_INPUT_DATA,
|
||||
mbedtls_mpi_gcd( &X, &X, NULL ) );
|
||||
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_MPI_BAD_INPUT_DATA,
|
||||
mbedtls_mpi_inv_mod( NULL, &X, &X ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_MPI_BAD_INPUT_DATA,
|
||||
mbedtls_mpi_inv_mod( &X, NULL, &X ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_MPI_BAD_INPUT_DATA,
|
||||
mbedtls_mpi_inv_mod( &X, &X, NULL ) );
|
||||
|
||||
exit:
|
||||
return;
|
||||
}
|
||||
/* END_CASE */
|
||||
|
||||
/* BEGIN_CASE */
|
||||
void mpi_null( )
|
||||
{
|
||||
|
||||
@@ -1,6 +1,3 @@
|
||||
PK invalid parameters
|
||||
invalid_parameters:
|
||||
|
||||
PK valid parameters
|
||||
valid_parameters:
|
||||
|
||||
|
||||
@@ -323,275 +323,6 @@ exit:
|
||||
}
|
||||
/* END_CASE */
|
||||
|
||||
/* BEGIN_CASE depends_on:MBEDTLS_CHECK_PARAMS:!MBEDTLS_PARAM_FAILED_ALT */
|
||||
void invalid_parameters( )
|
||||
{
|
||||
size_t len;
|
||||
unsigned char *null_buf = NULL;
|
||||
unsigned char buf[1];
|
||||
unsigned char *p = buf;
|
||||
char str[1] = {0};
|
||||
mbedtls_pk_context pk;
|
||||
mbedtls_md_type_t valid_md = MBEDTLS_MD_SHA256;
|
||||
void *options = buf;
|
||||
|
||||
(void) null_buf;
|
||||
(void) p;
|
||||
(void) str;
|
||||
|
||||
mbedtls_pk_init( &pk );
|
||||
|
||||
TEST_INVALID_PARAM( mbedtls_pk_init( NULL ) );
|
||||
|
||||
#if defined(MBEDTLS_ECDSA_C) && defined(MBEDTLS_ECP_RESTARTABLE)
|
||||
TEST_INVALID_PARAM( mbedtls_pk_restart_init( NULL ) );
|
||||
#endif
|
||||
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_PK_BAD_INPUT_DATA,
|
||||
mbedtls_pk_setup( NULL, NULL ) );
|
||||
|
||||
#if defined(MBEDTLS_PK_RSA_ALT_SUPPORT)
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_PK_BAD_INPUT_DATA,
|
||||
mbedtls_pk_setup_rsa_alt( NULL, buf,
|
||||
NULL, NULL, NULL ) );
|
||||
#endif
|
||||
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_PK_BAD_INPUT_DATA,
|
||||
mbedtls_pk_verify_restartable( NULL,
|
||||
MBEDTLS_MD_NONE,
|
||||
buf, sizeof( buf ),
|
||||
buf, sizeof( buf ),
|
||||
NULL ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_PK_BAD_INPUT_DATA,
|
||||
mbedtls_pk_verify_restartable( &pk,
|
||||
MBEDTLS_MD_NONE,
|
||||
NULL, sizeof( buf ),
|
||||
buf, sizeof( buf ),
|
||||
NULL ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_PK_BAD_INPUT_DATA,
|
||||
mbedtls_pk_verify_restartable( &pk,
|
||||
valid_md,
|
||||
NULL, 0,
|
||||
buf, sizeof( buf ),
|
||||
NULL ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_PK_BAD_INPUT_DATA,
|
||||
mbedtls_pk_verify_restartable( &pk,
|
||||
MBEDTLS_MD_NONE,
|
||||
buf, sizeof( buf ),
|
||||
NULL, sizeof( buf ),
|
||||
NULL ) );
|
||||
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_PK_BAD_INPUT_DATA,
|
||||
mbedtls_pk_verify( NULL,
|
||||
MBEDTLS_MD_NONE,
|
||||
buf, sizeof( buf ),
|
||||
buf, sizeof( buf ) ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_PK_BAD_INPUT_DATA,
|
||||
mbedtls_pk_verify( &pk,
|
||||
MBEDTLS_MD_NONE,
|
||||
NULL, sizeof( buf ),
|
||||
buf, sizeof( buf ) ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_PK_BAD_INPUT_DATA,
|
||||
mbedtls_pk_verify( &pk,
|
||||
valid_md,
|
||||
NULL, 0,
|
||||
buf, sizeof( buf ) ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_PK_BAD_INPUT_DATA,
|
||||
mbedtls_pk_verify( &pk,
|
||||
MBEDTLS_MD_NONE,
|
||||
buf, sizeof( buf ),
|
||||
NULL, sizeof( buf ) ) );
|
||||
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_PK_BAD_INPUT_DATA,
|
||||
mbedtls_pk_verify_ext( MBEDTLS_PK_NONE, options,
|
||||
NULL,
|
||||
MBEDTLS_MD_NONE,
|
||||
buf, sizeof( buf ),
|
||||
buf, sizeof( buf ) ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_PK_BAD_INPUT_DATA,
|
||||
mbedtls_pk_verify_ext( MBEDTLS_PK_NONE, options,
|
||||
&pk,
|
||||
MBEDTLS_MD_NONE,
|
||||
NULL, sizeof( buf ),
|
||||
buf, sizeof( buf ) ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_PK_BAD_INPUT_DATA,
|
||||
mbedtls_pk_verify_ext( MBEDTLS_PK_NONE, options,
|
||||
&pk,
|
||||
valid_md,
|
||||
NULL, 0,
|
||||
buf, sizeof( buf ) ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_PK_BAD_INPUT_DATA,
|
||||
mbedtls_pk_verify_ext( MBEDTLS_PK_NONE, options,
|
||||
&pk,
|
||||
MBEDTLS_MD_NONE,
|
||||
buf, sizeof( buf ),
|
||||
NULL, sizeof( buf ) ) );
|
||||
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_PK_BAD_INPUT_DATA,
|
||||
mbedtls_pk_sign_restartable( NULL, MBEDTLS_MD_NONE, buf, sizeof( buf ),
|
||||
buf, &len, mbedtls_test_rnd_std_rand,
|
||||
NULL, NULL ) );
|
||||
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_PK_BAD_INPUT_DATA,
|
||||
mbedtls_pk_sign_restartable( &pk, MBEDTLS_MD_NONE, NULL, sizeof( buf ),
|
||||
buf, &len, mbedtls_test_rnd_std_rand,
|
||||
NULL, NULL ) );
|
||||
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_PK_BAD_INPUT_DATA,
|
||||
mbedtls_pk_sign_restartable( &pk, valid_md, NULL, 0, buf, &len,
|
||||
mbedtls_test_rnd_std_rand, NULL, NULL ) );
|
||||
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_PK_BAD_INPUT_DATA,
|
||||
mbedtls_pk_sign_restartable( &pk, MBEDTLS_MD_NONE, buf, sizeof( buf ),
|
||||
NULL, &len, mbedtls_test_rnd_std_rand,
|
||||
NULL, NULL ) );
|
||||
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_PK_BAD_INPUT_DATA,
|
||||
mbedtls_pk_sign( NULL, MBEDTLS_MD_NONE, buf, sizeof( buf ),
|
||||
buf, &len, mbedtls_test_rnd_std_rand, NULL ) );
|
||||
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_PK_BAD_INPUT_DATA,
|
||||
mbedtls_pk_sign( &pk, MBEDTLS_MD_NONE, NULL, sizeof( buf ),
|
||||
buf, &len, mbedtls_test_rnd_std_rand, NULL ) );
|
||||
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_PK_BAD_INPUT_DATA,
|
||||
mbedtls_pk_sign( &pk, valid_md, NULL, 0, buf, &len,
|
||||
mbedtls_test_rnd_std_rand, NULL ) );
|
||||
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_PK_BAD_INPUT_DATA,
|
||||
mbedtls_pk_sign( &pk, MBEDTLS_MD_NONE, buf, sizeof( buf ), NULL, &len,
|
||||
mbedtls_test_rnd_std_rand, NULL ) );
|
||||
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_PK_BAD_INPUT_DATA,
|
||||
mbedtls_pk_decrypt( NULL, buf, sizeof( buf ), buf, &len, sizeof( buf ),
|
||||
mbedtls_test_rnd_std_rand, NULL ) );
|
||||
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_PK_BAD_INPUT_DATA,
|
||||
mbedtls_pk_decrypt( &pk, NULL, sizeof( buf ), buf, &len, sizeof( buf ),
|
||||
mbedtls_test_rnd_std_rand, NULL ) );
|
||||
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_PK_BAD_INPUT_DATA,
|
||||
mbedtls_pk_decrypt( &pk, buf, sizeof( buf ), NULL, &len, sizeof( buf ),
|
||||
mbedtls_test_rnd_std_rand, NULL ) );
|
||||
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_PK_BAD_INPUT_DATA,
|
||||
mbedtls_pk_decrypt( &pk, buf, sizeof( buf ), buf, NULL, sizeof( buf ),
|
||||
mbedtls_test_rnd_std_rand, NULL ) );
|
||||
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_PK_BAD_INPUT_DATA,
|
||||
mbedtls_pk_encrypt( NULL, buf, sizeof( buf ), buf, &len, sizeof( buf ),
|
||||
mbedtls_test_rnd_std_rand, NULL ) );
|
||||
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_PK_BAD_INPUT_DATA,
|
||||
mbedtls_pk_encrypt( &pk, NULL, sizeof( buf ), buf, &len, sizeof( buf ),
|
||||
mbedtls_test_rnd_std_rand, NULL ) );
|
||||
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_PK_BAD_INPUT_DATA,
|
||||
mbedtls_pk_encrypt( &pk, buf, sizeof( buf ), NULL, &len, sizeof( buf ),
|
||||
mbedtls_test_rnd_std_rand, NULL ) );
|
||||
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_PK_BAD_INPUT_DATA,
|
||||
mbedtls_pk_encrypt( &pk, buf, sizeof( buf ), buf, NULL, sizeof( buf ),
|
||||
mbedtls_test_rnd_std_rand, NULL ) );
|
||||
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_PK_BAD_INPUT_DATA,
|
||||
mbedtls_pk_check_pair( NULL, &pk ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_PK_BAD_INPUT_DATA,
|
||||
mbedtls_pk_check_pair( &pk, NULL ) );
|
||||
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_PK_BAD_INPUT_DATA,
|
||||
mbedtls_pk_debug( NULL, NULL ) );
|
||||
|
||||
#if defined(MBEDTLS_PK_PARSE_C)
|
||||
#if defined(MBEDTLS_FS_IO)
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_PK_BAD_INPUT_DATA,
|
||||
mbedtls_pk_load_file( NULL, &p, &len ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_PK_BAD_INPUT_DATA,
|
||||
mbedtls_pk_load_file( str, NULL, &len ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_PK_BAD_INPUT_DATA,
|
||||
mbedtls_pk_load_file( str, &p, NULL ) );
|
||||
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_PK_BAD_INPUT_DATA,
|
||||
mbedtls_pk_parse_keyfile( NULL, str, NULL ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_PK_BAD_INPUT_DATA,
|
||||
mbedtls_pk_parse_keyfile( &pk, NULL, NULL ) );
|
||||
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_PK_BAD_INPUT_DATA,
|
||||
mbedtls_pk_parse_public_keyfile( NULL, str ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_PK_BAD_INPUT_DATA,
|
||||
mbedtls_pk_parse_public_keyfile( &pk, NULL ) );
|
||||
#endif
|
||||
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_PK_BAD_INPUT_DATA,
|
||||
mbedtls_pk_parse_subpubkey( NULL, buf, &pk ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_PK_BAD_INPUT_DATA,
|
||||
mbedtls_pk_parse_subpubkey( &null_buf, buf, &pk ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_PK_BAD_INPUT_DATA,
|
||||
mbedtls_pk_parse_subpubkey( &p, NULL, &pk ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_PK_BAD_INPUT_DATA,
|
||||
mbedtls_pk_parse_subpubkey( &p, buf, NULL ) );
|
||||
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_PK_BAD_INPUT_DATA,
|
||||
mbedtls_pk_parse_key( NULL,
|
||||
buf, sizeof( buf ),
|
||||
buf, sizeof( buf ) ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_PK_BAD_INPUT_DATA,
|
||||
mbedtls_pk_parse_key( &pk,
|
||||
NULL, sizeof( buf ),
|
||||
buf, sizeof( buf ) ) );
|
||||
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_PK_BAD_INPUT_DATA,
|
||||
mbedtls_pk_parse_public_key( NULL,
|
||||
buf, sizeof( buf ) ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_PK_BAD_INPUT_DATA,
|
||||
mbedtls_pk_parse_public_key( &pk,
|
||||
NULL, sizeof( buf ) ) );
|
||||
#endif /* MBEDTLS_PK_PARSE_C */
|
||||
|
||||
#if defined(MBEDTLS_PK_WRITE_C)
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_PK_BAD_INPUT_DATA,
|
||||
mbedtls_pk_write_pubkey( NULL, p, &pk ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_PK_BAD_INPUT_DATA,
|
||||
mbedtls_pk_write_pubkey( &null_buf, p, &pk ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_PK_BAD_INPUT_DATA,
|
||||
mbedtls_pk_write_pubkey( &p, NULL, &pk ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_PK_BAD_INPUT_DATA,
|
||||
mbedtls_pk_write_pubkey( &p, p, NULL ) );
|
||||
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_PK_BAD_INPUT_DATA,
|
||||
mbedtls_pk_write_pubkey_der( NULL,
|
||||
buf, sizeof( buf ) ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_PK_BAD_INPUT_DATA,
|
||||
mbedtls_pk_write_pubkey_der( &pk,
|
||||
NULL, sizeof( buf ) ) );
|
||||
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_PK_BAD_INPUT_DATA,
|
||||
mbedtls_pk_write_key_der( NULL,
|
||||
buf, sizeof( buf ) ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_PK_BAD_INPUT_DATA,
|
||||
mbedtls_pk_write_key_der( &pk,
|
||||
NULL, sizeof( buf ) ) );
|
||||
|
||||
#if defined(MBEDTLS_PEM_WRITE_C)
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_PK_BAD_INPUT_DATA,
|
||||
mbedtls_pk_write_pubkey_pem( NULL,
|
||||
buf, sizeof( buf ) ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_PK_BAD_INPUT_DATA,
|
||||
mbedtls_pk_write_pubkey_pem( &pk,
|
||||
NULL, sizeof( buf ) ) );
|
||||
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_PK_BAD_INPUT_DATA,
|
||||
mbedtls_pk_write_key_pem( NULL,
|
||||
buf, sizeof( buf ) ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_PK_BAD_INPUT_DATA,
|
||||
mbedtls_pk_write_key_pem( &pk,
|
||||
NULL, sizeof( buf ) ) );
|
||||
#endif /* MBEDTLS_PEM_WRITE_C */
|
||||
|
||||
#endif /* MBEDTLS_PK_WRITE_C */
|
||||
}
|
||||
/* END_CASE */
|
||||
|
||||
/* BEGIN_CASE */
|
||||
void pk_utils( int type, int parameter, int bitlen, int len, char * name )
|
||||
{
|
||||
|
||||
@@ -34,9 +34,6 @@ mbedtls_poly1305:"01000000000000000400000000000000000000000000000000000000000000
|
||||
Poly1305 RFC 7539 Test Vector #11
|
||||
mbedtls_poly1305:"0100000000000000040000000000000000000000000000000000000000000000":"13000000000000000000000000000000":"e33594d7505e43b900000000000000003394d7505e4379cd010000000000000000000000000000000000000000000000"
|
||||
|
||||
Poly1305 Parameter validation
|
||||
poly1305_bad_params:
|
||||
|
||||
Poly1305 Selftest
|
||||
depends_on:MBEDTLS_SELF_TEST
|
||||
poly1305_selftest:
|
||||
|
||||
@@ -79,45 +79,6 @@ void mbedtls_poly1305( data_t *key, data_t *expected_mac, data_t *src_str )
|
||||
}
|
||||
/* END_CASE */
|
||||
|
||||
/* BEGIN_CASE depends_on:MBEDTLS_CHECK_PARAMS:!MBEDTLS_PARAM_FAILED_ALT */
|
||||
void poly1305_bad_params()
|
||||
{
|
||||
unsigned char src[1];
|
||||
unsigned char key[32];
|
||||
unsigned char mac[16];
|
||||
size_t src_len = sizeof( src );
|
||||
mbedtls_poly1305_context ctx;
|
||||
|
||||
TEST_INVALID_PARAM( mbedtls_poly1305_init( NULL ) );
|
||||
TEST_VALID_PARAM( mbedtls_poly1305_free( NULL ) );
|
||||
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_POLY1305_BAD_INPUT_DATA,
|
||||
mbedtls_poly1305_starts( NULL, key ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_POLY1305_BAD_INPUT_DATA,
|
||||
mbedtls_poly1305_starts( &ctx, NULL ) );
|
||||
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_POLY1305_BAD_INPUT_DATA,
|
||||
mbedtls_poly1305_update( NULL, src, 0 ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_POLY1305_BAD_INPUT_DATA,
|
||||
mbedtls_poly1305_update( &ctx, NULL, src_len ) );
|
||||
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_POLY1305_BAD_INPUT_DATA,
|
||||
mbedtls_poly1305_finish( NULL, mac ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_POLY1305_BAD_INPUT_DATA,
|
||||
mbedtls_poly1305_finish( &ctx, NULL ) );
|
||||
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_POLY1305_BAD_INPUT_DATA,
|
||||
mbedtls_poly1305_mac( NULL, src, 0, mac ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_POLY1305_BAD_INPUT_DATA,
|
||||
mbedtls_poly1305_mac( key, NULL, src_len, mac ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_POLY1305_BAD_INPUT_DATA,
|
||||
mbedtls_poly1305_mac( key, src, 0, NULL ) );
|
||||
|
||||
exit:
|
||||
return;
|
||||
}
|
||||
/* END_CASE */
|
||||
|
||||
/* BEGIN_CASE depends_on:MBEDTLS_SELF_TEST */
|
||||
void poly1305_selftest()
|
||||
{
|
||||
|
||||
@@ -1,6 +1,3 @@
|
||||
RSA parameter validation
|
||||
rsa_invalid_param:
|
||||
|
||||
RSA init-free-free
|
||||
rsa_init_free:0
|
||||
|
||||
|
||||
@@ -17,477 +17,6 @@
|
||||
* END_DEPENDENCIES
|
||||
*/
|
||||
|
||||
/* BEGIN_CASE depends_on:MBEDTLS_CHECK_PARAMS:!MBEDTLS_PARAM_FAILED_ALT */
|
||||
void rsa_invalid_param( )
|
||||
{
|
||||
mbedtls_rsa_context ctx;
|
||||
const int valid_padding = MBEDTLS_RSA_PKCS_V21;
|
||||
const int invalid_padding = 42;
|
||||
const int valid_mode = MBEDTLS_RSA_PRIVATE;
|
||||
const int invalid_mode = 42;
|
||||
unsigned char buf[42] = { 0 };
|
||||
size_t olen;
|
||||
|
||||
TEST_INVALID_PARAM( mbedtls_rsa_init( NULL, valid_padding, 0 ) );
|
||||
TEST_INVALID_PARAM( mbedtls_rsa_init( &ctx, invalid_padding, 0 ) );
|
||||
TEST_VALID_PARAM( mbedtls_rsa_free( NULL ) );
|
||||
|
||||
/* No more variants because only the first argument must be non-NULL. */
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_RSA_BAD_INPUT_DATA,
|
||||
mbedtls_rsa_import( NULL, NULL, NULL,
|
||||
NULL, NULL, NULL ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_RSA_BAD_INPUT_DATA,
|
||||
mbedtls_rsa_import_raw( NULL,
|
||||
NULL, 0,
|
||||
NULL, 0,
|
||||
NULL, 0,
|
||||
NULL, 0,
|
||||
NULL, 0 ) );
|
||||
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_RSA_BAD_INPUT_DATA,
|
||||
mbedtls_rsa_complete( NULL ) );
|
||||
|
||||
/* No more variants because only the first argument must be non-NULL. */
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_RSA_BAD_INPUT_DATA,
|
||||
mbedtls_rsa_export( NULL, NULL, NULL,
|
||||
NULL, NULL, NULL ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_RSA_BAD_INPUT_DATA,
|
||||
mbedtls_rsa_export_raw( NULL,
|
||||
NULL, 0,
|
||||
NULL, 0,
|
||||
NULL, 0,
|
||||
NULL, 0,
|
||||
NULL, 0 ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_RSA_BAD_INPUT_DATA,
|
||||
mbedtls_rsa_export_crt( NULL, NULL, NULL, NULL ) );
|
||||
|
||||
TEST_INVALID_PARAM( mbedtls_rsa_set_padding( NULL,
|
||||
valid_padding, 0 ) );
|
||||
TEST_INVALID_PARAM( mbedtls_rsa_set_padding( &ctx,
|
||||
invalid_padding, 0 ) );
|
||||
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_RSA_BAD_INPUT_DATA,
|
||||
mbedtls_rsa_gen_key( NULL,
|
||||
mbedtls_test_rnd_std_rand,
|
||||
NULL, 0, 0 ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_RSA_BAD_INPUT_DATA,
|
||||
mbedtls_rsa_gen_key( &ctx, NULL,
|
||||
NULL, 0, 0 ) );
|
||||
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_RSA_BAD_INPUT_DATA,
|
||||
mbedtls_rsa_check_pubkey( NULL ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_RSA_BAD_INPUT_DATA,
|
||||
mbedtls_rsa_check_privkey( NULL ) );
|
||||
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_RSA_BAD_INPUT_DATA,
|
||||
mbedtls_rsa_check_pub_priv( NULL, &ctx ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_RSA_BAD_INPUT_DATA,
|
||||
mbedtls_rsa_check_pub_priv( &ctx, NULL ) );
|
||||
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_RSA_BAD_INPUT_DATA,
|
||||
mbedtls_rsa_public( NULL, buf, buf ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_RSA_BAD_INPUT_DATA,
|
||||
mbedtls_rsa_public( &ctx, NULL, buf ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_RSA_BAD_INPUT_DATA,
|
||||
mbedtls_rsa_public( &ctx, buf, NULL ) );
|
||||
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_RSA_BAD_INPUT_DATA,
|
||||
mbedtls_rsa_private( NULL, NULL, NULL,
|
||||
buf, buf ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_RSA_BAD_INPUT_DATA,
|
||||
mbedtls_rsa_private( &ctx, NULL, NULL,
|
||||
NULL, buf ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_RSA_BAD_INPUT_DATA,
|
||||
mbedtls_rsa_private( &ctx, NULL, NULL,
|
||||
buf, NULL ) );
|
||||
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_RSA_BAD_INPUT_DATA,
|
||||
mbedtls_rsa_pkcs1_encrypt( NULL, NULL, NULL,
|
||||
valid_mode,
|
||||
sizeof( buf ), buf,
|
||||
buf ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_RSA_BAD_INPUT_DATA,
|
||||
mbedtls_rsa_pkcs1_encrypt( &ctx, NULL, NULL,
|
||||
invalid_mode,
|
||||
sizeof( buf ), buf,
|
||||
buf ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_RSA_BAD_INPUT_DATA,
|
||||
mbedtls_rsa_pkcs1_encrypt( &ctx, NULL, NULL,
|
||||
valid_mode,
|
||||
sizeof( buf ), NULL,
|
||||
buf ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_RSA_BAD_INPUT_DATA,
|
||||
mbedtls_rsa_pkcs1_encrypt( &ctx, NULL, NULL,
|
||||
valid_mode,
|
||||
sizeof( buf ), buf,
|
||||
NULL ) );
|
||||
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_RSA_BAD_INPUT_DATA,
|
||||
mbedtls_rsa_rsaes_pkcs1_v15_encrypt( NULL, NULL,
|
||||
NULL,
|
||||
valid_mode,
|
||||
sizeof( buf ), buf,
|
||||
buf ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_RSA_BAD_INPUT_DATA,
|
||||
mbedtls_rsa_rsaes_pkcs1_v15_encrypt( &ctx, NULL,
|
||||
NULL,
|
||||
invalid_mode,
|
||||
sizeof( buf ), buf,
|
||||
buf ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_RSA_BAD_INPUT_DATA,
|
||||
mbedtls_rsa_rsaes_pkcs1_v15_encrypt( &ctx, NULL,
|
||||
NULL,
|
||||
valid_mode,
|
||||
sizeof( buf ), NULL,
|
||||
buf ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_RSA_BAD_INPUT_DATA,
|
||||
mbedtls_rsa_rsaes_pkcs1_v15_encrypt( &ctx, NULL,
|
||||
NULL,
|
||||
valid_mode,
|
||||
sizeof( buf ), buf,
|
||||
NULL ) );
|
||||
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_RSA_BAD_INPUT_DATA,
|
||||
mbedtls_rsa_rsaes_oaep_encrypt( NULL, NULL, NULL,
|
||||
valid_mode,
|
||||
buf, sizeof( buf ),
|
||||
sizeof( buf ), buf,
|
||||
buf ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_RSA_BAD_INPUT_DATA,
|
||||
mbedtls_rsa_rsaes_oaep_encrypt( &ctx, NULL, NULL,
|
||||
invalid_mode,
|
||||
buf, sizeof( buf ),
|
||||
sizeof( buf ), buf,
|
||||
buf ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_RSA_BAD_INPUT_DATA,
|
||||
mbedtls_rsa_rsaes_oaep_encrypt( &ctx, NULL, NULL,
|
||||
valid_mode,
|
||||
NULL, sizeof( buf ),
|
||||
sizeof( buf ), buf,
|
||||
buf ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_RSA_BAD_INPUT_DATA,
|
||||
mbedtls_rsa_rsaes_oaep_encrypt( &ctx, NULL, NULL,
|
||||
valid_mode,
|
||||
buf, sizeof( buf ),
|
||||
sizeof( buf ), NULL,
|
||||
buf ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_RSA_BAD_INPUT_DATA,
|
||||
mbedtls_rsa_rsaes_oaep_encrypt( &ctx, NULL, NULL,
|
||||
valid_mode,
|
||||
buf, sizeof( buf ),
|
||||
sizeof( buf ), buf,
|
||||
NULL ) );
|
||||
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_RSA_BAD_INPUT_DATA,
|
||||
mbedtls_rsa_pkcs1_decrypt( NULL, NULL, NULL,
|
||||
valid_mode, &olen,
|
||||
buf, buf, 42 ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_RSA_BAD_INPUT_DATA,
|
||||
mbedtls_rsa_pkcs1_decrypt( &ctx, NULL, NULL,
|
||||
invalid_mode, &olen,
|
||||
buf, buf, 42 ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_RSA_BAD_INPUT_DATA,
|
||||
mbedtls_rsa_pkcs1_decrypt( &ctx, NULL, NULL,
|
||||
valid_mode, NULL,
|
||||
buf, buf, 42 ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_RSA_BAD_INPUT_DATA,
|
||||
mbedtls_rsa_pkcs1_decrypt( &ctx, NULL, NULL,
|
||||
valid_mode, &olen,
|
||||
NULL, buf, 42 ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_RSA_BAD_INPUT_DATA,
|
||||
mbedtls_rsa_pkcs1_decrypt( &ctx, NULL, NULL,
|
||||
valid_mode, &olen,
|
||||
buf, NULL, 42 ) );
|
||||
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_RSA_BAD_INPUT_DATA,
|
||||
mbedtls_rsa_rsaes_pkcs1_v15_decrypt( NULL, NULL,
|
||||
NULL,
|
||||
valid_mode, &olen,
|
||||
buf, buf, 42 ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_RSA_BAD_INPUT_DATA,
|
||||
mbedtls_rsa_rsaes_pkcs1_v15_decrypt( &ctx, NULL,
|
||||
NULL,
|
||||
invalid_mode, &olen,
|
||||
buf, buf, 42 ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_RSA_BAD_INPUT_DATA,
|
||||
mbedtls_rsa_rsaes_pkcs1_v15_decrypt( &ctx, NULL,
|
||||
NULL,
|
||||
valid_mode, NULL,
|
||||
buf, buf, 42 ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_RSA_BAD_INPUT_DATA,
|
||||
mbedtls_rsa_rsaes_pkcs1_v15_decrypt( &ctx, NULL,
|
||||
NULL,
|
||||
valid_mode, &olen,
|
||||
NULL, buf, 42 ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_RSA_BAD_INPUT_DATA,
|
||||
mbedtls_rsa_rsaes_pkcs1_v15_decrypt( &ctx, NULL,
|
||||
NULL,
|
||||
valid_mode, &olen,
|
||||
buf, NULL, 42 ) );
|
||||
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_RSA_BAD_INPUT_DATA,
|
||||
mbedtls_rsa_rsaes_oaep_decrypt( NULL, NULL, NULL,
|
||||
valid_mode,
|
||||
buf, sizeof( buf ),
|
||||
&olen,
|
||||
buf, buf, 42 ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_RSA_BAD_INPUT_DATA,
|
||||
mbedtls_rsa_rsaes_oaep_decrypt( &ctx, NULL, NULL,
|
||||
invalid_mode,
|
||||
buf, sizeof( buf ),
|
||||
&olen,
|
||||
buf, buf, 42 ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_RSA_BAD_INPUT_DATA,
|
||||
mbedtls_rsa_rsaes_oaep_decrypt( &ctx, NULL, NULL,
|
||||
valid_mode,
|
||||
NULL, sizeof( buf ),
|
||||
NULL,
|
||||
buf, buf, 42 ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_RSA_BAD_INPUT_DATA,
|
||||
mbedtls_rsa_rsaes_oaep_decrypt( &ctx, NULL, NULL,
|
||||
valid_mode,
|
||||
buf, sizeof( buf ),
|
||||
&olen,
|
||||
NULL, buf, 42 ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_RSA_BAD_INPUT_DATA,
|
||||
mbedtls_rsa_rsaes_oaep_decrypt( &ctx, NULL, NULL,
|
||||
valid_mode,
|
||||
buf, sizeof( buf ),
|
||||
&olen,
|
||||
buf, NULL, 42 ) );
|
||||
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_RSA_BAD_INPUT_DATA,
|
||||
mbedtls_rsa_pkcs1_sign( NULL, NULL, NULL,
|
||||
valid_mode,
|
||||
0, sizeof( buf ), buf,
|
||||
buf ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_RSA_BAD_INPUT_DATA,
|
||||
mbedtls_rsa_pkcs1_sign( &ctx, NULL, NULL,
|
||||
invalid_mode,
|
||||
0, sizeof( buf ), buf,
|
||||
buf ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_RSA_BAD_INPUT_DATA,
|
||||
mbedtls_rsa_pkcs1_sign( &ctx, NULL, NULL,
|
||||
valid_mode,
|
||||
0, sizeof( buf ), NULL,
|
||||
buf ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_RSA_BAD_INPUT_DATA,
|
||||
mbedtls_rsa_pkcs1_sign( &ctx, NULL, NULL,
|
||||
valid_mode,
|
||||
0, sizeof( buf ), buf,
|
||||
NULL ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_RSA_BAD_INPUT_DATA,
|
||||
mbedtls_rsa_pkcs1_sign( &ctx, NULL, NULL,
|
||||
valid_mode,
|
||||
MBEDTLS_MD_SHA1,
|
||||
0, NULL,
|
||||
buf ) );
|
||||
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_RSA_BAD_INPUT_DATA,
|
||||
mbedtls_rsa_rsassa_pkcs1_v15_sign( NULL, NULL, NULL,
|
||||
valid_mode,
|
||||
0, sizeof( buf ), buf,
|
||||
buf ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_RSA_BAD_INPUT_DATA,
|
||||
mbedtls_rsa_rsassa_pkcs1_v15_sign( &ctx, NULL, NULL,
|
||||
invalid_mode,
|
||||
0, sizeof( buf ), buf,
|
||||
buf ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_RSA_BAD_INPUT_DATA,
|
||||
mbedtls_rsa_rsassa_pkcs1_v15_sign( &ctx, NULL, NULL,
|
||||
valid_mode,
|
||||
0, sizeof( buf ), NULL,
|
||||
buf ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_RSA_BAD_INPUT_DATA,
|
||||
mbedtls_rsa_rsassa_pkcs1_v15_sign( &ctx, NULL, NULL,
|
||||
valid_mode,
|
||||
0, sizeof( buf ), buf,
|
||||
NULL ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_RSA_BAD_INPUT_DATA,
|
||||
mbedtls_rsa_rsassa_pkcs1_v15_sign( &ctx, NULL, NULL,
|
||||
valid_mode,
|
||||
MBEDTLS_MD_SHA1,
|
||||
0, NULL,
|
||||
buf ) );
|
||||
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_RSA_BAD_INPUT_DATA,
|
||||
mbedtls_rsa_rsassa_pss_sign( NULL, NULL, NULL,
|
||||
valid_mode,
|
||||
0, sizeof( buf ), buf,
|
||||
buf ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_RSA_BAD_INPUT_DATA,
|
||||
mbedtls_rsa_rsassa_pss_sign( &ctx, NULL, NULL,
|
||||
invalid_mode,
|
||||
0, sizeof( buf ), buf,
|
||||
buf ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_RSA_BAD_INPUT_DATA,
|
||||
mbedtls_rsa_rsassa_pss_sign( &ctx, NULL, NULL,
|
||||
valid_mode,
|
||||
0, sizeof( buf ), NULL,
|
||||
buf ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_RSA_BAD_INPUT_DATA,
|
||||
mbedtls_rsa_rsassa_pss_sign( &ctx, NULL, NULL,
|
||||
valid_mode,
|
||||
0, sizeof( buf ), buf,
|
||||
NULL ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_RSA_BAD_INPUT_DATA,
|
||||
mbedtls_rsa_rsassa_pss_sign( &ctx, NULL, NULL,
|
||||
valid_mode,
|
||||
MBEDTLS_MD_SHA1,
|
||||
0, NULL,
|
||||
buf ) );
|
||||
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_RSA_BAD_INPUT_DATA,
|
||||
mbedtls_rsa_rsassa_pss_sign_ext( NULL, NULL, NULL,
|
||||
0, sizeof( buf ), buf,
|
||||
MBEDTLS_RSA_SALT_LEN_ANY,
|
||||
buf ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_RSA_BAD_INPUT_DATA,
|
||||
mbedtls_rsa_rsassa_pss_sign_ext( &ctx, NULL, NULL,
|
||||
0, sizeof( buf ), NULL,
|
||||
MBEDTLS_RSA_SALT_LEN_ANY,
|
||||
buf ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_RSA_BAD_INPUT_DATA,
|
||||
mbedtls_rsa_rsassa_pss_sign_ext( &ctx, NULL, NULL,
|
||||
0, sizeof( buf ), buf,
|
||||
MBEDTLS_RSA_SALT_LEN_ANY,
|
||||
NULL ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_RSA_BAD_INPUT_DATA,
|
||||
mbedtls_rsa_rsassa_pss_sign_ext( &ctx, NULL, NULL,
|
||||
MBEDTLS_MD_SHA1,
|
||||
0, NULL,
|
||||
MBEDTLS_RSA_SALT_LEN_ANY,
|
||||
buf ) );
|
||||
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_RSA_BAD_INPUT_DATA,
|
||||
mbedtls_rsa_pkcs1_verify( NULL, NULL, NULL,
|
||||
valid_mode,
|
||||
0, sizeof( buf ), buf,
|
||||
buf ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_RSA_BAD_INPUT_DATA,
|
||||
mbedtls_rsa_pkcs1_verify( &ctx, NULL, NULL,
|
||||
invalid_mode,
|
||||
0, sizeof( buf ), buf,
|
||||
buf ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_RSA_BAD_INPUT_DATA,
|
||||
mbedtls_rsa_pkcs1_verify( &ctx, NULL, NULL,
|
||||
valid_mode,
|
||||
0, sizeof( buf ), NULL,
|
||||
buf ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_RSA_BAD_INPUT_DATA,
|
||||
mbedtls_rsa_pkcs1_verify( &ctx, NULL, NULL,
|
||||
valid_mode,
|
||||
0, sizeof( buf ), buf,
|
||||
NULL ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_RSA_BAD_INPUT_DATA,
|
||||
mbedtls_rsa_pkcs1_verify( &ctx, NULL, NULL,
|
||||
valid_mode,
|
||||
MBEDTLS_MD_SHA1, 0, NULL,
|
||||
buf ) );
|
||||
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_RSA_BAD_INPUT_DATA,
|
||||
mbedtls_rsa_rsassa_pkcs1_v15_verify( NULL, NULL,
|
||||
NULL,
|
||||
valid_mode,
|
||||
0, sizeof( buf ), buf,
|
||||
buf ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_RSA_BAD_INPUT_DATA,
|
||||
mbedtls_rsa_rsassa_pkcs1_v15_verify( &ctx, NULL,
|
||||
NULL,
|
||||
invalid_mode,
|
||||
0, sizeof( buf ), buf,
|
||||
buf ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_RSA_BAD_INPUT_DATA,
|
||||
mbedtls_rsa_rsassa_pkcs1_v15_verify( &ctx, NULL,
|
||||
NULL,
|
||||
valid_mode,
|
||||
0, sizeof( buf ),
|
||||
NULL, buf ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_RSA_BAD_INPUT_DATA,
|
||||
mbedtls_rsa_rsassa_pkcs1_v15_verify( &ctx, NULL,
|
||||
NULL,
|
||||
valid_mode,
|
||||
0, sizeof( buf ), buf,
|
||||
NULL ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_RSA_BAD_INPUT_DATA,
|
||||
mbedtls_rsa_rsassa_pkcs1_v15_verify( &ctx, NULL,
|
||||
NULL,
|
||||
valid_mode,
|
||||
MBEDTLS_MD_SHA1,
|
||||
0, NULL,
|
||||
buf ) );
|
||||
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_RSA_BAD_INPUT_DATA,
|
||||
mbedtls_rsa_rsassa_pss_verify( NULL, NULL, NULL,
|
||||
valid_mode,
|
||||
0, sizeof( buf ),
|
||||
buf, buf ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_RSA_BAD_INPUT_DATA,
|
||||
mbedtls_rsa_rsassa_pss_verify( &ctx, NULL, NULL,
|
||||
invalid_mode,
|
||||
0, sizeof( buf ),
|
||||
buf, buf ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_RSA_BAD_INPUT_DATA,
|
||||
mbedtls_rsa_rsassa_pss_verify( &ctx, NULL, NULL,
|
||||
valid_mode,
|
||||
0, sizeof( buf ),
|
||||
NULL, buf ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_RSA_BAD_INPUT_DATA,
|
||||
mbedtls_rsa_rsassa_pss_verify( &ctx, NULL, NULL,
|
||||
valid_mode,
|
||||
0, sizeof( buf ),
|
||||
buf, NULL ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_RSA_BAD_INPUT_DATA,
|
||||
mbedtls_rsa_rsassa_pss_verify( &ctx, NULL, NULL,
|
||||
valid_mode,
|
||||
MBEDTLS_MD_SHA1,
|
||||
0, NULL,
|
||||
buf ) );
|
||||
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_RSA_BAD_INPUT_DATA,
|
||||
mbedtls_rsa_rsassa_pss_verify_ext( NULL, NULL, NULL,
|
||||
valid_mode,
|
||||
0, sizeof( buf ),
|
||||
buf,
|
||||
0, 0,
|
||||
buf ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_RSA_BAD_INPUT_DATA,
|
||||
mbedtls_rsa_rsassa_pss_verify_ext( &ctx, NULL, NULL,
|
||||
invalid_mode,
|
||||
0, sizeof( buf ),
|
||||
buf,
|
||||
0, 0,
|
||||
buf ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_RSA_BAD_INPUT_DATA,
|
||||
mbedtls_rsa_rsassa_pss_verify_ext( &ctx, NULL, NULL,
|
||||
valid_mode,
|
||||
0, sizeof( buf ),
|
||||
NULL, 0, 0,
|
||||
buf ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_RSA_BAD_INPUT_DATA,
|
||||
mbedtls_rsa_rsassa_pss_verify_ext( &ctx, NULL, NULL,
|
||||
valid_mode,
|
||||
0, sizeof( buf ),
|
||||
buf, 0, 0,
|
||||
NULL ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_RSA_BAD_INPUT_DATA,
|
||||
mbedtls_rsa_rsassa_pss_verify_ext( &ctx, NULL, NULL,
|
||||
valid_mode,
|
||||
MBEDTLS_MD_SHA1,
|
||||
0, NULL,
|
||||
0, 0,
|
||||
buf ) );
|
||||
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_RSA_BAD_INPUT_DATA,
|
||||
mbedtls_rsa_copy( NULL, &ctx ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_RSA_BAD_INPUT_DATA,
|
||||
mbedtls_rsa_copy( &ctx, NULL ) );
|
||||
|
||||
exit:
|
||||
return;
|
||||
}
|
||||
/* END_CASE */
|
||||
|
||||
/* BEGIN_CASE */
|
||||
void rsa_init_free( int reinit )
|
||||
{
|
||||
|
||||
@@ -1,9 +1,6 @@
|
||||
SHA-1 - Valid parameters
|
||||
sha1_valid_param:
|
||||
|
||||
SHA-1 - Invalid parameters
|
||||
sha1_invalid_param:
|
||||
|
||||
# Test the operation of SHA-1 and SHA-2
|
||||
SHA-1 Test Vector NIST CAVS #1
|
||||
depends_on:MBEDTLS_SHA1_C
|
||||
@@ -48,9 +45,6 @@ mbedtls_sha1:"8236153781bd2f1b81ffe0def1beb46f5a70191142926651503f1b3bb1016acdb9
|
||||
SHA-256 Valid parameters
|
||||
sha256_valid_param:
|
||||
|
||||
SHA-256 Invalid parameters
|
||||
sha256_invalid_param:
|
||||
|
||||
SHA-224 Test Vector NIST CAVS #1
|
||||
depends_on:MBEDTLS_SHA256_C
|
||||
sha224:"":"d14a028c2a3a2bc9476102bb288234c415a2b01f828ea62ac5b3e42f"
|
||||
@@ -107,9 +101,6 @@ SHA-256 Test Vector NIST CAVS #7
|
||||
depends_on:MBEDTLS_SHA256_C
|
||||
mbedtls_sha256:"8390cf0be07661cc7669aac54ce09a37733a629d45f5d983ef201f9b2d13800e555d9b1097fec3b783d7a50dcb5e2b644b96a1e9463f177cf34906bf388f366db5c2deee04a30e283f764a97c3b377a034fefc22c259214faa99babaff160ab0aaa7e2ccb0ce09c6b32fe08cbc474694375aba703fadbfa31cf685b30a11c57f3cf4edd321e57d3ae6ebb1133c8260e75b9224fa47a2bb205249add2e2e62f817491482ae152322be0900355cdcc8d42a98f82e961a0dc6f537b7b410eff105f59673bfb787bf042aa071f7af68d944d27371c64160fe9382772372516c230c1f45c0d6b6cca7f274b394da9402d3eafdf733994ec58ab22d71829a98399574d4b5908a447a5a681cb0dd50a31145311d92c22a16de1ead66a5499f2dceb4cae694772ce90762ef8336afec653aa9b1a1c4820b221136dfce80dce2ba920d88a530c9410d0a4e0358a3a11052e58dd73b0b179ef8f56fe3b5a2d117a73a0c38a1392b6938e9782e0d86456ee4884e3c39d4d75813f13633bc79baa07c0d2d555afbf207f52b7dca126d015aa2b9873b3eb065e90b9b065a5373fe1fb1b20d594327d19fba56cb81e7b6696605ffa56eba3c27a438697cc21b201fd7e09f18deea1b3ea2f0d1edc02df0e20396a145412cd6b13c32d2e605641c948b714aec30c0649dc44143511f35ab0fd5dd64c34d06fe86f3836dfe9edeb7f08cfc3bd40956826356242191f99f53473f32b0cc0cf9321d6c92a112e8db90b86ee9e87cc32d0343db01e32ce9eb782cb24efbbbeb440fe929e8f2bf8dfb1550a3a2e742e8b455a3e5730e9e6a7a9824d17acc0f72a7f67eae0f0970f8bde46dcdefaed3047cf807e7f00a42e5fd11d40f5e98533d7574425b7d2bc3b3845c443008b58980e768e464e17cc6f6b3939eee52f713963d07d8c4abf02448ef0b889c9671e2f8a436ddeeffcca7176e9bf9d1005ecd377f2fa67c23ed1f137e60bf46018a8bd613d038e883704fc26e798969df35ec7bbc6a4fe46d8910bd82fa3cded265d0a3b6d399e4251e4d8233daa21b5812fded6536198ff13aa5a1cd46a5b9a17a4ddc1d9f85544d1d1cc16f3df858038c8e071a11a7e157a85a6a8dc47e88d75e7009a8b26fdb73f33a2a70f1e0c259f8f9533b9b8f9af9288b7274f21baeec78d396f8bacdcc22471207d9b4efccd3fedc5c5a2214ff5e51c553f35e21ae696fe51e8df733a8e06f50f419e599e9f9e4b37ce643fc810faaa47989771509d69a110ac916261427026369a21263ac4460fb4f708f8ae28599856db7cb6a43ac8e03d64a9609807e76c5f312b9d1863bfa304e8953647648b4f4ab0ed995e":"4109cdbec3240ad74cc6c37f39300f70fede16e21efc77f7865998714aad0b5e"
|
||||
|
||||
SHA-512 Invalid parameters
|
||||
sha512_invalid_param:
|
||||
|
||||
SHA-512 Valid parameters
|
||||
sha512_valid_param:
|
||||
|
||||
|
||||
@@ -11,46 +11,6 @@ void sha1_valid_param( )
|
||||
}
|
||||
/* END_CASE */
|
||||
|
||||
/* BEGIN_CASE depends_on:MBEDTLS_SHA1_C:MBEDTLS_CHECK_PARAMS:!MBEDTLS_PARAM_FAILED_ALT */
|
||||
void sha1_invalid_param( )
|
||||
{
|
||||
mbedtls_sha1_context ctx;
|
||||
unsigned char buf[64] = { 0 };
|
||||
size_t const buflen = sizeof( buf );
|
||||
|
||||
TEST_INVALID_PARAM( mbedtls_sha1_init( NULL ) );
|
||||
|
||||
TEST_INVALID_PARAM( mbedtls_sha1_clone( NULL, &ctx ) );
|
||||
TEST_INVALID_PARAM( mbedtls_sha1_clone( &ctx, NULL ) );
|
||||
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_SHA1_BAD_INPUT_DATA,
|
||||
mbedtls_sha1_starts_ret( NULL ) );
|
||||
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_SHA1_BAD_INPUT_DATA,
|
||||
mbedtls_sha1_update_ret( NULL, buf, buflen ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_SHA1_BAD_INPUT_DATA,
|
||||
mbedtls_sha1_update_ret( &ctx, NULL, buflen ) );
|
||||
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_SHA1_BAD_INPUT_DATA,
|
||||
mbedtls_sha1_finish_ret( NULL, buf ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_SHA1_BAD_INPUT_DATA,
|
||||
mbedtls_sha1_finish_ret( &ctx, NULL ) );
|
||||
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_SHA1_BAD_INPUT_DATA,
|
||||
mbedtls_internal_sha1_process( NULL, buf ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_SHA1_BAD_INPUT_DATA,
|
||||
mbedtls_internal_sha1_process( &ctx, NULL ) );
|
||||
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_SHA1_BAD_INPUT_DATA,
|
||||
mbedtls_sha1_ret( NULL, buflen, buf ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_SHA1_BAD_INPUT_DATA,
|
||||
mbedtls_sha1_ret( buf, buflen, NULL ) );
|
||||
|
||||
exit:
|
||||
return;
|
||||
}
|
||||
/* END_CASE */
|
||||
|
||||
/* BEGIN_CASE depends_on:MBEDTLS_SHA1_C */
|
||||
void mbedtls_sha1( data_t * src_str, data_t * hash )
|
||||
{
|
||||
@@ -72,55 +32,6 @@ void sha256_valid_param( )
|
||||
}
|
||||
/* END_CASE */
|
||||
|
||||
/* BEGIN_CASE depends_on:MBEDTLS_SHA256_C:MBEDTLS_CHECK_PARAMS:!MBEDTLS_PARAM_FAILED_ALT */
|
||||
void sha256_invalid_param( )
|
||||
{
|
||||
mbedtls_sha256_context ctx;
|
||||
unsigned char buf[64] = { 0 };
|
||||
size_t const buflen = sizeof( buf );
|
||||
int valid_type = 0;
|
||||
int invalid_type = 42;
|
||||
|
||||
TEST_INVALID_PARAM( mbedtls_sha256_init( NULL ) );
|
||||
|
||||
TEST_INVALID_PARAM( mbedtls_sha256_clone( NULL, &ctx ) );
|
||||
TEST_INVALID_PARAM( mbedtls_sha256_clone( &ctx, NULL ) );
|
||||
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_SHA256_BAD_INPUT_DATA,
|
||||
mbedtls_sha256_starts_ret( NULL, valid_type ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_SHA256_BAD_INPUT_DATA,
|
||||
mbedtls_sha256_starts_ret( &ctx, invalid_type ) );
|
||||
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_SHA256_BAD_INPUT_DATA,
|
||||
mbedtls_sha256_update_ret( NULL, buf, buflen ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_SHA256_BAD_INPUT_DATA,
|
||||
mbedtls_sha256_update_ret( &ctx, NULL, buflen ) );
|
||||
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_SHA256_BAD_INPUT_DATA,
|
||||
mbedtls_sha256_finish_ret( NULL, buf ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_SHA256_BAD_INPUT_DATA,
|
||||
mbedtls_sha256_finish_ret( &ctx, NULL ) );
|
||||
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_SHA256_BAD_INPUT_DATA,
|
||||
mbedtls_internal_sha256_process( NULL, buf ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_SHA256_BAD_INPUT_DATA,
|
||||
mbedtls_internal_sha256_process( &ctx, NULL ) );
|
||||
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_SHA256_BAD_INPUT_DATA,
|
||||
mbedtls_sha256_ret( NULL, buflen,
|
||||
buf, valid_type ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_SHA256_BAD_INPUT_DATA,
|
||||
mbedtls_sha256_ret( buf, buflen,
|
||||
NULL, valid_type ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_SHA256_BAD_INPUT_DATA,
|
||||
mbedtls_sha256_ret( buf, buflen,
|
||||
buf, invalid_type ) );
|
||||
|
||||
exit:
|
||||
return;
|
||||
}
|
||||
/* END_CASE */
|
||||
|
||||
/* BEGIN_CASE depends_on:MBEDTLS_SHA256_C */
|
||||
void sha224( data_t * src_str, data_t * hash )
|
||||
{
|
||||
@@ -156,55 +67,6 @@ void sha512_valid_param( )
|
||||
}
|
||||
/* END_CASE */
|
||||
|
||||
/* BEGIN_CASE depends_on:MBEDTLS_SHA512_C:MBEDTLS_CHECK_PARAMS:!MBEDTLS_PARAM_FAILED_ALT */
|
||||
void sha512_invalid_param( )
|
||||
{
|
||||
mbedtls_sha512_context ctx;
|
||||
unsigned char buf[64] = { 0 };
|
||||
size_t const buflen = sizeof( buf );
|
||||
int valid_type = 0;
|
||||
int invalid_type = 42;
|
||||
|
||||
TEST_INVALID_PARAM( mbedtls_sha512_init( NULL ) );
|
||||
|
||||
TEST_INVALID_PARAM( mbedtls_sha512_clone( NULL, &ctx ) );
|
||||
TEST_INVALID_PARAM( mbedtls_sha512_clone( &ctx, NULL ) );
|
||||
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_SHA512_BAD_INPUT_DATA,
|
||||
mbedtls_sha512_starts_ret( NULL, valid_type ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_SHA512_BAD_INPUT_DATA,
|
||||
mbedtls_sha512_starts_ret( &ctx, invalid_type ) );
|
||||
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_SHA512_BAD_INPUT_DATA,
|
||||
mbedtls_sha512_update_ret( NULL, buf, buflen ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_SHA512_BAD_INPUT_DATA,
|
||||
mbedtls_sha512_update_ret( &ctx, NULL, buflen ) );
|
||||
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_SHA512_BAD_INPUT_DATA,
|
||||
mbedtls_sha512_finish_ret( NULL, buf ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_SHA512_BAD_INPUT_DATA,
|
||||
mbedtls_sha512_finish_ret( &ctx, NULL ) );
|
||||
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_SHA512_BAD_INPUT_DATA,
|
||||
mbedtls_internal_sha512_process( NULL, buf ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_SHA512_BAD_INPUT_DATA,
|
||||
mbedtls_internal_sha512_process( &ctx, NULL ) );
|
||||
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_SHA512_BAD_INPUT_DATA,
|
||||
mbedtls_sha512_ret( NULL, buflen,
|
||||
buf, valid_type ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_SHA512_BAD_INPUT_DATA,
|
||||
mbedtls_sha512_ret( buf, buflen,
|
||||
NULL, valid_type ) );
|
||||
TEST_INVALID_PARAM_RET( MBEDTLS_ERR_SHA512_BAD_INPUT_DATA,
|
||||
mbedtls_sha512_ret( buf, buflen,
|
||||
buf, invalid_type ) );
|
||||
|
||||
exit:
|
||||
return;
|
||||
}
|
||||
/* END_CASE */
|
||||
|
||||
/* BEGIN_CASE depends_on:MBEDTLS_SHA512_C */
|
||||
void sha384( data_t * src_str, data_t * hash )
|
||||
{
|
||||
|
||||
Reference in New Issue
Block a user