mirror/mbedtls
1
0
Fork 0
mirror of https://github.com/Mbed-TLS/mbedtls.git synced 2025-04-04 04:20:43 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

Fix excessive line lengths

Browse Source 
Signed-off-by: Paul Elliott <paul.elliott@arm.com>
This commit is contained in:
Paul Elliott 2021-05-07 17:52:18 +01:00
parent a218ceba93
commit 2df40057b3
3 changed files with 206 additions and 121 deletions

30
library/psa_crypto.c

@ -3309,7 +3309,8 @@ psa_status_t psa_aead_generate_nonce( psa_aead_operation_t *operation,
return( PSA_ERROR_BAD_STATE ); return( PSA_ERROR_BAD_STATE );
} }
required_nonce_size = PSA_AEAD_NONCE_LENGTH(operation->key_type, operation->alg); required_nonce_size = PSA_AEAD_NONCE_LENGTH(operation->key_type,
operation->alg);
if( nonce_size == 0 || nonce_size < required_nonce_size ) if( nonce_size == 0 || nonce_size < required_nonce_size )
{ {
@ -3323,7 +3324,8 @@ psa_status_t psa_aead_generate_nonce( psa_aead_operation_t *operation,
return status; return status;
} }
status = psa_driver_wrapper_aead_set_nonce( operation, nonce, required_nonce_size ); status = psa_driver_wrapper_aead_set_nonce( operation, nonce,
required_nonce_size );
if( status == PSA_SUCCESS ) if( status == PSA_SUCCESS )
{ {
@ -3345,7 +3347,8 @@ psa_status_t psa_aead_set_nonce( psa_aead_operation_t *operation,
return( PSA_ERROR_BAD_STATE ); return( PSA_ERROR_BAD_STATE );
} }
return( psa_driver_wrapper_aead_set_nonce( operation, nonce, nonce_length ) ); return( psa_driver_wrapper_aead_set_nonce( operation, nonce,
nonce_length ) );
} }
/* Declare the lengths of the message and additional data for multipart AEAD. */ /* Declare the lengths of the message and additional data for multipart AEAD. */
@ -3358,7 +3361,8 @@ psa_status_t psa_aead_set_lengths( psa_aead_operation_t *operation,
return( PSA_ERROR_BAD_STATE ); return( PSA_ERROR_BAD_STATE );
} }
return( psa_driver_wrapper_aead_set_lengths( operation, ad_length, plaintext_length ) ); return( psa_driver_wrapper_aead_set_lengths( operation, ad_length,
plaintext_length ) );
} }
/* Pass additional data to an active multipart AEAD operation. */ /* Pass additional data to an active multipart AEAD operation. */
psa_status_t psa_aead_update_ad( psa_aead_operation_t *operation, psa_status_t psa_aead_update_ad( psa_aead_operation_t *operation,
@ -3370,7 +3374,8 @@ psa_status_t psa_aead_update_ad( psa_aead_operation_t *operation,
return( PSA_ERROR_BAD_STATE ); return( PSA_ERROR_BAD_STATE );
} }
return( psa_driver_wrapper_aead_update_ad( operation, input, input_length ) ); return( psa_driver_wrapper_aead_update_ad( operation, input,
input_length ) );
} }
/* Encrypt or decrypt a message fragment in an active multipart AEAD /* Encrypt or decrypt a message fragment in an active multipart AEAD
@ -3390,7 +3395,8 @@ psa_status_t psa_aead_update( psa_aead_operation_t *operation,
return( PSA_ERROR_BAD_STATE ); return( PSA_ERROR_BAD_STATE );
} }
return( psa_driver_wrapper_aead_update( operation, input, input_length, output, output_size, return( psa_driver_wrapper_aead_update( operation, input, input_length,
output, output_size,
output_length ) ); output_length ) );
} }
@ -3412,8 +3418,10 @@ psa_status_t psa_aead_finish( psa_aead_operation_t *operation,
return( PSA_ERROR_BAD_STATE ); return( PSA_ERROR_BAD_STATE );
} }
return( psa_driver_wrapper_aead_finish( operation, ciphertext, ciphertext_size, return( psa_driver_wrapper_aead_finish( operation, ciphertext,
ciphertext_length, tag, tag_size, tag_length ) ); ciphertext_size,
ciphertext_length,
tag, tag_size, tag_length ) );
} }
/* Finish authenticating and decrypting a message in a multipart AEAD /* Finish authenticating and decrypting a message in a multipart AEAD
@ -3433,8 +3441,10 @@ psa_status_t psa_aead_verify( psa_aead_operation_t *operation,
return( PSA_ERROR_BAD_STATE ); return( PSA_ERROR_BAD_STATE );
} }
return( psa_driver_wrapper_aead_verify( operation, plaintext, plaintext_size, plaintext_length, return( psa_driver_wrapper_aead_verify( operation, plaintext,
tag, tag_length ) ); plaintext_size,
plaintext_length,
tag, tag_length ) );
} }
/* Abort an AEAD operation. */ /* Abort an AEAD operation. */

147
library/psa_crypto_aead.c

