Debian Codegraph @

tests/suites/test_suite_psa_crypto_se_driver_hal_mocks.function

raw
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
13 static struct {
14 uint16_t called;
15 psa_key_location_t location;
16 psa_status_t return_value;
17 } mock_init_data;
18
19 static 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
27 static 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
36 static 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
43 static 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
50 static 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
59 static 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
68 static struct {
69 uint16_t called;
70 psa_status_t return_value;
71 } mock_allocate_data;
72
73 static 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
80 static 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
100 static 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
114 static 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
126 static 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
145 static 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
165 static 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
182 static 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
199 #if defined(PSA_WANT_KEY_TYPE_RSA_KEY_PAIR_IMPORT) && \
200 defined(PSA_WANT_ALG_ECDSA) && \
201 defined(PSA_WANT_ALG_SHA_256)
202 static psa_status_t mock_sign(psa_drv_se_context_t *context,
203 psa_key_slot_number_t key_slot,
204 psa_algorithm_t alg,
205 const uint8_t *p_hash,
206 size_t hash_length,
207 uint8_t *p_signature,
208 size_t signature_size,
209 size_t *p_signature_length)
210 {
211 (void) context;
212 (void) p_hash;
213 (void) p_signature;
214 (void) p_signature_length;
215
216 mock_sign_data.called++;
217 mock_sign_data.key_slot = key_slot;
218 mock_sign_data.alg = alg;
219 mock_sign_data.hash_length = hash_length;
220 mock_sign_data.signature_size = signature_size;
221
222 return mock_sign_data.return_value;
223 }
224 #endif
225
226 #if defined(PSA_WANT_ALG_ECDSA) && defined(PSA_WANT_ALG_SHA_256)
227 static psa_status_t mock_verify(psa_drv_se_context_t *context,
228 psa_key_slot_number_t key_slot,
229 psa_algorithm_t alg,
230 const uint8_t *p_hash,
231 size_t hash_length,
232 const uint8_t *p_signature,
233 size_t signature_length)
234 {
235 (void) context;
236 (void) p_hash;
237 (void) p_signature;
238
239 mock_verify_data.called++;
240 mock_verify_data.key_slot = key_slot;
241 mock_verify_data.alg = alg;
242 mock_verify_data.hash_length = hash_length;
243 mock_verify_data.signature_length = signature_length;
244
245 return mock_verify_data.return_value;
246 }
247 #endif
248
249 static psa_status_t mock_allocate(psa_drv_se_context_t *drv_context,
250 void *persistent_data,
251 const psa_key_attributes_t *attributes,
252 psa_key_creation_method_t method,
253 psa_key_slot_number_t *key_slot)
254 {
255 (void) drv_context;
256 (void) persistent_data;
257 (void) attributes;
258 (void) method;
259 (void) key_slot;
260
261 mock_allocate_data.called++;
262 *key_slot = 0;
263
264 return mock_allocate_data.return_value;
265 }
266
267 static psa_status_t mock_destroy(psa_drv_se_context_t *context,
268 void *persistent_data,
269 psa_key_slot_number_t slot_number)
270 {
271 (void) context;
272 (void) persistent_data;
273
274 mock_destroy_data.called++;
275 mock_destroy_data.slot_number = slot_number;
276
277 return mock_destroy_data.return_value;
278 }
279
280 /* END_HEADER */
281
282 /* BEGIN_DEPENDENCIES
283 * depends_on:MBEDTLS_PSA_CRYPTO_SE_C
284 * END_DEPENDENCIES
285 */
286
287 /* BEGIN_CASE */
288 void mock_init(int location_arg,
289 int expected_register_status_arg,
290 int driver_status_arg,
291 int expected_psa_status_arg,
292 int expected_called)
293 {
294 psa_key_location_t location = location_arg;
295 psa_status_t expected_register_status = expected_register_status_arg;
296 psa_status_t driver_status = driver_status_arg;
297 psa_status_t expected_psa_status = expected_psa_status_arg;
298 psa_drv_se_t driver = {
299 .hal_version = PSA_DRV_SE_HAL_VERSION,
300 .p_init = mock_init,
301 };
302 int psa_crypto_init_called = 0;
303
304 mock_init_data.return_value = driver_status;
305
306 TEST_EQUAL(psa_register_se_driver(location, &driver),
307 expected_register_status);
308
309 psa_crypto_init_called = 1;
310 TEST_EQUAL(psa_crypto_init(), expected_psa_status);
311
312 TEST_EQUAL(mock_init_data.called, expected_called);
313 if (expected_called) {
314 TEST_EQUAL(mock_init_data.location, location);
315 }
316
317 exit:
318 if (psa_crypto_init_called) {
319 PSA_DONE();
320 }
321 mock_teardown();
322 }
323 /* END_CASE */
324
325 /* BEGIN_CASE */
326 void mock_import(int mock_alloc_return_value,
327 int mock_import_return_value,
328 int bits,
329 int expected_result)
330 {
331 psa_drv_se_t driver;
332 psa_drv_se_key_management_t key_management;
333 psa_key_lifetime_t lifetime = TEST_SE_PERSISTENT_LIFETIME;
334 psa_key_location_t location = PSA_KEY_LIFETIME_GET_LOCATION(lifetime);
335 mbedtls_svc_key_id_t id = mbedtls_svc_key_id_make(1, 1);
336 mbedtls_svc_key_id_t returned_id;
337 psa_key_attributes_t attributes = PSA_KEY_ATTRIBUTES_INIT;
338 const uint8_t key_material[3] = { 0xfa, 0xca, 0xde };
339
340 mock_allocate_data.return_value = mock_alloc_return_value;
341 mock_import_data.return_value = mock_import_return_value;
342 mock_import_data.bits = bits;
343 memset(&driver, 0, sizeof(driver));
344 memset(&key_management, 0, sizeof(key_management));
345 driver.hal_version = PSA_DRV_SE_HAL_VERSION;
346 driver.key_management = &key_management;
347 key_management.p_import = mock_import;
348 key_management.p_destroy = mock_destroy;
349 key_management.p_allocate = mock_allocate;
350
351 PSA_ASSERT(psa_register_se_driver(location, &driver));
352 PSA_ASSERT(psa_crypto_init());
353
354 psa_set_key_id(&attributes, id);
355 psa_set_key_lifetime(&attributes, lifetime);
356 psa_set_key_usage_flags(&attributes, PSA_KEY_USAGE_EXPORT);
357 psa_set_key_type(&attributes, PSA_KEY_TYPE_RAW_DATA);
358 TEST_ASSERT(psa_import_key(&attributes,
359 key_material, sizeof(key_material),
360 &returned_id) == expected_result);
361
362 TEST_ASSERT(mock_allocate_data.called == 1);
363 TEST_ASSERT(mock_import_data.called ==
364 (mock_alloc_return_value == PSA_SUCCESS ? 1 : 0));
365
366 if (mock_alloc_return_value == PSA_SUCCESS) {
367 TEST_ASSERT(mbedtls_svc_key_id_equal(
368 mock_import_data.attributes.id, id));
369 } else {
370 TEST_ASSERT(MBEDTLS_SVC_KEY_ID_GET_KEY_ID(
371 mock_import_data.attributes.id) == 0);
372 TEST_ASSERT(MBEDTLS_SVC_KEY_ID_GET_OWNER_ID(
373 mock_import_data.attributes.id) == 0);
374 }
375
376 TEST_ASSERT(mock_import_data.attributes.lifetime ==
377 (mock_alloc_return_value == PSA_SUCCESS ? lifetime : 0));
378 TEST_ASSERT(mock_import_data.attributes.policy.usage ==
379 (mock_alloc_return_value == PSA_SUCCESS ? PSA_KEY_USAGE_EXPORT : 0));
380 TEST_ASSERT(mock_import_data.attributes.type ==
381 (mock_alloc_return_value == PSA_SUCCESS ? PSA_KEY_TYPE_RAW_DATA : 0));
382
383 if (expected_result == PSA_SUCCESS) {
384 PSA_ASSERT(psa_destroy_key(id));
385 TEST_ASSERT(mock_destroy_data.called == 1);
386 }
387 exit:
388 PSA_DONE();
389 mock_teardown();
390 }
391 /* END_CASE */
392
393 /* BEGIN_CASE */
394 void mock_export(int mock_export_return_value, int expected_result)
395 {
396 psa_drv_se_t driver;
397 psa_drv_se_key_management_t key_management;
398 psa_key_lifetime_t lifetime = TEST_SE_PERSISTENT_LIFETIME;
399 psa_key_location_t location = PSA_KEY_LIFETIME_GET_LOCATION(lifetime);
400 mbedtls_svc_key_id_t id = mbedtls_svc_key_id_make(1, 1);
401 mbedtls_svc_key_id_t returned_id;
402 psa_key_attributes_t attributes = PSA_KEY_ATTRIBUTES_INIT;
403 const uint8_t key_material[3] = { 0xfa, 0xca, 0xde };
404 uint8_t exported[sizeof(key_material)];
405 size_t exported_length;
406
407 mock_export_data.return_value = mock_export_return_value;
408 memset(&driver, 0, sizeof(driver));
409 memset(&key_management, 0, sizeof(key_management));
410 driver.hal_version = PSA_DRV_SE_HAL_VERSION;
411 driver.key_management = &key_management;
412 driver.p_init = mock_init;
413 key_management.p_import = mock_import;
414 key_management.p_export = mock_export;
415 key_management.p_destroy = mock_destroy;
416 key_management.p_allocate = mock_allocate;
417
418 PSA_ASSERT(psa_register_se_driver(location, &driver));
419 PSA_ASSERT(psa_crypto_init());
420
421 psa_set_key_id(&attributes, id);
422 psa_set_key_lifetime(&attributes, lifetime);
423 psa_set_key_usage_flags(&attributes, PSA_KEY_USAGE_EXPORT);
424 psa_set_key_type(&attributes, PSA_KEY_TYPE_RAW_DATA);
425 PSA_ASSERT(psa_import_key(&attributes,
426 key_material, sizeof(key_material),
427 &returned_id));
428
429 TEST_ASSERT(psa_export_key(id,
430 exported, sizeof(exported),
431 &exported_length) == expected_result);
432
433 TEST_ASSERT(mock_export_data.called == 1);
434
435 PSA_ASSERT(psa_destroy_key(id));
436
437 TEST_ASSERT(mock_destroy_data.called == 1);
438
439 exit:
440 PSA_DONE();
441 mock_teardown();
442 }
443 /* END_CASE */
444
445 /* BEGIN_CASE */
446 void mock_generate(int mock_alloc_return_value,
447 int mock_generate_return_value,
448 int expected_result)
449 {
450 psa_drv_se_t driver;
451 psa_drv_se_key_management_t key_management;
452 psa_key_lifetime_t lifetime = TEST_SE_PERSISTENT_LIFETIME;
453 psa_key_location_t location = PSA_KEY_LIFETIME_GET_LOCATION(lifetime);
454 mbedtls_svc_key_id_t id = mbedtls_svc_key_id_make(1, 1);
455 mbedtls_svc_key_id_t returned_id;
456 psa_key_attributes_t attributes = PSA_KEY_ATTRIBUTES_INIT;
457
458 mock_allocate_data.return_value = mock_alloc_return_value;
459 mock_generate_data.return_value = mock_generate_return_value;
460 memset(&driver, 0, sizeof(driver));
461 memset(&key_management, 0, sizeof(key_management));
462 driver.hal_version = PSA_DRV_SE_HAL_VERSION;
463 driver.key_management = &key_management;
464 key_management.p_generate = mock_generate;
465 key_management.p_destroy = mock_destroy;
466 key_management.p_allocate = mock_allocate;
467
468 PSA_ASSERT(psa_register_se_driver(location, &driver));
469 PSA_ASSERT(psa_crypto_init());
470
471 psa_set_key_id(&attributes, id);
472 psa_set_key_lifetime(&attributes, lifetime);
473 psa_set_key_usage_flags(&attributes, PSA_KEY_USAGE_EXPORT);
474 psa_set_key_type(&attributes, PSA_KEY_TYPE_RAW_DATA);
475 psa_set_key_bits(&attributes, 8);
476 TEST_ASSERT(psa_generate_key(&attributes, &returned_id) == expected_result);
477 TEST_ASSERT(mock_allocate_data.called == 1);
478 TEST_ASSERT(mock_generate_data.called ==
479 (mock_alloc_return_value == PSA_SUCCESS ? 1 : 0));
480
481 if (mock_alloc_return_value == PSA_SUCCESS) {
482 TEST_ASSERT(mbedtls_svc_key_id_equal(
483 mock_generate_data.attributes.id, id));
484 } else {
485 TEST_ASSERT(MBEDTLS_SVC_KEY_ID_GET_KEY_ID(
486 mock_generate_data.attributes.id) == 0);
487 TEST_ASSERT(MBEDTLS_SVC_KEY_ID_GET_OWNER_ID(
488 mock_generate_data.attributes.id) == 0);
489 }
490
491 TEST_ASSERT(mock_generate_data.attributes.lifetime ==
492 (mock_alloc_return_value == PSA_SUCCESS ? lifetime : 0));
493 TEST_ASSERT(mock_generate_data.attributes.policy.usage ==
494 (mock_alloc_return_value == PSA_SUCCESS ? PSA_KEY_USAGE_EXPORT : 0));
495 TEST_ASSERT(mock_generate_data.attributes.type ==
496 (mock_alloc_return_value == PSA_SUCCESS ? PSA_KEY_TYPE_RAW_DATA : 0));
497
498 if (expected_result == PSA_SUCCESS) {
499 PSA_ASSERT(psa_destroy_key(id));
500 TEST_ASSERT(mock_destroy_data.called == 1);
501 }
502
503 exit:
504 PSA_DONE();
505 mock_teardown();
506 }
507 /* END_CASE */
508
509 /* BEGIN_CASE */
510 void mock_export_public(int mock_export_public_return_value,
511 int expected_result)
512 {
513 psa_drv_se_t driver;
514 psa_drv_se_key_management_t key_management;
515 psa_key_lifetime_t lifetime = TEST_SE_PERSISTENT_LIFETIME;
516 psa_key_location_t location = PSA_KEY_LIFETIME_GET_LOCATION(lifetime);
517 mbedtls_svc_key_id_t id = mbedtls_svc_key_id_make(1, 1);
518 mbedtls_svc_key_id_t returned_id;
519 psa_key_attributes_t attributes = PSA_KEY_ATTRIBUTES_INIT;
520 const uint8_t key_material[3] = { 0xfa, 0xca, 0xde };
521 uint8_t exported[sizeof(key_material)];
522 size_t exported_length;
523
524 mock_export_public_data.return_value = mock_export_public_return_value;
525 memset(&driver, 0, sizeof(driver));
526 memset(&key_management, 0, sizeof(key_management));
527 driver.hal_version = PSA_DRV_SE_HAL_VERSION;
528 driver.key_management = &key_management;
529 key_management.p_import = mock_import;
530 key_management.p_export_public = mock_export_public;
531 key_management.p_destroy = mock_destroy;
532 key_management.p_allocate = mock_allocate;
533
534 PSA_ASSERT(psa_register_se_driver(location, &driver));
535 PSA_ASSERT(psa_crypto_init());
536
537 psa_set_key_id(&attributes, id);
538 psa_set_key_lifetime(&attributes, lifetime);
539 psa_set_key_usage_flags(&attributes, PSA_KEY_USAGE_EXPORT);
540 psa_set_key_type(&attributes, PSA_KEY_TYPE_RSA_PUBLIC_KEY);
541
542 PSA_ASSERT(psa_import_key(&attributes,
543 key_material, sizeof(key_material),
544 &returned_id));
545
546 TEST_ASSERT(psa_export_public_key(id, exported, sizeof(exported),
547 &exported_length) == expected_result);
548 TEST_ASSERT(mock_export_public_data.called == 1);
549
550 PSA_ASSERT(psa_destroy_key(id));
551 TEST_ASSERT(mock_destroy_data.called == 1);
552
553 exit:
554 PSA_DONE();
555 mock_teardown();
556 }
557 /* END_CASE */
558
559 /* BEGIN_CASE depends_on:PSA_WANT_KEY_TYPE_RSA_KEY_PAIR_IMPORT:PSA_WANT_ALG_ECDSA:PSA_WANT_ALG_SHA_256 */
560 void mock_sign(int mock_sign_return_value, int expected_result)
561 {
562 psa_drv_se_t driver;
563 psa_drv_se_key_management_t key_management;
564 psa_drv_se_asymmetric_t asymmetric;
565 psa_key_lifetime_t lifetime = TEST_SE_PERSISTENT_LIFETIME;
566 psa_key_location_t location = PSA_KEY_LIFETIME_GET_LOCATION(lifetime);
567 mbedtls_svc_key_id_t id = mbedtls_svc_key_id_make(1, 1);
568 mbedtls_svc_key_id_t returned_id;
569 psa_key_attributes_t attributes = PSA_KEY_ATTRIBUTES_INIT;
570 const uint8_t key_material[3] = { 0xfa, 0xca, 0xde };
571 psa_algorithm_t algorithm = PSA_ALG_ECDSA(PSA_ALG_SHA_256);
572 const uint8_t hash[1] = { 'H' };
573 uint8_t signature[1] = { 'S' };
574 size_t signature_length;
575
576 mock_sign_data.return_value = mock_sign_return_value;
577 memset(&driver, 0, sizeof(driver));
578 memset(&key_management, 0, sizeof(key_management));
579 memset(&asymmetric, 0, sizeof(asymmetric));
580
581 driver.hal_version = PSA_DRV_SE_HAL_VERSION;
582
583 driver.key_management = &key_management;
584 key_management.p_import = mock_import;
585 key_management.p_destroy = mock_destroy;
586 key_management.p_allocate = mock_allocate;
587
588 driver.asymmetric = &asymmetric;
589 asymmetric.p_sign = mock_sign;
590
591 PSA_ASSERT(psa_register_se_driver(location, &driver));
592 PSA_ASSERT(psa_crypto_init());
593
594 psa_set_key_id(&attributes, id);
595 psa_set_key_lifetime(&attributes, lifetime);
596 psa_set_key_usage_flags(&attributes, PSA_KEY_USAGE_SIGN_HASH);
597 psa_set_key_algorithm(&attributes, algorithm);
598 psa_set_key_type(&attributes, PSA_KEY_TYPE_RSA_KEY_PAIR);
599
600 PSA_ASSERT(psa_import_key(&attributes,
601 key_material, sizeof(key_material),
602 &returned_id));
603
604 TEST_ASSERT(psa_sign_hash(id, algorithm,
605 hash, sizeof(hash),
606 signature, sizeof(signature),
607 &signature_length)
608 == expected_result);
609 TEST_ASSERT(mock_sign_data.called == 1);
610
611 PSA_ASSERT(psa_destroy_key(id));
612 TEST_ASSERT(mock_destroy_data.called == 1);
613
614 exit:
615 PSA_DONE();
616 mock_teardown();
617 }
618 /* END_CASE */
619
620 /* BEGIN_CASE depends_on:PSA_WANT_ALG_ECDSA:PSA_WANT_ALG_SHA_256 */
621 void mock_verify(int mock_verify_return_value, int expected_result)
622 {
623 psa_drv_se_t driver;
624 psa_drv_se_key_management_t key_management;
625 psa_drv_se_asymmetric_t asymmetric;
626 psa_key_lifetime_t lifetime = TEST_SE_PERSISTENT_LIFETIME;
627 psa_key_location_t location = PSA_KEY_LIFETIME_GET_LOCATION(lifetime);
628 mbedtls_svc_key_id_t id = mbedtls_svc_key_id_make(1, 1);
629 mbedtls_svc_key_id_t returned_id;
630 psa_key_attributes_t attributes = PSA_KEY_ATTRIBUTES_INIT;
631 const uint8_t key_material[3] = { 0xfa, 0xca, 0xde };
632 psa_algorithm_t algorithm = PSA_ALG_ECDSA(PSA_ALG_SHA_256);
633 const uint8_t hash[1] = { 'H' };
634 const uint8_t signature[1] = { 'S' };
635
636 mock_verify_data.return_value = mock_verify_return_value;
637 memset(&driver, 0, sizeof(driver));
638 memset(&key_management, 0, sizeof(key_management));
639 memset(&asymmetric, 0, sizeof(asymmetric));
640
641 driver.hal_version = PSA_DRV_SE_HAL_VERSION;
642
643 driver.key_management = &key_management;
644 key_management.p_import = mock_import;
645 key_management.p_destroy = mock_destroy;
646 key_management.p_allocate = mock_allocate;
647
648 driver.asymmetric = &asymmetric;
649 asymmetric.p_verify = mock_verify;
650
651 PSA_ASSERT(psa_register_se_driver(location, &driver));
652 PSA_ASSERT(psa_crypto_init());
653
654 psa_set_key_id(&attributes, id);
655 psa_set_key_lifetime(&attributes, lifetime);
656 psa_set_key_usage_flags(&attributes, PSA_KEY_USAGE_VERIFY_HASH);
657 psa_set_key_algorithm(&attributes, algorithm);
658 psa_set_key_type(&attributes, PSA_KEY_TYPE_RAW_DATA);
659
660 PSA_ASSERT(psa_import_key(&attributes,
661 key_material, sizeof(key_material),
662 &returned_id));
663
664 TEST_ASSERT(psa_verify_hash(id, algorithm,
665 hash, sizeof(hash),
666 signature, sizeof(signature))
667 == expected_result);
668 TEST_ASSERT(mock_verify_data.called == 1);
669
670 PSA_ASSERT(psa_destroy_key(id));
671 TEST_ASSERT(mock_destroy_data.called == 1);
672
673 exit:
674 PSA_DONE();
675 mock_teardown();
676 }
677 /* END_CASE */