crypto_se_driver: restructure tests to use mocking

Mock key importing and exporting

Author: AndrzejKurek

tests/suites/test_suite_psa_crypto_se_driver_hal.data

@@ -27,11 +27,8 @@ register_twice:3
 Register SE driver: maximum number of drivers
 register_max:
 
-Key creation smoke test (no p_allocate)
-key_creation_import_export:-1
+Key importing mock test
+mock_import:
 
-Key creation smoke test (p_allocate allows all slots)
-key_creation_import_export:0
-
-Key creation smoke test (p_allocate allows 1 slot)
-key_creation_import_export:ARRAY_LENGTH( mock_slots ) - 1
+Key exporting mock test
+mock_export:

tests/suites/test_suite_psa_crypto_se_driver_hal.function

@@ -11,22 +11,41 @@
  * This is probably a bug in the library. */
 #define PSA_ERROR_DETECTED_BY_DRIVER ((psa_status_t)( -500 ))
 
-#define MOCK_MAX_KEY_SIZE 64
-typedef struct
+static struct
 {
+    uint16_t called;
+    psa_key_slot_number_t slot_number;
     psa_key_lifetime_t lifetime;
     psa_key_type_t type;
-    size_t bits;
-    uint8_t content[MOCK_MAX_KEY_SIZE];
-} mock_slot_t;
-static mock_slot_t mock_slots[16];
+    psa_algorithm_t algorithm;
+    psa_key_usage_t usage;
+    size_t data_length;
+} mock_import_data;
 
-static uint8_t mock_min_slot = 0;
+static struct
+{
+    uint16_t called;
+    psa_key_slot_number_t slot_number;
+    size_t data_size;
+} mock_export_data;
+
+static struct
+{
+    uint16_t called;
+} mock_allocate_data;
 
