yuzu/mbedtls
1
0
Fork 0
mirror of https://github.com/yuzu-emu/mbedtls.git synced 2025-01-24 05:41:05 +00:00
Code Issues Packages Projects Releases Wiki Activity

psa: cipher: Re-organize multi-part operation context

Browse source 
Move members that are of no use to the PSA crypto core
to the Mbed TLS implementation specific operation context.

Signed-off-by: Ronald Cron <ronald.cron@arm.com>
This commit is contained in:
Ronald Cron 2021-03-10 09:17:32 +01:00
parent 49fafa98b1
commit 937dfee92c
3 changed files with 49 additions and 42 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

15
include/psa/crypto_struct.h
View file

@ -136,6 +136,14 @@ static inline struct psa_mac_operation_s psa_mac_operation_init( void )
return( v ); return( v );
} }
typedef struct {
/** Context structure for the Mbed TLS cipher implementation. */
psa_algorithm_t alg;
uint8_t iv_size;
uint8_t block_size;
mbedtls_cipher_context_t cipher;
} mbedtls_psa_cipher_operation_t;
struct psa_cipher_operation_s struct psa_cipher_operation_s
{ {
/** Unique ID indicating which driver got assigned to do the /** Unique ID indicating which driver got assigned to do the
@ -146,20 +154,17 @@ struct psa_cipher_operation_s
* any driver (i.e. none of the driver contexts are active). */ * any driver (i.e. none of the driver contexts are active). */
unsigned int id; unsigned int id;
psa_algorithm_t alg;
unsigned int iv_required : 1; unsigned int iv_required : 1;
unsigned int iv_set : 1; unsigned int iv_set : 1;
uint8_t iv_size;
uint8_t block_size;
union union
{ {
unsigned dummy; /* Enable easier initializing of the union. */ unsigned dummy; /* Enable easier initializing of the union. */
mbedtls_cipher_context_t cipher; mbedtls_psa_cipher_operation_t mbedtls_ctx;
psa_operation_driver_context_t driver; psa_operation_driver_context_t driver;
} ctx; } ctx;
}; };
#define PSA_CIPHER_OPERATION_INIT {0, 0, 0, 0, 0, 0, {0}} #define PSA_CIPHER_OPERATION_INIT {0, 0, 0, {0}}
static inline struct psa_cipher_operation_s psa_cipher_operation_init( void ) static inline struct psa_cipher_operation_s psa_cipher_operation_init( void )
{ {
const struct psa_cipher_operation_s v = PSA_CIPHER_OPERATION_INIT; const struct psa_cipher_operation_s v = PSA_CIPHER_OPERATION_INIT;

11
library/psa_crypto.c
View file

@ -3409,10 +3409,7 @@ static psa_status_t psa_cipher_setup( psa_cipher_operation_t *operation,
* is used to indicate to psa_cipher_abort that there are resources to free, * is used to indicate to psa_cipher_abort that there are resources to free,
* so we only set it (in the driver wrapper) after resources have been * so we only set it (in the driver wrapper) after resources have been
* allocated/initialized. */ * allocated/initialized. */
operation->alg = alg;
operation->iv_set = 0; operation->iv_set = 0;
operation->iv_size = 0;
operation->block_size = 0;
if( alg == PSA_ALG_ECB_NO_PADDING ) if( alg == PSA_ALG_ECB_NO_PADDING )
operation->iv_required = 0; operation->iv_required = 0;
else else
@ -3587,18 +3584,10 @@ psa_status_t psa_cipher_abort( psa_cipher_operation_t *operation )
return( PSA_SUCCESS ); return( PSA_SUCCESS );
} }
/* Sanity check (shouldn't happen: operation->alg should
* always have been initialized to a valid value). */
if( ! PSA_ALG_IS_CIPHER( operation->alg ) )
return( PSA_ERROR_BAD_STATE );
psa_driver_wrapper_cipher_abort( operation ); psa_driver_wrapper_cipher_abort( operation );
operation->id = 0; operation->id = 0;
operation->alg = 0;
operation->iv_set = 0; operation->iv_set = 0;
operation->iv_size = 0;
operation->block_size = 0;
operation->iv_required = 0; operation->iv_required = 0;
return( PSA_SUCCESS ); return( PSA_SUCCESS );

65
library/psa_crypto_cipher.c
View file

@ -42,21 +42,22 @@ static psa_status_t cipher_setup(
size_t key_bits; size_t key_bits;
const mbedtls_cipher_info_t *cipher_info = NULL; const mbedtls_cipher_info_t *cipher_info = NULL;
psa_key_type_t key_type = attributes->core.type; psa_key_type_t key_type = attributes->core.type;
mbedtls_psa_cipher_operation_t *mbedtls_ctx = &operation->ctx.mbedtls_ctx;
(void)key_buffer_size; (void)key_buffer_size;
/* Proceed with initializing an mbed TLS cipher context if no driver is /* Proceed with initializing an mbed TLS cipher context if no driver is
* available for the given algorithm & key. */ * available for the given algorithm & key. */
mbedtls_cipher_init( &operation->ctx.cipher ); mbedtls_cipher_init( &mbedtls_ctx->cipher );
operation->alg = alg; mbedtls_ctx->alg = alg;
key_bits = attributes->core.bits; key_bits = attributes->core.bits;
cipher_info = mbedtls_cipher_info_from_psa( alg, key_type, cipher_info = mbedtls_cipher_info_from_psa( alg, key_type,
key_bits, NULL ); key_bits, NULL );
if( cipher_info == NULL ) if( cipher_info == NULL )
return( PSA_ERROR_NOT_SUPPORTED ); return( PSA_ERROR_NOT_SUPPORTED );
ret = mbedtls_cipher_setup( &operation->ctx.cipher, cipher_info ); ret = mbedtls_cipher_setup( &mbedtls_ctx->cipher, cipher_info );
if( ret != 0 ) if( ret != 0 )
goto exit; goto exit;
@ -67,14 +68,14 @@ static psa_status_t cipher_setup(
uint8_t keys[24]; uint8_t keys[24];
memcpy( keys, key_buffer, 16 ); memcpy( keys, key_buffer, 16 );
memcpy( keys + 16, key_buffer, 8 ); memcpy( keys + 16, key_buffer, 8 );
ret = mbedtls_cipher_setkey( &operation->ctx.cipher, ret = mbedtls_cipher_setkey( &mbedtls_ctx->cipher,
keys, keys,
192, cipher_operation ); 192, cipher_operation );
} }
else else
#endif #endif
{ {
ret = mbedtls_cipher_setkey( &operation->ctx.cipher, key_buffer, ret = mbedtls_cipher_setkey( &mbedtls_ctx->cipher, key_buffer,
(int) key_bits, cipher_operation ); (int) key_bits, cipher_operation );
} }
if( ret != 0 ) if( ret != 0 )
@ -85,11 +86,11 @@ static psa_status_t cipher_setup(
switch( alg ) switch( alg )
{ {
case PSA_ALG_CBC_NO_PADDING: case PSA_ALG_CBC_NO_PADDING:
ret = mbedtls_cipher_set_padding_mode( &operation->ctx.cipher, ret = mbedtls_cipher_set_padding_mode( &mbedtls_ctx->cipher,
MBEDTLS_PADDING_NONE ); MBEDTLS_PADDING_NONE );
break; break;
case PSA_ALG_CBC_PKCS7: case PSA_ALG_CBC_PKCS7:
ret = mbedtls_cipher_set_padding_mode( &operation->ctx.cipher, ret = mbedtls_cipher_set_padding_mode( &mbedtls_ctx->cipher,
MBEDTLS_PADDING_PKCS7 ); MBEDTLS_PADDING_PKCS7 );
break; break;
default: default:
@ -101,18 +102,18 @@ static psa_status_t cipher_setup(
goto exit; goto exit;
#endif /* MBEDTLS_PSA_BUILTIN_ALG_CBC_NO_PADDING || MBEDTLS_PSA_BUILTIN_ALG_CBC_PKCS7 */ #endif /* MBEDTLS_PSA_BUILTIN_ALG_CBC_NO_PADDING || MBEDTLS_PSA_BUILTIN_ALG_CBC_PKCS7 */
operation->block_size = ( PSA_ALG_IS_STREAM_CIPHER( alg ) ? 1 : mbedtls_ctx->block_size = ( PSA_ALG_IS_STREAM_CIPHER( alg ) ? 1 :
PSA_BLOCK_CIPHER_BLOCK_LENGTH( key_type ) ); PSA_BLOCK_CIPHER_BLOCK_LENGTH( key_type ) );
if( ( alg & PSA_ALG_CIPHER_FROM_BLOCK_FLAG ) != 0 && if( ( alg & PSA_ALG_CIPHER_FROM_BLOCK_FLAG ) != 0 &&
alg != PSA_ALG_ECB_NO_PADDING ) alg != PSA_ALG_ECB_NO_PADDING )
{ {
operation->iv_size = PSA_BLOCK_CIPHER_BLOCK_LENGTH( key_type ); mbedtls_ctx->iv_size = PSA_BLOCK_CIPHER_BLOCK_LENGTH( key_type );
} }
#if defined(MBEDTLS_PSA_BUILTIN_KEY_TYPE_CHACHA20) #if defined(MBEDTLS_PSA_BUILTIN_KEY_TYPE_CHACHA20)
else else
if( ( alg == PSA_ALG_STREAM_CIPHER ) && if( ( alg == PSA_ALG_STREAM_CIPHER ) &&
( key_type == PSA_KEY_TYPE_CHACHA20 ) ) ( key_type == PSA_KEY_TYPE_CHACHA20 ) )
operation->iv_size = 12; mbedtls_ctx->iv_size = 12;
#endif #endif
exit: exit:
@ -146,16 +147,17 @@ psa_status_t mbedtls_psa_cipher_generate_iv(
uint8_t *iv, size_t iv_size, size_t *iv_length ) uint8_t *iv, size_t iv_size, size_t *iv_length )
{ {
int ret = MBEDTLS_ERR_ERROR_CORRUPTION_DETECTED; int ret = MBEDTLS_ERR_ERROR_CORRUPTION_DETECTED;
mbedtls_psa_cipher_operation_t *mbedtls_ctx = &operation->ctx.mbedtls_ctx;
if( iv_size < operation->iv_size ) if( iv_size < mbedtls_ctx->iv_size )
return( PSA_ERROR_BUFFER_TOO_SMALL ); return( PSA_ERROR_BUFFER_TOO_SMALL );
ret = mbedtls_psa_get_random( MBEDTLS_PSA_RANDOM_STATE, ret = mbedtls_psa_get_random( MBEDTLS_PSA_RANDOM_STATE,
iv, operation->iv_size ); iv, mbedtls_ctx->iv_size );
if( ret != 0 ) if( ret != 0 )
return( mbedtls_to_psa_error( ret ) ); return( mbedtls_to_psa_error( ret ) );
*iv_length = operation->iv_size; *iv_length = mbedtls_ctx->iv_size;
return( mbedtls_psa_cipher_set_iv( operation, iv, *iv_length ) ); return( mbedtls_psa_cipher_set_iv( operation, iv, *iv_length ) );
} }
@ -164,11 +166,13 @@ psa_status_t mbedtls_psa_cipher_set_iv( psa_cipher_operation_t *operation,
const uint8_t *iv, const uint8_t *iv,
size_t iv_length ) size_t iv_length )
{ {
if( iv_length != operation->iv_size ) mbedtls_psa_cipher_operation_t *mbedtls_ctx = &operation->ctx.mbedtls_ctx;
if( iv_length != mbedtls_ctx->iv_size )
return( PSA_ERROR_INVALID_ARGUMENT ); return( PSA_ERROR_INVALID_ARGUMENT );
return( mbedtls_to_psa_error( return( mbedtls_to_psa_error(
mbedtls_cipher_set_iv( &operation->ctx.cipher, mbedtls_cipher_set_iv( &mbedtls_ctx->cipher,
iv, iv_length ) ) ); iv, iv_length ) ) );
} }
@ -268,17 +272,18 @@ psa_status_t mbedtls_psa_cipher_update( psa_cipher_operation_t *operation,
size_t *output_length ) size_t *output_length )
{ {
psa_status_t status = PSA_ERROR_CORRUPTION_DETECTED; psa_status_t status = PSA_ERROR_CORRUPTION_DETECTED;
mbedtls_psa_cipher_operation_t *mbedtls_ctx = &operation->ctx.mbedtls_ctx;
size_t expected_output_size; size_t expected_output_size;
if( ! PSA_ALG_IS_STREAM_CIPHER( operation->alg ) ) if( ! PSA_ALG_IS_STREAM_CIPHER( mbedtls_ctx->alg ) )
{ {
/* Take the unprocessed partial block left over from previous /* Take the unprocessed partial block left over from previous
* update calls, if any, plus the input to this call. Remove * update calls, if any, plus the input to this call. Remove
* the last partial block, if any. You get the data that will be * the last partial block, if any. You get the data that will be
* output in this call. */ * output in this call. */
expected_output_size = expected_output_size =
( operation->ctx.cipher.unprocessed_len + input_length ) ( mbedtls_ctx->cipher.unprocessed_len + input_length )
/ operation->block_size * operation->block_size; / mbedtls_ctx->block_size * mbedtls_ctx->block_size;
} }
else else
{ {
@ -288,12 +293,12 @@ psa_status_t mbedtls_psa_cipher_update( psa_cipher_operation_t *operation,
if( output_size < expected_output_size ) if( output_size < expected_output_size )
return( PSA_ERROR_BUFFER_TOO_SMALL ); return( PSA_ERROR_BUFFER_TOO_SMALL );
if( operation->alg == PSA_ALG_ECB_NO_PADDING ) if( mbedtls_ctx->alg == PSA_ALG_ECB_NO_PADDING )
{ {
/* mbedtls_cipher_update has an API inconsistency: it will only /* mbedtls_cipher_update has an API inconsistency: it will only
* process a single block at a time in ECB mode. Abstract away that * process a single block at a time in ECB mode. Abstract away that
* inconsistency here to match the PSA API behaviour. */ * inconsistency here to match the PSA API behaviour. */
status = psa_cipher_update_ecb( &operation->ctx.cipher, status = psa_cipher_update_ecb( &mbedtls_ctx->cipher,
input, input,
input_length, input_length,
output, output,
@ -303,7 +308,7 @@ psa_status_t mbedtls_psa_cipher_update( psa_cipher_operation_t *operation,
else else
{ {
status = mbedtls_to_psa_error( status = mbedtls_to_psa_error(
mbedtls_cipher_update( &operation->ctx.cipher, input, mbedtls_cipher_update( &mbedtls_ctx->cipher, input,
input_length, output, output_length ) ); input_length, output, output_length ) );
} }
@ -316,12 +321,13 @@ psa_status_t mbedtls_psa_cipher_finish( psa_cipher_operation_t *operation,
size_t *output_length ) size_t *output_length )
{ {
psa_status_t status = PSA_ERROR_GENERIC_ERROR; psa_status_t status = PSA_ERROR_GENERIC_ERROR;
mbedtls_psa_cipher_operation_t *mbedtls_ctx = &operation->ctx.mbedtls_ctx;
uint8_t temp_output_buffer[MBEDTLS_MAX_BLOCK_LENGTH]; uint8_t temp_output_buffer[MBEDTLS_MAX_BLOCK_LENGTH];
if( operation->ctx.cipher.unprocessed_len != 0 ) if( mbedtls_ctx->cipher.unprocessed_len != 0 )
{ {
if( operation->alg == PSA_ALG_ECB_NO_PADDING || if( mbedtls_ctx->alg == PSA_ALG_ECB_NO_PADDING ||
operation->alg == PSA_ALG_CBC_NO_PADDING ) mbedtls_ctx->alg == PSA_ALG_CBC_NO_PADDING )
{ {
status = PSA_ERROR_INVALID_ARGUMENT; status = PSA_ERROR_INVALID_ARGUMENT;
goto exit; goto exit;
@ -329,7 +335,7 @@ psa_status_t mbedtls_psa_cipher_finish( psa_cipher_operation_t *operation,
} }
status = mbedtls_to_psa_error( status = mbedtls_to_psa_error(
mbedtls_cipher_finish( &operation->ctx.cipher, mbedtls_cipher_finish( &mbedtls_ctx->cipher,
temp_output_buffer, temp_output_buffer,
output_length ) ); output_length ) );
if( status != PSA_SUCCESS ) if( status != PSA_SUCCESS )
@ -351,7 +357,14 @@ exit:
psa_status_t mbedtls_psa_cipher_abort( psa_cipher_operation_t *operation ) psa_status_t mbedtls_psa_cipher_abort( psa_cipher_operation_t *operation )
{ {
mbedtls_cipher_free( &operation->ctx.cipher ); mbedtls_psa_cipher_operation_t *mbedtls_ctx = &operation->ctx.mbedtls_ctx;
/* Sanity check (shouldn't happen: operation->alg should
* always have been initialized to a valid value). */
if( ! PSA_ALG_IS_CIPHER( mbedtls_ctx->alg ) )
return( PSA_ERROR_BAD_STATE );
mbedtls_cipher_free( &mbedtls_ctx->cipher );
return( PSA_SUCCESS ); return( PSA_SUCCESS );
} }