mirror of
https://github.com/yuzu-emu/mbedtls.git
synced 2024-12-12 03:34:23 +01:00
3cff768ad4
Create a new header file psa_helpers.h and put the one helper macro that isn't specific to PSA crypto there. Use this header file in the ITS test suite.
216 lines
6.7 KiB
Plaintext
216 lines
6.7 KiB
Plaintext
/* BEGIN_HEADER */
|
|
#include "../library/psa_crypto_its.h"
|
|
|
|
#include "psa_helpers.h"
|
|
|
|
/* Internal definitions of the implementation, copied for the sake of
|
|
* some of the tests and of the cleanup code. */
|
|
#define PSA_ITS_STORAGE_PREFIX ""
|
|
#define PSA_ITS_STORAGE_FILENAME_PATTERN "%08lx%08lx"
|
|
#define PSA_ITS_STORAGE_SUFFIX ".psa_its"
|
|
#define PSA_ITS_STORAGE_FILENAME_LENGTH \
|
|
( sizeof( PSA_ITS_STORAGE_PREFIX ) - 1 + /*prefix without terminating 0*/ \
|
|
16 + /*UID (64-bit number in hex)*/ \
|
|
sizeof( PSA_ITS_STORAGE_SUFFIX ) - 1 + /*suffix without terminating 0*/ \
|
|
1 /*terminating null byte*/ )
|
|
#define PSA_ITS_STORAGE_TEMP \
|
|
PSA_ITS_STORAGE_PREFIX "tempfile" PSA_ITS_STORAGE_SUFFIX
|
|
static void psa_its_fill_filename( psa_storage_uid_t uid, char *filename )
|
|
{
|
|
/* Break up the UID into two 32-bit pieces so as not to rely on
|
|
* long long support in snprintf. */
|
|
mbedtls_snprintf( filename, PSA_ITS_STORAGE_FILENAME_LENGTH,
|
|
"%s" PSA_ITS_STORAGE_FILENAME_PATTERN "%s",
|
|
PSA_ITS_STORAGE_PREFIX,
|
|
(unsigned long) ( uid >> 32 ),
|
|
(unsigned long) ( uid & 0xffffffff ),
|
|
PSA_ITS_STORAGE_SUFFIX );
|
|
}
|
|
|
|
/* Maximum uid used by the test, recorded so that cleanup() can delete
|
|
* all files. 0xffffffffffffffff is always cleaned up, so it does not
|
|
* need to and should not be taken into account for uid_max. */
|
|
static psa_storage_uid_t uid_max = 0;
|
|
|
|
static void cleanup( void )
|
|
{
|
|
char filename[PSA_ITS_STORAGE_FILENAME_LENGTH];
|
|
psa_storage_uid_t uid;
|
|
for( uid = 0; uid < uid_max; uid++ )
|
|
{
|
|
psa_its_fill_filename( uid, filename );
|
|
remove( filename );
|
|
}
|
|
psa_its_fill_filename( (psa_storage_uid_t)( -1 ), filename );
|
|
remove( filename );
|
|
remove( PSA_ITS_STORAGE_TEMP );
|
|
uid_max = 0;
|
|
}
|
|
|
|
static psa_status_t psa_its_set_wrap( psa_storage_uid_t uid,
|
|
uint32_t data_length,
|
|
const void *p_data,
|
|
psa_storage_create_flags_t create_flags )
|
|
{
|
|
if( uid_max != (psa_storage_uid_t)( -1 ) && uid_max < uid )
|
|
uid_max = uid;
|
|
return( psa_its_set( uid, data_length, p_data, create_flags ) );
|
|
}
|
|
|
|
/* END_HEADER */
|
|
|
|
/* BEGIN_DEPENDENCIES
|
|
* depends_on:MBEDTLS_PSA_ITS_FILE_C
|
|
* END_DEPENDENCIES
|
|
*/
|
|
|
|
/* BEGIN_CASE */
|
|
void set_get_remove( int uid_arg, int flags_arg, data_t *data )
|
|
{
|
|
psa_storage_uid_t uid = uid_arg;
|
|
uint32_t flags = flags_arg;
|
|
struct psa_storage_info_t info;
|
|
unsigned char *buffer = NULL;
|
|
|
|
ASSERT_ALLOC( buffer, data->len );
|
|
|
|
PSA_ASSERT( psa_its_set_wrap( uid, data->len, data->x, flags ) );
|
|
|
|
PSA_ASSERT( psa_its_get_info( uid, &info ) );
|
|
TEST_ASSERT( info.size == data->len );
|
|
TEST_ASSERT( info.flags == flags );
|
|
PSA_ASSERT( psa_its_get( uid, 0, data->len, buffer ) );
|
|
ASSERT_COMPARE( data->x, data->len, buffer, data->len );
|
|
|
|
PSA_ASSERT( psa_its_remove( uid ) );
|
|
|
|
exit:
|
|
mbedtls_free( buffer );
|
|
cleanup( );
|
|
}
|
|
/* END_CASE */
|
|
|
|
/* BEGIN_CASE */
|
|
void set_overwrite( int uid_arg,
|
|
int flags1_arg, data_t *data1,
|
|
int flags2_arg, data_t *data2 )
|
|
{
|
|
psa_storage_uid_t uid = uid_arg;
|
|
uint32_t flags1 = flags1_arg;
|
|
uint32_t flags2 = flags2_arg;
|
|
struct psa_storage_info_t info;
|
|
unsigned char *buffer = NULL;
|
|
|
|
ASSERT_ALLOC( buffer, MAX( data1->len, data2->len ) );
|
|
|
|
PSA_ASSERT( psa_its_set_wrap( uid, data1->len, data1->x, flags1 ) );
|
|
PSA_ASSERT( psa_its_get_info( uid, &info ) );
|
|
TEST_ASSERT( info.size == data1->len );
|
|
TEST_ASSERT( info.flags == flags1 );
|
|
PSA_ASSERT( psa_its_get( uid, 0, data1->len, buffer ) );
|
|
ASSERT_COMPARE( data1->x, data1->len, buffer, data1->len );
|
|
|
|
PSA_ASSERT( psa_its_set_wrap( uid, data2->len, data2->x, flags2 ) );
|
|
PSA_ASSERT( psa_its_get_info( uid, &info ) );
|
|
TEST_ASSERT( info.size == data2->len );
|
|
TEST_ASSERT( info.flags == flags2 );
|
|
PSA_ASSERT( psa_its_get( uid, 0, data2->len, buffer ) );
|
|
ASSERT_COMPARE( data2->x, data2->len, buffer, data2->len );
|
|
|
|
PSA_ASSERT( psa_its_remove( uid ) );
|
|
|
|
exit:
|
|
mbedtls_free( buffer );
|
|
cleanup( );
|
|
}
|
|
/* END_CASE */
|
|
|
|
/* BEGIN_CASE */
|
|
void set_multiple( int first_id, int count )
|
|
{
|
|
psa_storage_uid_t uid0 = first_id;
|
|
psa_storage_uid_t uid;
|
|
char stored[40];
|
|
char retrieved[40];
|
|
|
|
memset( stored, '.', sizeof( stored ) );
|
|
for( uid = uid0; uid < uid0 + count; uid++ )
|
|
{
|
|
mbedtls_snprintf( stored, sizeof( stored ),
|
|
"Content of file 0x%08lx", (unsigned long) uid );
|
|
PSA_ASSERT( psa_its_set_wrap( uid, sizeof( stored ), stored, 0 ) );
|
|
}
|
|
|
|
for( uid = uid0; uid < uid0 + count; uid++ )
|
|
{
|
|
mbedtls_snprintf( stored, sizeof( stored ),
|
|
"Content of file 0x%08lx", (unsigned long) uid );
|
|
PSA_ASSERT( psa_its_get( uid, 0, sizeof( stored ), retrieved ) );
|
|
ASSERT_COMPARE( retrieved, sizeof( stored ),
|
|
stored, sizeof( stored ) );
|
|
PSA_ASSERT( psa_its_remove( uid ) );
|
|
TEST_ASSERT( psa_its_get( uid, 0, 0, NULL ) ==
|
|
PSA_ERROR_DOES_NOT_EXIST );
|
|
}
|
|
|
|
exit:
|
|
cleanup( );
|
|
}
|
|
/* END_CASE */
|
|
|
|
/* BEGIN_CASE */
|
|
void nonexistent( int uid_arg, int create_and_remove )
|
|
{
|
|
psa_storage_uid_t uid = uid_arg;
|
|
struct psa_storage_info_t info;
|
|
|
|
if( create_and_remove )
|
|
{
|
|
PSA_ASSERT( psa_its_set_wrap( uid, 0, NULL, 0 ) );
|
|
PSA_ASSERT( psa_its_remove( uid ) );
|
|
}
|
|
|
|
TEST_ASSERT( psa_its_remove( uid ) == PSA_ERROR_DOES_NOT_EXIST );
|
|
TEST_ASSERT( psa_its_get_info( uid, &info ) ==
|
|
PSA_ERROR_DOES_NOT_EXIST );
|
|
TEST_ASSERT( psa_its_get( uid, 0, 0, NULL ) ==
|
|
PSA_ERROR_DOES_NOT_EXIST );
|
|
|
|
exit:
|
|
cleanup( );
|
|
}
|
|
/* END_CASE */
|
|
|
|
/* BEGIN_CASE */
|
|
void get_at( int uid_arg, data_t *data,
|
|
int offset, int length_arg,
|
|
int expected_status )
|
|
{
|
|
psa_storage_uid_t uid = uid_arg;
|
|
unsigned char *buffer = NULL;
|
|
psa_status_t status;
|
|
size_t length = length_arg >= 0 ? length_arg : 0;
|
|
unsigned char *trailer;
|
|
size_t i;
|
|
|
|
ASSERT_ALLOC( buffer, length + 16 );
|
|
trailer = buffer + length;
|
|
memset( trailer, '-', 16 );
|
|
|
|
PSA_ASSERT( psa_its_set_wrap( uid, data->len, data->x, 0 ) );
|
|
|
|
status = psa_its_get( uid, offset, length_arg, buffer );
|
|
TEST_ASSERT( status == (psa_status_t) expected_status );
|
|
if( status == PSA_SUCCESS )
|
|
ASSERT_COMPARE( data->x + offset, length,
|
|
buffer, length );
|
|
for( i = 0; i < 16; i++ )
|
|
TEST_ASSERT( trailer[i] == '-' );
|
|
PSA_ASSERT( psa_its_remove( uid ) );
|
|
|
|
exit:
|
|
mbedtls_free( buffer );
|
|
cleanup( );
|
|
}
|
|
/* END_CASE */
|