mirror of
https://github.com/yuzu-emu/mbedtls.git
synced 2024-11-23 03:55:44 +01:00
02c78b7825
Create an include folder dedicated to include files for tests. With the upcoming work on tests for PSA crypto drivers the number of includes specific to tests is going to increase significantly thus create a dedicated folder. Don't put the include files in the include folder but in include/test folder. This way test headers can be included using a test/* path pattern as mbedtls and psa headers are included using an mbedtls/* and psa/* path pattern. This makes explicit the scope of the test headers. Move the existing includes for tests into include/test and update the code and build systems (make and cmake) accordingly. Signed-off-by: Ronald Cron <ronald.cron@arm.com>
227 lines
7.0 KiB
Plaintext
227 lines
7.0 KiB
Plaintext
/* BEGIN_HEADER */
|
|
|
|
/* This test file is specific to the ITS implementation in PSA Crypto
|
|
* on top of stdio. It expects to know what the stdio name of a file is
|
|
* based on its keystore name.
|
|
*/
|
|
|
|
#include "../library/psa_crypto_its.h"
|
|
|
|
#include "test/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;
|
|
size_t ret_len = 0;
|
|
|
|
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, &ret_len ) );
|
|
ASSERT_COMPARE( data->x, data->len, buffer, ret_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;
|
|
size_t ret_len = 0;
|
|
|
|
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, &ret_len ) );
|
|
ASSERT_COMPARE( data1->x, data1->len, buffer, ret_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 );
|
|
ret_len = 0;
|
|
PSA_ASSERT( psa_its_get( uid, 0, data2->len, buffer, &ret_len ) );
|
|
ASSERT_COMPARE( data2->x, data2->len, buffer, ret_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];
|
|
size_t ret_len = 0;
|
|
|
|
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, &ret_len ) );
|
|
ASSERT_COMPARE( retrieved, ret_len,
|
|
stored, sizeof( stored ) );
|
|
PSA_ASSERT( psa_its_remove( uid ) );
|
|
TEST_ASSERT( psa_its_get( uid, 0, 0, NULL, 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, 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;
|
|
size_t ret_len = 0;
|
|
|
|
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, &ret_len );
|
|
TEST_ASSERT( status == (psa_status_t) expected_status );
|
|
if( status == PSA_SUCCESS )
|
|
ASSERT_COMPARE( data->x + offset, (size_t) length_arg,
|
|
buffer, ret_len );
|
|
for( i = 0; i < 16; i++ )
|
|
TEST_ASSERT( trailer[i] == '-' );
|
|
PSA_ASSERT( psa_its_remove( uid ) );
|
|
|
|
exit:
|
|
mbedtls_free( buffer );
|
|
cleanup( );
|
|
}
|
|
/* END_CASE */
|