1/* BEGIN_HEADER */
2#include "psa/crypto_se_driver.h"
3
4#include "psa_crypto_se.h"
5#include "psa_crypto_storage.h"
6
7/** The location and lifetime used for tests that use a single driver. */
8#define TEST_DRIVER_LOCATION 1
9#define TEST_SE_PERSISTENT_LIFETIME                             \
10    ( PSA_KEY_LIFETIME_FROM_PERSISTENCE_AND_LOCATION(           \
11        PSA_KEY_PERSISTENCE_DEFAULT, TEST_DRIVER_LOCATION ) )
12
13static struct
14{
15    uint16_t called;
16    psa_key_location_t location;
17    psa_status_t return_value;
18} mock_init_data;
19
20static struct
21{
22    uint16_t called;
23    psa_key_slot_number_t key_slot;
24    psa_key_attributes_t attributes;
25    size_t pubkey_size;
26    psa_status_t return_value;
27} mock_generate_data;
28
29static struct
30{
31    uint16_t called;
32    psa_key_slot_number_t key_slot;
33    psa_key_attributes_t attributes;
34    size_t bits;
35    size_t data_length;
36    psa_status_t return_value;
37} mock_import_data;
38
39static struct
40{
41    uint16_t called;
42    psa_key_slot_number_t slot_number;
43    size_t data_size;
44    psa_status_t return_value;
45} mock_export_data;
46
47static struct
48{
49    uint16_t called;
50    psa_key_slot_number_t slot_number;
51    size_t data_size;
52    psa_status_t return_value;
53} mock_export_public_data;
54
55static struct
56{
57    uint16_t called;
58    psa_key_slot_number_t key_slot;
59    psa_algorithm_t alg;
60    size_t hash_length;
61    size_t signature_size;
62    psa_status_t return_value;
63} mock_sign_data;
64
65static struct
66{
67    uint16_t called;
68    psa_key_slot_number_t key_slot;
69    psa_algorithm_t alg;
70    size_t hash_length;
71    size_t signature_length;
72    psa_status_t return_value;
73} mock_verify_data;
74
75static struct
76{
77    uint16_t called;
78    psa_status_t return_value;
79} mock_allocate_data;
80
81static struct
82{
83    uint16_t called;
84    psa_key_slot_number_t slot_number;
85    psa_status_t return_value;
86} mock_destroy_data;
87
88#define MAX_KEY_ID_FOR_TEST 10
89static void psa_purge_storage( void )
90{
91    psa_key_id_t id;
92    psa_key_location_t location;
93
94    /* The tests may have potentially created key ids from 1 to
95     * MAX_KEY_ID_FOR_TEST. In addition, run the destroy function on key id
96     * 0, which file-based storage uses as a temporary file. */
97    for( id = 0; id <= MAX_KEY_ID_FOR_TEST; id++ )
98        psa_destroy_persistent_key( mbedtls_svc_key_id_make( 1, id ) );
99
100    /* Purge the transaction file. */
101    psa_crypto_stop_transaction( );
102    /* Purge driver persistent data. */
103    for( location = 0; location < PSA_MAX_SE_LOCATION; location++ )
104        psa_destroy_se_persistent_data( location );
105}
106
107static void mock_teardown( void )
108{
109    memset( &mock_init_data, 0, sizeof( mock_init_data ) );
110    memset( &mock_import_data, 0, sizeof( mock_import_data ) );
111    memset( &mock_export_data, 0, sizeof( mock_export_data ) );
112    memset( &mock_export_public_data, 0, sizeof( mock_export_public_data ) );
113    memset( &mock_sign_data, 0, sizeof( mock_sign_data ) );
114    memset( &mock_verify_data, 0, sizeof( mock_verify_data ) );
115    memset( &mock_allocate_data, 0, sizeof( mock_allocate_data ) );
116    memset( &mock_destroy_data, 0, sizeof( mock_destroy_data ) );
117    memset( &mock_generate_data, 0, sizeof( mock_generate_data ) );
118    psa_purge_storage( );
119}
120
121static psa_status_t mock_init( psa_drv_se_context_t *drv_context,
122                               void *persistent_data,
123                               psa_key_location_t location )
124{
125    (void) drv_context;
126    (void) persistent_data;
127
128    mock_init_data.called++;
129    mock_init_data.location = location;
130    return( mock_init_data.return_value );
131}
132
133static psa_status_t mock_generate( psa_drv_se_context_t *drv_context,
134                                   psa_key_slot_number_t key_slot,
135                                   const psa_key_attributes_t *attributes,
136                                   uint8_t *pubkey,
137                                   size_t pubkey_size,
138                                   size_t *pubkey_length )
139{
140    (void) drv_context;
141    (void) pubkey;
142    (void) pubkey_length;
143
144    mock_generate_data.called++;
145    mock_generate_data.key_slot = key_slot;
146    mock_generate_data.attributes = *attributes;
147    mock_generate_data.pubkey_size = pubkey_size;
148
149    return( mock_generate_data.return_value );
150}
151
152static psa_status_t mock_import( psa_drv_se_context_t *drv_context,
153                                 psa_key_slot_number_t key_slot,
154                                 const psa_key_attributes_t *attributes,
155                                 const uint8_t *data,
156                                 size_t data_length,
157                                 size_t *bits )
158{
159    (void) drv_context;
160    (void) data;
161
162    *bits = mock_import_data.bits;
163
164    mock_import_data.called++;
165    mock_import_data.key_slot = key_slot;
166    mock_import_data.attributes = *attributes;
167    mock_import_data.data_length = data_length;
168
169    return( mock_import_data.return_value );
170}
171
172psa_status_t mock_export( psa_drv_se_context_t *context,
173                          psa_key_slot_number_t slot_number,
174                          uint8_t *p_data,
175                          size_t data_size,
176                          size_t *p_data_length )
177{
178    (void) context;
179    (void) p_data;
180    (void) p_data_length;
181
182    mock_export_data.called++;
183    mock_export_data.slot_number = slot_number;
184    mock_export_data.data_size = data_size;
185
186    return( mock_export_data.return_value );
187}
188
189psa_status_t mock_export_public( psa_drv_se_context_t *context,
190                                 psa_key_slot_number_t slot_number,
191                                 uint8_t *p_data,
192                                 size_t data_size,
193                                 size_t *p_data_length )
194{
195    (void) context;
196    (void) p_data;
197    (void) p_data_length;
198
199    mock_export_public_data.called++;
200    mock_export_public_data.slot_number = slot_number;
201    mock_export_public_data.data_size = data_size;
202
203    return( mock_export_public_data.return_value );
204}
205
206psa_status_t mock_sign( psa_drv_se_context_t *context,
207                        psa_key_slot_number_t key_slot,
208                        psa_algorithm_t alg,
209                        const uint8_t *p_hash,
210                        size_t hash_length,
211                        uint8_t *p_signature,
212                        size_t signature_size,
213                        size_t *p_signature_length )
214{
215    (void) context;
216    (void) p_hash;
217    (void) p_signature;
218    (void) p_signature_length;
219
220    mock_sign_data.called++;
221    mock_sign_data.key_slot = key_slot;
222    mock_sign_data.alg = alg;
223    mock_sign_data.hash_length = hash_length;
224    mock_sign_data.signature_size = signature_size;
225
226    return mock_sign_data.return_value;
227}
228
229psa_status_t mock_verify( psa_drv_se_context_t *context,
230                          psa_key_slot_number_t key_slot,
231                          psa_algorithm_t alg,
232                          const uint8_t *p_hash,
233                          size_t hash_length,
234                          const uint8_t *p_signature,
235                          size_t signature_length )
236{
237    (void) context;
238    (void) p_hash;
239    (void) p_signature;
240
241    mock_verify_data.called++;
242    mock_verify_data.key_slot = key_slot;
243    mock_verify_data.alg = alg;
244    mock_verify_data.hash_length = hash_length;
245    mock_verify_data.signature_length = signature_length;
246
247    return mock_verify_data.return_value;
248}
249
250psa_status_t mock_allocate( psa_drv_se_context_t *drv_context,
251                            void *persistent_data,
252                            const psa_key_attributes_t *attributes,
253                            psa_key_creation_method_t method,
254                            psa_key_slot_number_t *key_slot )
255{
256    (void) drv_context;
257    (void) persistent_data;
258    (void) attributes;
259    (void) method;
260    (void) key_slot;
261
262    mock_allocate_data.called++;
263    *key_slot = 0;
264
265    return( mock_allocate_data.return_value );
266}
267
268psa_status_t mock_destroy( psa_drv_se_context_t *context,
269                           void *persistent_data,
270                           psa_key_slot_number_t slot_number )
271{
272    (void) context;
273    (void) persistent_data;
274
275    mock_destroy_data.called++;
276    mock_destroy_data.slot_number = slot_number;
277
278    return( mock_destroy_data.return_value );
279}
280
281/* END_HEADER */
282
283/* BEGIN_DEPENDENCIES
284 * depends_on:MBEDTLS_PSA_CRYPTO_SE_C
285 * END_DEPENDENCIES
286 */
287
288/* BEGIN_CASE */
289void mock_init( int location_arg,
290                int expected_register_status_arg,
291                int driver_status_arg,
292                int expected_psa_status_arg,
293                int expected_called )
294{
295    psa_key_location_t location = location_arg;
296    psa_status_t expected_register_status = expected_register_status_arg;
297    psa_status_t driver_status = driver_status_arg;
298    psa_status_t expected_psa_status = expected_psa_status_arg;
299    psa_drv_se_t driver = {
300        .hal_version = PSA_DRV_SE_HAL_VERSION,
301        .p_init = mock_init,
302    };
303    int psa_crypto_init_called = 0;
304
305    mock_init_data.return_value = driver_status;
306
307    TEST_EQUAL( psa_register_se_driver( location, &driver ),
308                expected_register_status );
309
310    psa_crypto_init_called = 1;
311    TEST_EQUAL( psa_crypto_init( ), expected_psa_status );
312
313    TEST_EQUAL( mock_init_data.called, expected_called );
314    if( expected_called )
315        TEST_EQUAL( mock_init_data.location, location );
316
317exit:
318    if( psa_crypto_init_called )
319        PSA_DONE( );
320    mock_teardown( );
321}
322/* END_CASE */
323
324/* BEGIN_CASE */
325void mock_import( int mock_alloc_return_value,
326                  int mock_import_return_value,
327                  int bits,
328                  int expected_result )
329{
330    psa_drv_se_t driver;
331    psa_drv_se_key_management_t key_management;
332    psa_key_lifetime_t lifetime = TEST_SE_PERSISTENT_LIFETIME;
333    psa_key_location_t location = PSA_KEY_LIFETIME_GET_LOCATION( lifetime );
334    mbedtls_svc_key_id_t id = mbedtls_svc_key_id_make( 1, 1 );
335    mbedtls_svc_key_id_t returned_id;
336    psa_key_attributes_t attributes = PSA_KEY_ATTRIBUTES_INIT;
337    const uint8_t key_material[3] = {0xfa, 0xca, 0xde};
338
339    mock_allocate_data.return_value = mock_alloc_return_value;
340    mock_import_data.return_value = mock_import_return_value;
341    mock_import_data.bits = bits;
342    memset( &driver, 0, sizeof( driver ) );
343    memset( &key_management, 0, sizeof( key_management ) );
344    driver.hal_version = PSA_DRV_SE_HAL_VERSION;
345    driver.key_management = &key_management;
346    key_management.p_import = mock_import;
347    key_management.p_destroy = mock_destroy;
348    key_management.p_allocate = mock_allocate;
349
350    PSA_ASSERT( psa_register_se_driver( location, &driver ) );
351    PSA_ASSERT( psa_crypto_init( ) );
352
353    psa_set_key_id( &attributes, id );
354    psa_set_key_lifetime( &attributes, lifetime );
355    psa_set_key_usage_flags( &attributes, PSA_KEY_USAGE_EXPORT );
356    psa_set_key_type( &attributes, PSA_KEY_TYPE_RAW_DATA );
357    TEST_ASSERT( psa_import_key( &attributes,
358                                 key_material, sizeof( key_material ),
359                                 &returned_id ) == expected_result );
360
361    TEST_ASSERT( mock_allocate_data.called == 1 );
362    TEST_ASSERT( mock_import_data.called ==
363        ( mock_alloc_return_value == PSA_SUCCESS? 1 : 0 ) );
364
365    if( mock_alloc_return_value == PSA_SUCCESS )
366    {
367        TEST_ASSERT( mbedtls_svc_key_id_equal(
368                         mock_import_data.attributes.core.id, id ) );
369    }
370    else
371    {
372        TEST_ASSERT( MBEDTLS_SVC_KEY_ID_GET_KEY_ID(
373                         mock_import_data.attributes.core.id ) == 0 );
374        TEST_ASSERT( MBEDTLS_SVC_KEY_ID_GET_OWNER_ID(
375                         mock_import_data.attributes.core.id ) == 0 );
376    }
377
378    TEST_ASSERT( mock_import_data.attributes.core.lifetime ==
379        ( mock_alloc_return_value == PSA_SUCCESS? lifetime : 0 ) );
380    TEST_ASSERT( mock_import_data.attributes.core.policy.usage ==
381        ( mock_alloc_return_value == PSA_SUCCESS? PSA_KEY_USAGE_EXPORT : 0 ) );
382    TEST_ASSERT( mock_import_data.attributes.core.type ==
383        ( mock_alloc_return_value == PSA_SUCCESS? PSA_KEY_TYPE_RAW_DATA : 0 ) );
384
385    if( expected_result == PSA_SUCCESS )
386    {
387        PSA_ASSERT( psa_destroy_key( id ) );
388        TEST_ASSERT( mock_destroy_data.called == 1 );
389    }
390exit:
391    PSA_DONE( );
392    mock_teardown( );
393}
394/* END_CASE */
395
396/* BEGIN_CASE */
397void mock_export( int mock_export_return_value, int expected_result )
398{
399    psa_drv_se_t driver;
400    psa_drv_se_key_management_t key_management;
401    psa_key_lifetime_t lifetime = TEST_SE_PERSISTENT_LIFETIME;
402    psa_key_location_t location = PSA_KEY_LIFETIME_GET_LOCATION( lifetime );
403    mbedtls_svc_key_id_t id = mbedtls_svc_key_id_make( 1, 1 );
404    mbedtls_svc_key_id_t returned_id;
405    psa_key_attributes_t attributes = PSA_KEY_ATTRIBUTES_INIT;
406    const uint8_t key_material[3] = {0xfa, 0xca, 0xde};
407    uint8_t exported[sizeof( key_material )];
408    size_t exported_length;
409
410    mock_export_data.return_value = mock_export_return_value;
411    memset( &driver, 0, sizeof( driver ) );
412    memset( &key_management, 0, sizeof( key_management ) );
413    driver.hal_version = PSA_DRV_SE_HAL_VERSION;
414    driver.key_management = &key_management;
415    driver.p_init = mock_init;
416    key_management.p_import = mock_import;
417    key_management.p_export = mock_export;
418    key_management.p_destroy = mock_destroy;
419    key_management.p_allocate = mock_allocate;
420
421    PSA_ASSERT( psa_register_se_driver( location, &driver ) );
422    PSA_ASSERT( psa_crypto_init( ) );
423
424    psa_set_key_id( &attributes, id );
425    psa_set_key_lifetime( &attributes, lifetime );
426    psa_set_key_usage_flags( &attributes, PSA_KEY_USAGE_EXPORT );
427    psa_set_key_type( &attributes, PSA_KEY_TYPE_RAW_DATA );
428    PSA_ASSERT( psa_import_key( &attributes,
429                                key_material, sizeof( key_material ),
430                                &returned_id ) );
431
432    TEST_ASSERT( psa_export_key( id,
433                                 exported, sizeof( exported ),
434                                 &exported_length ) == expected_result );
435
436    TEST_ASSERT( mock_export_data.called == 1 );
437
438    PSA_ASSERT( psa_destroy_key( id ) );
439
440    TEST_ASSERT( mock_destroy_data.called == 1 );
441
442exit:
443    PSA_DONE( );
444    mock_teardown( );
445}
446/* END_CASE */
447
448/* BEGIN_CASE */
449void mock_generate( int mock_alloc_return_value,
450                    int mock_generate_return_value,
451                    int expected_result )
452{
453    psa_drv_se_t driver;
454    psa_drv_se_key_management_t key_management;
455    psa_key_lifetime_t lifetime = TEST_SE_PERSISTENT_LIFETIME;
456    psa_key_location_t location = PSA_KEY_LIFETIME_GET_LOCATION( lifetime );
457    mbedtls_svc_key_id_t id = mbedtls_svc_key_id_make( 1, 1 );
458    mbedtls_svc_key_id_t returned_id;
459    psa_key_attributes_t attributes = PSA_KEY_ATTRIBUTES_INIT;
460
461    mock_allocate_data.return_value = mock_alloc_return_value;
462    mock_generate_data.return_value = mock_generate_return_value;
463    memset( &driver, 0, sizeof( driver ) );
464    memset( &key_management, 0, sizeof( key_management ) );
465    driver.hal_version = PSA_DRV_SE_HAL_VERSION;
466    driver.key_management = &key_management;
467    key_management.p_generate = mock_generate;
468    key_management.p_destroy = mock_destroy;
469    key_management.p_allocate = mock_allocate;
470
471    PSA_ASSERT( psa_register_se_driver( location, &driver ) );
472    PSA_ASSERT( psa_crypto_init( ) );
473
474    psa_set_key_id( &attributes, id );
475    psa_set_key_lifetime( &attributes, lifetime );
476    psa_set_key_usage_flags( &attributes, PSA_KEY_USAGE_EXPORT );
477    psa_set_key_type( &attributes, PSA_KEY_TYPE_RAW_DATA );
478    psa_set_key_bits( &attributes, 8 );
479    TEST_ASSERT( psa_generate_key( &attributes, &returned_id) == expected_result );
480    TEST_ASSERT( mock_allocate_data.called == 1 );
481    TEST_ASSERT( mock_generate_data.called ==
482        ( mock_alloc_return_value == PSA_SUCCESS? 1 : 0 ) );
483
484    if( mock_alloc_return_value == PSA_SUCCESS )
485    {
486        TEST_ASSERT( mbedtls_svc_key_id_equal(
487                         mock_generate_data.attributes.core.id, id ) );
488    }
489    else
490    {
491        TEST_ASSERT( MBEDTLS_SVC_KEY_ID_GET_KEY_ID(
492                         mock_generate_data.attributes.core.id ) == 0 );
493        TEST_ASSERT( MBEDTLS_SVC_KEY_ID_GET_OWNER_ID(
494                         mock_generate_data.attributes.core.id ) == 0 );
495    }
496
497    TEST_ASSERT( mock_generate_data.attributes.core.lifetime ==
498        ( mock_alloc_return_value == PSA_SUCCESS? lifetime : 0 ) );
499    TEST_ASSERT( mock_generate_data.attributes.core.policy.usage ==
500        ( mock_alloc_return_value == PSA_SUCCESS? PSA_KEY_USAGE_EXPORT : 0 ) );
501    TEST_ASSERT( mock_generate_data.attributes.core.type ==
502        ( mock_alloc_return_value == PSA_SUCCESS? PSA_KEY_TYPE_RAW_DATA : 0 ) );
503
504    if( expected_result == PSA_SUCCESS )
505    {
506        PSA_ASSERT( psa_destroy_key( id ) );
507        TEST_ASSERT( mock_destroy_data.called == 1 );
508    }
509
510exit:
511    PSA_DONE( );
512    mock_teardown( );
513}
514/* END_CASE */
515
516/* BEGIN_CASE */
517void mock_export_public( int mock_export_public_return_value,
518                         int expected_result )
519{
520    psa_drv_se_t driver;
521    psa_drv_se_key_management_t key_management;
522    psa_key_lifetime_t lifetime = TEST_SE_PERSISTENT_LIFETIME;
523    psa_key_location_t location = PSA_KEY_LIFETIME_GET_LOCATION( lifetime );
524    mbedtls_svc_key_id_t id = mbedtls_svc_key_id_make( 1, 1 );
525    mbedtls_svc_key_id_t returned_id;
526    psa_key_attributes_t attributes = PSA_KEY_ATTRIBUTES_INIT;
527    const uint8_t key_material[3] = {0xfa, 0xca, 0xde};
528    uint8_t exported[sizeof( key_material )];
529    size_t exported_length;
530
531    mock_export_public_data.return_value = mock_export_public_return_value;
532    memset( &driver, 0, sizeof( driver ) );
533    memset( &key_management, 0, sizeof( key_management ) );
534    driver.hal_version = PSA_DRV_SE_HAL_VERSION;
535    driver.key_management = &key_management;
536    key_management.p_import = mock_import;
537    key_management.p_export_public = mock_export_public;
538    key_management.p_destroy = mock_destroy;
539    key_management.p_allocate = mock_allocate;
540
541    PSA_ASSERT( psa_register_se_driver( location, &driver ) );
542    PSA_ASSERT( psa_crypto_init( ) );
543
544    psa_set_key_id( &attributes, id );
545    psa_set_key_lifetime( &attributes, lifetime );
546    psa_set_key_usage_flags( &attributes, PSA_KEY_USAGE_EXPORT );
547    psa_set_key_type( &attributes, PSA_KEY_TYPE_RSA_PUBLIC_KEY );
548
549    PSA_ASSERT( psa_import_key( &attributes,
550                                key_material, sizeof( key_material ),
551                                &returned_id ) );
552
553    TEST_ASSERT( psa_export_public_key( id, exported, sizeof(exported),
554                                        &exported_length ) == expected_result );
555    TEST_ASSERT( mock_export_public_data.called == 1 );
556
557    PSA_ASSERT( psa_destroy_key( id ) );
558    TEST_ASSERT( mock_destroy_data.called == 1 );
559
560exit:
561    PSA_DONE( );
562    mock_teardown( );
563}
564/* END_CASE */
565
566/* BEGIN_CASE */
567void mock_sign( int mock_sign_return_value, int expected_result )
568{
569    psa_drv_se_t driver;
570    psa_drv_se_key_management_t key_management;
571    psa_drv_se_asymmetric_t asymmetric;
572    psa_key_lifetime_t lifetime = TEST_SE_PERSISTENT_LIFETIME;
573    psa_key_location_t location = PSA_KEY_LIFETIME_GET_LOCATION( lifetime );
574    mbedtls_svc_key_id_t id = mbedtls_svc_key_id_make( 1, 1 );
575    mbedtls_svc_key_id_t returned_id;
576    psa_key_attributes_t attributes = PSA_KEY_ATTRIBUTES_INIT;
577    const uint8_t key_material[3] = {0xfa, 0xca, 0xde};
578    psa_algorithm_t algorithm = PSA_ALG_ECDSA(PSA_ALG_SHA_256);
579    const uint8_t hash[1] = {'H'};
580    uint8_t signature[1] = {'S'};
581    size_t signature_length;
582
583    mock_sign_data.return_value = mock_sign_return_value;
584    memset( &driver, 0, sizeof( driver ) );
585    memset( &key_management, 0, sizeof( key_management ) );
586    memset( &asymmetric, 0, sizeof( asymmetric ) );
587
588    driver.hal_version = PSA_DRV_SE_HAL_VERSION;
589
590    driver.key_management = &key_management;
591    key_management.p_import = mock_import;
592    key_management.p_destroy = mock_destroy;
593    key_management.p_allocate = mock_allocate;
594
595    driver.asymmetric = &asymmetric;
596    asymmetric.p_sign = mock_sign;
597
598    PSA_ASSERT( psa_register_se_driver( location, &driver ) );
599    PSA_ASSERT( psa_crypto_init( ) );
600
601    psa_set_key_id( &attributes, id );
602    psa_set_key_lifetime( &attributes, lifetime );
603    psa_set_key_usage_flags( &attributes, PSA_KEY_USAGE_SIGN_HASH );
604    psa_set_key_algorithm( &attributes, algorithm );
605    psa_set_key_type( &attributes, PSA_KEY_TYPE_RSA_KEY_PAIR );
606
607    PSA_ASSERT( psa_import_key( &attributes,
608                                key_material, sizeof( key_material ),
609                                &returned_id ) );
610
611    TEST_ASSERT( psa_sign_hash( id, algorithm,
612                                hash, sizeof( hash ),
613                                signature, sizeof( signature ),
614                                &signature_length)
615                 == expected_result );
616    TEST_ASSERT( mock_sign_data.called == 1 );
617
618    PSA_ASSERT( psa_destroy_key( id ) );
619    TEST_ASSERT( mock_destroy_data.called == 1 );
620
621exit:
622    PSA_DONE( );
623    mock_teardown( );
624}
625/* END_CASE */
626
627/* BEGIN_CASE */
628void mock_verify( int mock_verify_return_value, int expected_result )
629{
630    psa_drv_se_t driver;
631    psa_drv_se_key_management_t key_management;
632    psa_drv_se_asymmetric_t asymmetric;
633    psa_key_lifetime_t lifetime = TEST_SE_PERSISTENT_LIFETIME;
634    psa_key_location_t location = PSA_KEY_LIFETIME_GET_LOCATION( lifetime );
635    mbedtls_svc_key_id_t id = mbedtls_svc_key_id_make( 1, 1 );
636    mbedtls_svc_key_id_t returned_id;
637    psa_key_attributes_t attributes = PSA_KEY_ATTRIBUTES_INIT;
638    const uint8_t key_material[3] = {0xfa, 0xca, 0xde};
639    psa_algorithm_t algorithm = PSA_ALG_ECDSA(PSA_ALG_SHA_256);
640    const uint8_t hash[1] = {'H'};
641    const uint8_t signature[1] = {'S'};
642
643    mock_verify_data.return_value = mock_verify_return_value;
644    memset( &driver, 0, sizeof( driver ) );
645    memset( &key_management, 0, sizeof( key_management ) );
646    memset( &asymmetric, 0, sizeof( asymmetric ) );
647
648    driver.hal_version = PSA_DRV_SE_HAL_VERSION;
649
650    driver.key_management = &key_management;
651    key_management.p_import = mock_import;
652    key_management.p_destroy = mock_destroy;
653    key_management.p_allocate = mock_allocate;
654
655    driver.asymmetric = &asymmetric;
656    asymmetric.p_verify = mock_verify;
657
658    PSA_ASSERT( psa_register_se_driver( location, &driver ) );
659    PSA_ASSERT( psa_crypto_init( ) );
660
661    psa_set_key_id( &attributes, id );
662    psa_set_key_lifetime( &attributes, lifetime );
663    psa_set_key_usage_flags( &attributes, PSA_KEY_USAGE_VERIFY_HASH );
664    psa_set_key_algorithm( &attributes, algorithm );
665    psa_set_key_type( &attributes, PSA_KEY_TYPE_RAW_DATA );
666
667    PSA_ASSERT( psa_import_key( &attributes,
668                                key_material, sizeof( key_material ),
669                                &returned_id ) );
670
671    TEST_ASSERT( psa_verify_hash( id, algorithm,
672                                  hash, sizeof( hash ),
673                                  signature, sizeof( signature ) )
674                 == expected_result );
675    TEST_ASSERT( mock_verify_data.called == 1 );
676
677    PSA_ASSERT( psa_destroy_key( id ) );
678    TEST_ASSERT( mock_destroy_data.called == 1 );
679
680exit:
681    PSA_DONE( );
682    mock_teardown( );
683}
684/* END_CASE */
685