-static void mock_slots_reset( void )
+static struct
 {
-    memset( mock_slots, 0, sizeof( mock_slots ) );
-    mock_min_slot = 0;
+    uint16_t called;
+    psa_key_slot_number_t slot_number;
+} mock_destroy_data;
+
+static void mock_teardown( void )
+{
+    memset( &mock_import_data, 0, sizeof( mock_import_data ) );
+    memset( &mock_export_data, 0, sizeof( mock_export_data ) );
+    memset( &mock_allocate_data, 0, sizeof( mock_allocate_data ) );
+    memset( &mock_destroy_data, 0, sizeof( mock_destroy_data ) );
 }
 
 static psa_status_t mock_import( psa_key_slot_number_t slot_number,
@@ -37,16 +56,14 @@ static psa_status_t mock_import( psa_key_slot_number_t slot_number,
                                 const uint8_t *p_data,
                                 size_t data_length )
 {
-    if( slot_number > ARRAY_LENGTH( mock_slots ) )
-        return( PSA_ERROR_DETECTED_BY_DRIVER );
-    if( data_length > sizeof( mock_slots[slot_number].content ) )
-        return( PSA_ERROR_INSUFFICIENT_STORAGE );
-    mock_slots[slot_number].lifetime = lifetime;
-    mock_slots[slot_number].type = type;
-    mock_slots[slot_number].bits = PSA_BYTES_TO_BITS( data_length );
-    (void) algorithm;
-    (void) usage;
-    memcpy( mock_slots[slot_number].content, p_data, data_length );
+    (void) p_data;
+    mock_import_data.called++;
+    mock_import_data.slot_number = slot_number;
+    mock_import_data.lifetime = lifetime;
+    mock_import_data.type = type;
+    mock_import_data.algorithm = algorithm;
+    mock_import_data.usage = usage;
+    mock_import_data.data_length = data_length;
     return( PSA_SUCCESS );
 }
 
@@ -55,22 +72,11 @@ psa_status_t mock_export( psa_key_slot_number_t slot_number,
                          size_t data_size,
                          size_t *p_data_length )
 {
-    size_t actual_size;
-    if( slot_number > ARRAY_LENGTH( mock_slots ) )
-        return( PSA_ERROR_DETECTED_BY_DRIVER );
-    actual_size = PSA_BITS_TO_BYTES( mock_slots[slot_number].bits );
-    if( actual_size > data_size )
-        return( PSA_ERROR_BUFFER_TOO_SMALL );
-    *p_data_length = actual_size;
-    memcpy( p_data, mock_slots[slot_number].content, actual_size );
-    return( PSA_SUCCESS );
-}
-
-psa_status_t mock_destroy( psa_key_slot_number_t slot_number )
-{
-    if( slot_number > ARRAY_LENGTH( mock_slots ) )
-        return( PSA_ERROR_DETECTED_BY_DRIVER );
-    memset( &mock_slots[slot_number], 0, sizeof( mock_slots[slot_number] ) );
+    (void) p_data;
+    (void) p_data_length;
+    mock_export_data.called++;
+    mock_export_data.slot_number = slot_number;
+    mock_export_data.data_size = data_size;
     return( PSA_SUCCESS );
 }
 
@@ -79,9 +85,18 @@ psa_status_t mock_allocate( const psa_key_attributes_t *attributes,
                            psa_key_slot_number_t *slot_number )
 {
     (void) attributes;
-    return( psa_drv_cb_find_free_slot( slot_usage,
-                                       mock_min_slot, -1,
-                                       slot_number ) );
+    (void) slot_usage;
+    (void) slot_number;
+    mock_allocate_data.called++;
+    *slot_number = 0;
+    return( PSA_SUCCESS );
+}
+
+psa_status_t mock_destroy( psa_key_slot_number_t slot_number )
+{
+    mock_destroy_data.called++;
+    mock_destroy_data.slot_number = slot_number;
+    return( PSA_SUCCESS );
 }
 
 /* END_HEADER */
@@ -157,7 +172,52 @@ exit:
 /* END_CASE */
 
 /* BEGIN_CASE */
-void key_creation_import_export( int min_slot )
+void mock_import( )
+{
+    psa_drv_se_t driver;
+    psa_drv_se_key_management_t key_management;
+    psa_key_lifetime_t lifetime = 2;
+    psa_key_id_t id = 1;
+    psa_key_handle_t handle = 0;
+    psa_key_attributes_t attributes = PSA_KEY_ATTRIBUTES_INIT;
+    const uint8_t key_material[3] = {0xfa, 0xca, 0xde};
+
+    memset( &driver, 0, sizeof( driver ) );
+    memset( &key_management, 0, sizeof( key_management ) );
+    driver.hal_version = PSA_DRV_SE_HAL_VERSION;
+    driver.key_management = &key_management;
+    key_management.slot_count = 1;
+    key_management.p_import = mock_import;
+    key_management.p_destroy = mock_destroy;
+    key_management.p_allocate = mock_allocate;
+
+    PSA_ASSERT( psa_register_se_driver( lifetime, &driver ) );
+    PSA_ASSERT( psa_crypto_init( ) );
+
+    psa_set_key_id( &attributes, id );
+    psa_set_key_lifetime( &attributes, lifetime );
+    psa_set_key_usage_flags( &attributes, PSA_KEY_USAGE_EXPORT );
+    psa_set_key_type( &attributes, PSA_KEY_TYPE_RAW_DATA );
+    PSA_ASSERT( psa_import_key( &attributes,
+                                key_material, sizeof( key_material ),
+                                &handle ) );
+
+    TEST_ASSERT( mock_allocate_data.called == 1 );
+    TEST_ASSERT( mock_import_data.called == 1 );
+    TEST_ASSERT( mock_import_data.type == PSA_KEY_TYPE_RAW_DATA);
+
+    PSA_ASSERT( psa_destroy_key( handle ) );
+
+    TEST_ASSERT( mock_destroy_data.called == 1 );
+
+exit:
+    PSA_DONE( );
+    mock_teardown( );
+}
+/* END_CASE */
+
+/* BEGIN_CASE */
+void mock_export( )
 {
     psa_drv_se_t driver;
     psa_drv_se_key_management_t key_management;
@@ -168,21 +228,16 @@ void key_creation_import_export( int min_slot )
     const uint8_t key_material[3] = {0xfa, 0xca, 0xde};
     uint8_t exported[sizeof( key_material )];
     size_t exported_length;
-    psa_key_slot_number_t expected_slot = ( min_slot >= 0 ? min_slot : 0 );
 
     memset( &driver, 0, sizeof( driver ) );
     memset( &key_management, 0, sizeof( key_management ) );
     driver.hal_version = PSA_DRV_SE_HAL_VERSION;
     driver.key_management = &key_management;
-    key_management.slot_count = ARRAY_LENGTH( mock_slots );
+    key_management.slot_count = 1;
     key_management.p_import = mock_import;
     key_management.p_export = mock_export;
     key_management.p_destroy = mock_destroy;
-    if( min_slot >= 0 )
-    {
-        key_management.p_allocate = mock_allocate;
-        mock_min_slot = min_slot;
-    }
+    key_management.p_allocate = mock_allocate;
 
     PSA_ASSERT( psa_register_se_driver( lifetime, &driver ) );
     PSA_ASSERT( psa_crypto_init( ) );
@@ -195,22 +250,18 @@ void key_creation_import_export( int min_slot )
                                 key_material, sizeof( key_material ),
                                 &handle ) );
 
-    /* Test that the key was created in the designated slot. */
-    TEST_ASSERT( mock_slots[expected_slot].type == PSA_KEY_TYPE_RAW_DATA );
-
     PSA_ASSERT( psa_export_key( handle,
                                 exported, sizeof( exported ),
                                 &exported_length ) );
-    ASSERT_COMPARE( key_material, sizeof( key_material ),
-                    exported, exported_length );
-
+    
+    TEST_ASSERT( mock_export_data.called == 1 );
+    
     PSA_ASSERT( psa_destroy_key( handle ) );
 
-    /* Test that the key has been erased from the designated slot. */
-    TEST_ASSERT( mock_slots[expected_slot].type == 0 );
+    TEST_ASSERT( mock_destroy_data.called == 1 );
 
 exit:
     PSA_DONE( );
-    mock_slots_reset( );
+    mock_teardown( ); 
 }
 /* END_CASE */