@ -355,8 +355,10 @@ exit:
/* Set the key and algorithm for a multipart authenticated encryption /* Set the key and algorithm for a multipart authenticated encryption
* operation. */ * operation. */
psa_status_t mbedtls_psa_aead_encrypt_setup( psa_aead_operation_t *operation, psa_status_t mbedtls_psa_aead_encrypt_setup( psa_aead_operation_t *operation,
const psa_key_attributes_t *attributes, const psa_key_attributes_t
const uint8_t *key_buffer, size_t key_buffer_size, *attributes,
const uint8_t *key_buffer,
size_t key_buffer_size,
psa_algorithm_t alg ) psa_algorithm_t alg )
{ {
psa_status_t status; psa_status_t status;
@ -376,8 +378,10 @@ psa_status_t mbedtls_psa_aead_encrypt_setup( psa_aead_operation_t *operation,
/* Set the key and algorithm for a multipart authenticated decryption /* Set the key and algorithm for a multipart authenticated decryption
* operation. */ * operation. */
psa_status_t mbedtls_psa_aead_decrypt_setup( psa_aead_operation_t *operation, psa_status_t mbedtls_psa_aead_decrypt_setup( psa_aead_operation_t *operation,
const psa_key_attributes_t *attributes, const psa_key_attributes_t
const uint8_t *key_buffer, size_t key_buffer_size, *attributes,
const uint8_t *key_buffer,
size_t key_buffer_size,
psa_algorithm_t alg ) psa_algorithm_t alg )
{ {
psa_status_t status; psa_status_t status;
@ -434,11 +438,12 @@ psa_status_t mbedtls_psa_aead_set_nonce( psa_aead_operation_t *operation,
return( PSA_ERROR_INVALID_ARGUMENT ); return( PSA_ERROR_INVALID_ARGUMENT );
} }
status = mbedtls_to_psa_error(mbedtls_chachapoly_starts( &operation->ctx.chachapoly, status = mbedtls_to_psa_error(
nonce, mbedtls_chachapoly_starts( &operation->ctx.chachapoly,
operation->is_encrypt ? nonce,
MBEDTLS_CHACHAPOLY_ENCRYPT : operation->is_encrypt ?
MBEDTLS_CHACHAPOLY_DECRYPT ) ); MBEDTLS_CHACHAPOLY_ENCRYPT :
MBEDTLS_CHACHAPOLY_DECRYPT ) );
} }
else else
#endif /* MBEDTLS_PSA_BUILTIN_ALG_CHACHA20_POLY1305 */ #endif /* MBEDTLS_PSA_BUILTIN_ALG_CHACHA20_POLY1305 */
@ -540,13 +545,14 @@ psa_status_t mbedtls_psa_aead_update_ad( psa_aead_operation_t *operation,
return ( PSA_ERROR_INVALID_ARGUMENT ); return ( PSA_ERROR_INVALID_ARGUMENT );
} }
status = mbedtls_to_psa_error( mbedtls_gcm_starts( &operation->ctx.gcm, status = mbedtls_to_psa_error(
operation->is_encrypt ? mbedtls_gcm_starts( &operation->ctx.gcm,
MBEDTLS_GCM_ENCRYPT : MBEDTLS_GCM_DECRYPT, operation->is_encrypt ?
operation->nonce, MBEDTLS_GCM_ENCRYPT : MBEDTLS_GCM_DECRYPT,
operation->nonce_length, operation->nonce,
input, operation->nonce_length,
input_length ) ); input,
input_length ) );
} }
else else
@ -581,9 +587,10 @@ psa_status_t mbedtls_psa_aead_update_ad( psa_aead_operation_t *operation,
#if defined(MBEDTLS_PSA_BUILTIN_ALG_CHACHA20_POLY1305) #if defined(MBEDTLS_PSA_BUILTIN_ALG_CHACHA20_POLY1305)
if( operation->alg == PSA_ALG_CHACHA20_POLY1305 ) if( operation->alg == PSA_ALG_CHACHA20_POLY1305 )
{ {
status = mbedtls_to_psa_error( mbedtls_chachapoly_update_aad( &operation->ctx.chachapoly, status = mbedtls_to_psa_error(
input, mbedtls_chachapoly_update_aad( &operation->ctx.chachapoly,
input_length ) ); input,
input_length ) );
} }
else else
#endif /* MBEDTLS_PSA_BUILTIN_ALG_CHACHA20_POLY1305 */ #endif /* MBEDTLS_PSA_BUILTIN_ALG_CHACHA20_POLY1305 */
@ -676,7 +683,8 @@ psa_status_t mbedtls_psa_aead_update( psa_aead_operation_t *operation,
} }
/* Need to store tag for Finish() / Verify() */ /* Need to store tag for Finish() / Verify() */
operation->tag_buffer = ( uint8_t * ) mbedtls_calloc(1, operation->tag_length ); operation->tag_buffer =
( uint8_t * ) mbedtls_calloc(1, operation->tag_length );
if( operation->tag_buffer ) if( operation->tag_buffer )
{ {
@ -685,16 +693,17 @@ psa_status_t mbedtls_psa_aead_update( psa_aead_operation_t *operation,
{ {
/* Perform oneshot CCM encryption with additional data already /* Perform oneshot CCM encryption with additional data already
stored, as CCM does not support multipart yet.*/ stored, as CCM does not support multipart yet.*/
status = mbedtls_to_psa_error( mbedtls_ccm_encrypt_and_tag( &operation->ctx.ccm, status = mbedtls_to_psa_error(
input_length, mbedtls_ccm_encrypt_and_tag( &operation->ctx.ccm,
operation->nonce, input_length,
operation->nonce_length, operation->nonce,
operation->ad_buffer, operation->nonce_length,
operation->ad_length, operation->ad_buffer,
input, operation->ad_length,
output, input,
operation->tag_buffer, output,
operation->tag_length ) ); operation->tag_buffer,
operation->tag_length ) );
/* Even if the above operation fails, we no longer need the /* Even if the above operation fails, we no longer need the
additional data.*/ additional data.*/
@ -706,18 +715,22 @@ psa_status_t mbedtls_psa_aead_update( psa_aead_operation_t *operation,
{ {
/* Need to back up the body data so we can do this again /* Need to back up the body data so we can do this again
later.*/ later.*/
operation->body_buffer = ( uint8_t * ) mbedtls_calloc(1, input_length ); operation->body_buffer =
( uint8_t * ) mbedtls_calloc(1, input_length );
if( operation->body_buffer ) if( operation->body_buffer )
{ {
memcpy( operation->body_buffer, input, input_length ); memcpy( operation->body_buffer, input, input_length );
operation->body_length = input_length; operation->body_length = input_length;
/* this will fail, as the tag is clearly false, but will write the /* this will fail, as the tag is clearly false, but will
decrypted data to the output buffer. */ write the decrypted data to the output buffer.*/
ret = mbedtls_ccm_auth_decrypt( &operation->ctx.ccm, input_length, ret = mbedtls_ccm_auth_decrypt( &operation->ctx.ccm,
operation->nonce, operation->nonce_length, input_length,
operation->ad_buffer, operation->ad_length, operation->nonce,
operation->nonce_length,
operation->ad_buffer,
operation->ad_length,
input, output, input, output,
operation->tag_buffer, operation->tag_buffer,
operation->tag_length ); operation->tag_length );
@ -747,10 +760,11 @@ psa_status_t mbedtls_psa_aead_update( psa_aead_operation_t *operation,
#if defined(MBEDTLS_PSA_BUILTIN_ALG_CHACHA20_POLY1305) #if defined(MBEDTLS_PSA_BUILTIN_ALG_CHACHA20_POLY1305)
if( operation->alg == PSA_ALG_CHACHA20_POLY1305 ) if( operation->alg == PSA_ALG_CHACHA20_POLY1305 )
{ {
status = mbedtls_to_psa_error( mbedtls_chachapoly_update( &operation->ctx.chachapoly, status = mbedtls_to_psa_error(
input_length, mbedtls_chachapoly_update( &operation->ctx.chachapoly,
input, input_length,
output ) ); input,
output ) );
} }
else else
#endif /* MBEDTLS_PSA_BUILTIN_ALG_CHACHA20_POLY1305 */ #endif /* MBEDTLS_PSA_BUILTIN_ALG_CHACHA20_POLY1305 */
@ -772,7 +786,8 @@ psa_status_t mbedtls_psa_aead_update( psa_aead_operation_t *operation,
/* Common checks for both mbedtls_psa_aead_finish() and /* Common checks for both mbedtls_psa_aead_finish() and
mbedtls_psa_aead_verify() */ mbedtls_psa_aead_verify() */
static psa_status_t mbedtls_psa_aead_finish_checks( psa_aead_operation_t *operation, static psa_status_t mbedtls_psa_aead_finish_checks( psa_aead_operation_t
*operation,
size_t output_size, size_t output_size,
size_t tag_size ) size_t tag_size )
{ {
@ -793,13 +808,15 @@ static psa_status_t mbedtls_psa_aead_finish_checks( psa_aead_operation_t *operat
if( operation->is_encrypt ) if( operation->is_encrypt )
{ {
finish_output_size = PSA_AEAD_FINISH_OUTPUT_SIZE( operation->key_type, finish_output_size =
operation->alg ); PSA_AEAD_FINISH_OUTPUT_SIZE( operation->key_type,
operation->alg );
} }
else else
{ {
finish_output_size = PSA_AEAD_VERIFY_OUTPUT_SIZE( operation->key_type, finish_output_size =
operation->alg ); PSA_AEAD_VERIFY_OUTPUT_SIZE( operation->key_type,
operation->alg );
} }
if( output_size < finish_output_size ) if( output_size < finish_output_size )
@ -822,7 +839,8 @@ psa_status_t mbedtls_psa_aead_finish( psa_aead_operation_t *operation,
psa_status_t status = PSA_ERROR_CORRUPTION_DETECTED; psa_status_t status = PSA_ERROR_CORRUPTION_DETECTED;
size_t finish_output_size = 0; size_t finish_output_size = 0;
status = mbedtls_psa_aead_finish_checks( operation, ciphertext_size, tag_size ); status = mbedtls_psa_aead_finish_checks( operation, ciphertext_size,
tag_size );
if( status != PSA_SUCCESS ) if( status != PSA_SUCCESS )
{ {
@ -855,8 +873,9 @@ psa_status_t mbedtls_psa_aead_finish( psa_aead_operation_t *operation,
#if defined(MBEDTLS_PSA_BUILTIN_ALG_CHACHA20_POLY1305) #if defined(MBEDTLS_PSA_BUILTIN_ALG_CHACHA20_POLY1305)
if( operation->alg == PSA_ALG_CHACHA20_POLY1305 ) if( operation->alg == PSA_ALG_CHACHA20_POLY1305 )
{ {
status = mbedtls_to_psa_error( mbedtls_chachapoly_finish( &operation->ctx.chachapoly, status = mbedtls_to_psa_error(
tag ) ); mbedtls_chachapoly_finish( &operation->ctx.chachapoly,
tag ) );
} }
else else
#endif /* MBEDTLS_PSA_BUILTIN_ALG_CHACHA20_POLY1305 */ #endif /* MBEDTLS_PSA_BUILTIN_ALG_CHACHA20_POLY1305 */
@ -902,7 +921,8 @@ psa_status_t mbedtls_psa_aead_verify( psa_aead_operation_t *operation,
int do_tag_check = 1; int do_tag_check = 1;
uint8_t check_tag[16]; uint8_t check_tag[16];
status = mbedtls_psa_aead_finish_checks( operation, plaintext_size, tag_length ); status = mbedtls_psa_aead_finish_checks( operation, plaintext_size,
tag_length );
if( status != PSA_SUCCESS ) if( status != PSA_SUCCESS )
{ {
@ -913,9 +933,10 @@ psa_status_t mbedtls_psa_aead_verify( psa_aead_operation_t *operation,
if( operation->alg == PSA_ALG_GCM ) if( operation->alg == PSA_ALG_GCM )
{ {
/* Call finish to get the tag for comparison */ /* Call finish to get the tag for comparison */
status = mbedtls_to_psa_error( mbedtls_gcm_finish( &operation->ctx.gcm, status = mbedtls_to_psa_error(
check_tag, mbedtls_gcm_finish( &operation->ctx.gcm,
operation->tag_length ) ); check_tag,
operation->tag_length ) );
} }
else else
#endif /* MBEDTLS_PSA_BUILTIN_ALG_GCM */ #endif /* MBEDTLS_PSA_BUILTIN_ALG_GCM */
@ -931,17 +952,22 @@ psa_status_t mbedtls_psa_aead_verify( psa_aead_operation_t *operation,
* only way to get the tag, but this time throw away the * only way to get the tag, but this time throw away the
results, as verify cannot write that much data. */ results, as verify cannot write that much data. */
temp_buffer_size = PSA_AEAD_UPDATE_OUTPUT_SIZE( operation->key_type, temp_buffer_size = PSA_AEAD_UPDATE_OUTPUT_SIZE( operation->key_type,
operation->alg, operation->body_length ); operation->alg,
operation->body_length
);
temp_buffer = ( uint8_t * ) mbedtls_calloc(1, temp_buffer_size ); temp_buffer = ( uint8_t * ) mbedtls_calloc(1, temp_buffer_size );
if( temp_buffer ) if( temp_buffer )
{ {
ret = mbedtls_ccm_auth_decrypt( &operation->ctx.ccm, operation->body_length, ret = mbedtls_ccm_auth_decrypt( &operation->ctx.ccm,
operation->nonce, operation->nonce_length, operation->body_length,
operation->ad_buffer, operation->ad_length, operation->nonce,
operation->body_buffer, temp_buffer, operation->nonce_length,
tag, tag_length ); operation->ad_buffer,
operation->ad_length,
operation->body_buffer,
temp_buffer, tag, tag_length );
if( ret == MBEDTLS_ERR_CCM_AUTH_FAILED ) if( ret == MBEDTLS_ERR_CCM_AUTH_FAILED )
{ {
@ -974,8 +1000,9 @@ psa_status_t mbedtls_psa_aead_verify( psa_aead_operation_t *operation,
if( operation->alg == PSA_ALG_CHACHA20_POLY1305 ) if( operation->alg == PSA_ALG_CHACHA20_POLY1305 )
{ {
// call finish to get the tag for comparison. // call finish to get the tag for comparison.
status = mbedtls_to_psa_error( mbedtls_chachapoly_finish( &operation->ctx.chachapoly, status = mbedtls_to_psa_error(
check_tag ) ); mbedtls_chachapoly_finish( &operation->ctx.chachapoly,
check_tag ) );
} }
else else

150
tests/suites/test_suite_psa_crypto.function

@ -3201,7 +3201,8 @@ void aead_multipart_encrypt( int key_type_arg, data_t *key_data,
TEST_ASSERT( tag_length <= 16 ); TEST_ASSERT( tag_length <= 16 );
output_size = PSA_AEAD_UPDATE_OUTPUT_SIZE( key_type, alg, output_size = PSA_AEAD_UPDATE_OUTPUT_SIZE( key_type, alg,
( input_data->len + tag_length ) ); ( input_data->len +
tag_length ) );
ASSERT_ALLOC( output_data, output_size ); ASSERT_ALLOC( output_data, output_size );
@ -3224,8 +3225,9 @@ void aead_multipart_encrypt( int key_type_arg, data_t *key_data,
if( nonce->len == 0 ) if( nonce->len == 0 )
{ {
PSA_ASSERT( psa_aead_generate_nonce( &operation, nonce_buffer, sizeof( nonce_buffer ), PSA_ASSERT( psa_aead_generate_nonce( &operation, nonce_buffer,
&nonce_length ) ); sizeof( nonce_buffer ),
&nonce_length ) );
} }
else else
{ {
@ -3236,7 +3238,8 @@ void aead_multipart_encrypt( int key_type_arg, data_t *key_data,
#if defined(MBEDTLS_PSA_BUILTIN_ALG_GCM) #if defined(MBEDTLS_PSA_BUILTIN_ALG_GCM)
if( operation.alg == PSA_ALG_GCM ) if( operation.alg == PSA_ALG_GCM )
{ {
PSA_ASSERT( psa_aead_set_lengths( &operation, additional_data->len, input_data->len ) ); PSA_ASSERT( psa_aead_set_lengths( &operation, additional_data->len,
input_data->len ) );
} }
#endif #endif
@ -3256,7 +3259,8 @@ void aead_multipart_encrypt( int key_type_arg, data_t *key_data,
part_length = ad_part_len; part_length = ad_part_len;
} }
PSA_ASSERT( psa_aead_update_ad(&operation, additional_data->x + part_offset, PSA_ASSERT( psa_aead_update_ad( &operation,
additional_data->x + part_offset,
part_length ) ); part_length ) );
part_offset += part_length; part_offset += part_length;
@ -3265,13 +3269,15 @@ void aead_multipart_encrypt( int key_type_arg, data_t *key_data,
else else
{ {
/* Pass additional data in one go. */ /* Pass additional data in one go. */
PSA_ASSERT( psa_aead_update_ad(&operation, additional_data->x, additional_data->len) ); PSA_ASSERT( psa_aead_update_ad(&operation, additional_data->x,
additional_data->len) );
} }
if( data_part_len != -1 ) if( data_part_len != -1 )
{ {
/* Pass data in parts */ /* Pass data in parts */
part_data_size = PSA_AEAD_UPDATE_OUTPUT_SIZE( key_type, alg, ( size_t ) data_part_len ); part_data_size = PSA_AEAD_UPDATE_OUTPUT_SIZE( key_type, alg,
( size_t ) data_part_len );
ASSERT_ALLOC( part_data, part_data_size ); ASSERT_ALLOC( part_data, part_data_size );
@ -3288,13 +3294,16 @@ void aead_multipart_encrypt( int key_type_arg, data_t *key_data,
part_length = data_part_len; part_length = data_part_len;
} }
PSA_ASSERT( psa_aead_update( &operation, ( input_data->x + part_offset ), PSA_ASSERT( psa_aead_update( &operation,
( input_data->x + part_offset ),
part_length, part_data, part_length, part_data,
part_data_size, &output_part_length ) ); part_data_size,
&output_part_length ) );
if( output_data && output_part_length ) if( output_data && output_part_length )
{ {
memcpy( ( output_data + part_offset ), part_data, output_part_length ); memcpy( ( output_data + part_offset ), part_data,
output_part_length );
} }
part_offset += part_length; part_offset += part_length;
@ -3317,7 +3326,8 @@ void aead_multipart_encrypt( int key_type_arg, data_t *key_data,
if( output_data && output_part_length ) if( output_data && output_part_length )
{ {
memcpy( ( output_data + output_length ), final_data, output_part_length ); memcpy( ( output_data + output_length ), final_data,
output_part_length );
} }
TEST_EQUAL(tag_length, tag_size); TEST_EQUAL(tag_length, tag_size);
@ -3334,7 +3344,8 @@ void aead_multipart_encrypt( int key_type_arg, data_t *key_data,
/* For all currently defined algorithms, PSA_AEAD_ENCRYPT_OUTPUT_SIZE /* For all currently defined algorithms, PSA_AEAD_ENCRYPT_OUTPUT_SIZE
* should be exact. */ * should be exact. */
TEST_EQUAL( output_length, TEST_EQUAL( output_length,
PSA_AEAD_ENCRYPT_OUTPUT_SIZE( key_type, alg, input_data->len ) ); PSA_AEAD_ENCRYPT_OUTPUT_SIZE( key_type, alg,
input_data->len ) );
TEST_ASSERT( output_length <= TEST_ASSERT( output_length <=
PSA_AEAD_ENCRYPT_OUTPUT_MAX_SIZE( input_data->len ) ); PSA_AEAD_ENCRYPT_OUTPUT_MAX_SIZE( input_data->len ) );
@ -3389,7 +3400,8 @@ void aead_multipart_encrypt_decrypt( int key_type_arg, data_t *key_data,
PSA_ASSERT( psa_crypto_init( ) ); PSA_ASSERT( psa_crypto_init( ) );
psa_set_key_usage_flags( &attributes, PSA_KEY_USAGE_ENCRYPT | PSA_KEY_USAGE_DECRYPT ); psa_set_key_usage_flags( &attributes,
PSA_KEY_USAGE_ENCRYPT | PSA_KEY_USAGE_DECRYPT );
psa_set_key_algorithm( &attributes, alg ); psa_set_key_algorithm( &attributes, alg );
psa_set_key_type( &attributes, key_type ); psa_set_key_type( &attributes, key_type );
@ -3429,7 +3441,8 @@ void aead_multipart_encrypt_decrypt( int key_type_arg, data_t *key_data,
if( nonce->len == 0 ) if( nonce->len == 0 )
{ {
status = psa_aead_generate_nonce( &operation, nonce_buffer, sizeof( nonce_buffer ), status = psa_aead_generate_nonce( &operation, nonce_buffer,
sizeof( nonce_buffer ),
&nonce_length ); &nonce_length );
} }
else else
@ -3447,7 +3460,8 @@ void aead_multipart_encrypt_decrypt( int key_type_arg, data_t *key_data,
#if defined(MBEDTLS_PSA_BUILTIN_ALG_GCM) #if defined(MBEDTLS_PSA_BUILTIN_ALG_GCM)
if( operation.alg == PSA_ALG_GCM ) if( operation.alg == PSA_ALG_GCM )
{ {
status = psa_aead_set_lengths( &operation, additional_data->len, input_data->len ); status = psa_aead_set_lengths( &operation, additional_data->len,
input_data->len );
if( status != PSA_SUCCESS ) if( status != PSA_SUCCESS )
{ {
@ -3472,7 +3486,8 @@ void aead_multipart_encrypt_decrypt( int key_type_arg, data_t *key_data,
part_length = ad_part_len; part_length = ad_part_len;
} }
status = psa_aead_update_ad( &operation, additional_data->x + part_offset, status = psa_aead_update_ad( &operation,
additional_data->x + part_offset,
part_length ); part_length );
if( status != PSA_SUCCESS ) if( status != PSA_SUCCESS )
@ -3486,7 +3501,8 @@ void aead_multipart_encrypt_decrypt( int key_type_arg, data_t *key_data,
} }
else else
{ {
status = psa_aead_update_ad(&operation, additional_data->x, additional_data->len); status = psa_aead_update_ad(&operation, additional_data->x,
additional_data->len);
if( status != PSA_SUCCESS ) if( status != PSA_SUCCESS )
{ {
@ -3499,7 +3515,7 @@ void aead_multipart_encrypt_decrypt( int key_type_arg, data_t *key_data,
{ {
/* Pass data in parts */ /* Pass data in parts */
part_data_size = PSA_AEAD_UPDATE_OUTPUT_SIZE( key_type, alg, part_data_size = PSA_AEAD_UPDATE_OUTPUT_SIZE( key_type, alg,
( size_t ) data_part_len ); ( size_t ) data_part_len );
ASSERT_ALLOC( part_data, part_data_size ); ASSERT_ALLOC( part_data, part_data_size );
@ -3516,7 +3532,8 @@ void aead_multipart_encrypt_decrypt( int key_type_arg, data_t *key_data,
part_length = data_part_len; part_length = data_part_len;
} }
status = psa_aead_update( &operation, ( input_data->x + part_offset ), status = psa_aead_update( &operation,
( input_data->x + part_offset ),
part_length, part_data, part_length, part_data,
part_data_size, &output_part_length ); part_data_size, &output_part_length );
@ -3528,7 +3545,8 @@ void aead_multipart_encrypt_decrypt( int key_type_arg, data_t *key_data,
if( output_data && output_part_length ) if( output_data && output_part_length )
{ {
memcpy( ( output_data + part_offset ), part_data, output_part_length ); memcpy( ( output_data + part_offset ), part_data,
output_part_length );
} }
part_offset += part_length; part_offset += part_length;
@ -3562,7 +3580,8 @@ void aead_multipart_encrypt_decrypt( int key_type_arg, data_t *key_data,
if( output_data &&output_part_length ) if( output_data &&output_part_length )
{ {
memcpy( ( output_data + output_length ), final_data, output_part_length ); memcpy( ( output_data + output_length ), final_data,
output_part_length );
} }
output_length += output_part_length; output_length += output_part_length;
@ -3571,23 +3590,27 @@ void aead_multipart_encrypt_decrypt( int key_type_arg, data_t *key_data,
* should be exact. */ * should be exact. */
if( expected_result != PSA_ERROR_INVALID_ARGUMENT ) if( expected_result != PSA_ERROR_INVALID_ARGUMENT )
TEST_EQUAL( ( output_length + tag_length ), TEST_EQUAL( ( output_length + tag_length ),
PSA_AEAD_ENCRYPT_OUTPUT_SIZE( key_type, alg, input_data->len ) ); PSA_AEAD_ENCRYPT_OUTPUT_SIZE( key_type, alg,
input_data->len ) );
TEST_EQUAL(tag_length, tag_size); TEST_EQUAL(tag_length, tag_size);
if( PSA_SUCCESS == expected_result ) if( PSA_SUCCESS == expected_result )
{ {
output_size2 = PSA_AEAD_UPDATE_OUTPUT_SIZE( key_type, alg, output_length ); output_size2 = PSA_AEAD_UPDATE_OUTPUT_SIZE( key_type, alg,
output_length );
ASSERT_ALLOC( output_data2, output_size2 ); ASSERT_ALLOC( output_data2, output_size2 );
/* For all currently defined algorithms, PSA_AEAD_DECRYPT_OUTPUT_SIZE /* For all currently defined algorithms, PSA_AEAD_DECRYPT_OUTPUT_SIZE
* should be exact. */ * should be exact. */
TEST_EQUAL( input_data->len, TEST_EQUAL( input_data->len,
PSA_AEAD_DECRYPT_OUTPUT_SIZE( key_type, alg, PSA_AEAD_DECRYPT_OUTPUT_SIZE( key_type, alg,
( output_length + tag_length ) ) ); ( output_length +
tag_length ) ) );
TEST_ASSERT( input_data->len <= TEST_ASSERT( input_data->len <=
PSA_AEAD_DECRYPT_OUTPUT_MAX_SIZE( output_length + tag_length ) ); PSA_AEAD_DECRYPT_OUTPUT_MAX_SIZE( output_length +
tag_length ) );
operation = psa_aead_operation_init(); operation = psa_aead_operation_init();
@ -3599,7 +3622,8 @@ void aead_multipart_encrypt_decrypt( int key_type_arg, data_t *key_data,
if( status == PSA_ERROR_NOT_SUPPORTED ) if( status == PSA_ERROR_NOT_SUPPORTED )
{ {
MBEDTLS_TEST_PSA_SKIP_IF_ALT_AES_192( key_type, key_data->len * 8 ); MBEDTLS_TEST_PSA_SKIP_IF_ALT_AES_192( key_type, key_data->len * 8 );
MBEDTLS_TEST_PSA_SKIP_IF_ALT_GCM_NOT_12BYTES_NONCE( alg, nonce->len ); MBEDTLS_TEST_PSA_SKIP_IF_ALT_GCM_NOT_12BYTES_NONCE( alg,
nonce->len );
} }
TEST_EQUAL( status, expected_result ); TEST_EQUAL( status, expected_result );
@ -3607,7 +3631,8 @@ void aead_multipart_encrypt_decrypt( int key_type_arg, data_t *key_data,
if( nonce->len == 0 ) if( nonce->len == 0 )
{ {
/* Use previously generated nonce. */ /* Use previously generated nonce. */
status = psa_aead_set_nonce( &operation, nonce_buffer, nonce_length ); status = psa_aead_set_nonce( &operation, nonce_buffer,
nonce_length );
} }
else else
{ {
@ -3623,7 +3648,8 @@ void aead_multipart_encrypt_decrypt( int key_type_arg, data_t *key_data,
#if defined(MBEDTLS_PSA_BUILTIN_ALG_GCM) #if defined(MBEDTLS_PSA_BUILTIN_ALG_GCM)
if( operation.alg == PSA_ALG_GCM ) if( operation.alg == PSA_ALG_GCM )
{ {
status = psa_aead_set_lengths( &operation, additional_data->len, output_length ); status = psa_aead_set_lengths( &operation, additional_data->len,
output_length );
if( status != PSA_SUCCESS ) if( status != PSA_SUCCESS )
{ {
@ -3638,7 +3664,8 @@ void aead_multipart_encrypt_decrypt( int key_type_arg, data_t *key_data,
while( part_offset <= additional_data->len) while( part_offset <= additional_data->len)
{ {
if( additional_data->len - part_offset < ( uint32_t ) ad_part_len ) if( additional_data->len - part_offset <
( uint32_t ) ad_part_len )
{ {
part_length = additional_data->len - part_offset; part_length = additional_data->len - part_offset;
} }
@ -3647,7 +3674,9 @@ void aead_multipart_encrypt_decrypt( int key_type_arg, data_t *key_data,
part_length = ad_part_len; part_length = ad_part_len;
} }
PSA_ASSERT( psa_aead_update_ad(&operation, additional_data->x + part_offset, PSA_ASSERT( psa_aead_update_ad( &operation,
additional_data->x +
part_offset,
part_length ) ); part_length ) );
part_offset += part_length; part_offset += part_length;
@ -3655,13 +3684,15 @@ void aead_multipart_encrypt_decrypt( int key_type_arg, data_t *key_data,
} }
else else
{ {
PSA_ASSERT( psa_aead_update_ad(&operation, additional_data->x, additional_data->len) ); PSA_ASSERT( psa_aead_update_ad(&operation, additional_data->x,
additional_data->len) );
} }
if( data_part_len != -1 ) if( data_part_len != -1 )
{ {
/* Pass data in parts */ /* Pass data in parts */
part_data_size = PSA_AEAD_UPDATE_OUTPUT_SIZE( key_type, alg, ( size_t ) data_part_len ); part_data_size = PSA_AEAD_UPDATE_OUTPUT_SIZE( key_type, alg,
( size_t ) data_part_len );
ASSERT_ALLOC( part_data, part_data_size ); ASSERT_ALLOC( part_data, part_data_size );
@ -3669,22 +3700,27 @@ void aead_multipart_encrypt_decrypt( int key_type_arg, data_t *key_data,
while( part_offset <= ( input_data->len - tag_length ) ) while( part_offset <= ( input_data->len - tag_length ) )
{ {
if( ( input_data->len - tag_length - part_offset ) < ( uint32_t ) data_part_len ) if( ( input_data->len - tag_length - part_offset ) <
( uint32_t ) data_part_len )
{ {
part_length = ( input_data->len - tag_length - part_offset ); part_length =
( input_data->len - tag_length - part_offset );
} }
else else
{ {
part_length = data_part_len; part_length = data_part_len;
} }
PSA_ASSERT( psa_aead_update( &operation, ( input_data->x + part_offset ), PSA_ASSERT( psa_aead_update( &operation,
( input_data->x + part_offset ),
part_length, part_data, part_length, part_data,
part_data_size, &output_part_length ) ); part_data_size,
&output_part_length ) );
if( output_data2 && output_part_length ) if( output_data2 && output_part_length )
{ {
memcpy( ( output_data2 + part_offset ), part_data, output_part_length ); memcpy( ( output_data2 + part_offset ),
part_data, output_part_length );
} }
part_offset += part_length; part_offset += part_length;
@ -3705,7 +3741,8 @@ void aead_multipart_encrypt_decrypt( int key_type_arg, data_t *key_data,
if( output_data2 && output_part_length ) if( output_data2 && output_part_length )
{ {
memcpy( ( output_data2 + output_length2 ), final_data, output_part_length); memcpy( ( output_data2 + output_length2 ), final_data,
output_part_length);
} }
output_length2 += output_part_length; output_length2 += output_part_length;
@ -3772,7 +3809,8 @@ void aead_multipart_decrypt( int key_type_arg, data_t *key_data,
tag_length = PSA_AEAD_TAG_LENGTH( key_type, key_bits, alg ); tag_length = PSA_AEAD_TAG_LENGTH( key_type, key_bits, alg );
output_size = PSA_AEAD_UPDATE_OUTPUT_SIZE( key_type, alg, output_size = PSA_AEAD_UPDATE_OUTPUT_SIZE( key_type, alg,
( input_data->len - tag_length ) ); ( input_data->len -
tag_length ) );
ASSERT_ALLOC( output_data, output_size ); ASSERT_ALLOC( output_data, output_size );
ASSERT_ALLOC( final_data, PSA_AEAD_VERIFY_OUTPUT_MAX_SIZE ); ASSERT_ALLOC( final_data, PSA_AEAD_VERIFY_OUTPUT_MAX_SIZE );
@ -3798,7 +3836,8 @@ void aead_multipart_decrypt( int key_type_arg, data_t *key_data,
if( nonce->len == 0 ) if( nonce->len == 0 )
{ {
status = psa_aead_generate_nonce( &operation, nonce_buffer, sizeof( nonce_buffer ), status = psa_aead_generate_nonce( &operation, nonce_buffer,
sizeof( nonce_buffer ),
&nonce_length ); &nonce_length );
} }
else else
@ -3842,7 +3881,8 @@ void aead_multipart_decrypt( int key_type_arg, data_t *key_data,
part_length = ad_part_len; part_length = ad_part_len;
} }
status = psa_aead_update_ad( &operation, additional_data->x + part_offset, status = psa_aead_update_ad( &operation,
additional_data->x + part_offset,
part_length ); part_length );
if( status != PSA_SUCCESS ) if( status != PSA_SUCCESS )
@ -3856,7 +3896,8 @@ void aead_multipart_decrypt( int key_type_arg, data_t *key_data,
} }
else else
{ {
status = psa_aead_update_ad( &operation, additional_data->x, additional_data->len ); status = psa_aead_update_ad( &operation, additional_data->x,
additional_data->len );
if( status != PSA_SUCCESS ) if( status != PSA_SUCCESS )
{ {
@ -3868,7 +3909,8 @@ void aead_multipart_decrypt( int key_type_arg, data_t *key_data,
if( data_part_len != -1 ) if( data_part_len != -1 )
{ {
/* Pass data in parts */ /* Pass data in parts */
part_data_size = PSA_AEAD_UPDATE_OUTPUT_SIZE( key_type, alg, ( size_t ) data_part_len ); part_data_size = PSA_AEAD_UPDATE_OUTPUT_SIZE( key_type, alg,
( size_t ) data_part_len );
ASSERT_ALLOC( part_data, part_data_size ); ASSERT_ALLOC( part_data, part_data_size );
@ -3876,7 +3918,8 @@ void aead_multipart_decrypt( int key_type_arg, data_t *key_data,
while( part_offset <= input_data->len) while( part_offset <= input_data->len)
{ {
if( (input_data->len - tag_length - part_offset ) < ( uint32_t ) data_part_len ) if( (input_data->len - tag_length - part_offset ) <
( uint32_t ) data_part_len )
{ {
part_length = ( input_data->len - tag_length - part_offset ); part_length = ( input_data->len - tag_length - part_offset );
} }
@ -3885,9 +3928,10 @@ void aead_multipart_decrypt( int key_type_arg, data_t *key_data,
part_length = data_part_len; part_length = data_part_len;
} }
status = psa_aead_update( &operation, ( input_data->x + part_offset ), status = psa_aead_update( &operation,
part_length, part_data, ( input_data->x + part_offset ),
part_data_size, &output_part_length ); part_length, part_data,
part_data_size, &output_part_length );
if( status != PSA_SUCCESS ) if( status != PSA_SUCCESS )
{ {
@ -3897,7 +3941,8 @@ void aead_multipart_decrypt( int key_type_arg, data_t *key_data,
if( output_data && output_part_length ) if( output_data && output_part_length )
{ {
memcpy( ( output_data + part_offset ), part_data, output_part_length ); memcpy( ( output_data + part_offset ), part_data,
output_part_length );
} }
part_offset += part_length; part_offset += part_length;
@ -3920,7 +3965,8 @@ void aead_multipart_decrypt( int key_type_arg, data_t *key_data,
status = psa_aead_verify( &operation, final_data, status = psa_aead_verify( &operation, final_data,
PSA_AEAD_VERIFY_OUTPUT_MAX_SIZE, PSA_AEAD_VERIFY_OUTPUT_MAX_SIZE,
&output_part_length, &output_part_length,
( input_data->x + input_data->len - tag_length ), ( input_data->x + input_data->len -
tag_length ),
tag_length ); tag_length );
if( status != PSA_SUCCESS ) if( status != PSA_SUCCESS )
@ -3931,7 +3977,8 @@ void aead_multipart_decrypt( int key_type_arg, data_t *key_data,
if( output_data && output_part_length ) if( output_data && output_part_length )
{ {
memcpy( ( output_data + output_length ), final_data, output_part_length ); memcpy( ( output_data + output_length ), final_data,
output_part_length );
} }
output_length += output_part_length; output_length += output_part_length;
@ -3941,7 +3988,8 @@ void aead_multipart_decrypt( int key_type_arg, data_t *key_data,
/* For all currently defined algorithms, PSA_AEAD_DECRYPT_OUTPUT_SIZE /* For all currently defined algorithms, PSA_AEAD_DECRYPT_OUTPUT_SIZE
* should be exact. */ * should be exact. */
TEST_EQUAL( output_length, TEST_EQUAL( output_length,
PSA_AEAD_DECRYPT_OUTPUT_SIZE( key_type, alg, input_data->len ) ); PSA_AEAD_DECRYPT_OUTPUT_SIZE( key_type, alg,
input_data->len ) );
TEST_ASSERT( output_length <= TEST_ASSERT( output_length <=
PSA_AEAD_DECRYPT_OUTPUT_MAX_SIZE( input_data->len ) ); PSA_AEAD_DECRYPT_OUTPUT_MAX_SIZE( input_data->len ) );
} }