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