blob: 879a77c2f88028961e2708f3458d5fe5697dab7c [file] [log] [blame]
Gilles Peskinee59236f2018-01-27 23:32:46 +01001/* BEGIN_HEADER */
itayzafrir3e02b3b2018-06-12 17:06:52 +03002#include <stdint.h>
mohammad160327010052018-07-03 13:16:15 +03003
4#if defined(MBEDTLS_PSA_CRYPTO_SPM)
5#include "spm/psa_defs.h"
6#endif
7
Gilles Peskinedd2f95b2018-08-11 01:22:42 +02008#include "mbedtls/asn1.h"
Gilles Peskine0b352bc2018-06-28 00:16:11 +02009#include "mbedtls/asn1write.h"
Gilles Peskinedd2f95b2018-08-11 01:22:42 +020010#include "mbedtls/oid.h"
11
Gilles Peskinee59236f2018-01-27 23:32:46 +010012#include "psa/crypto.h"
itayzafrir3e02b3b2018-06-12 17:06:52 +030013
Gilles Peskine96ee5c72018-07-12 17:24:54 +020014#define ARRAY_LENGTH( array ) ( sizeof( array ) / sizeof( *( array ) ) )
15
itayzafrir3e02b3b2018-06-12 17:06:52 +030016#if(UINT32_MAX > SIZE_MAX)
Gilles Peskine2d277862018-06-18 15:41:12 +020017#define PSA_CRYPTO_TEST_SIZE_T_RANGE( x ) ( ( x ) <= SIZE_MAX )
itayzafrir3e02b3b2018-06-12 17:06:52 +030018#else
Gilles Peskine2d277862018-06-18 15:41:12 +020019#define PSA_CRYPTO_TEST_SIZE_T_RANGE( x ) 1
itayzafrir3e02b3b2018-06-12 17:06:52 +030020#endif
Gilles Peskinee66ca3b2018-06-20 00:11:45 +020021
Jaeden Amerof24c7f82018-06-27 17:20:43 +010022/** An invalid export length that will never be set by psa_export_key(). */
23static const size_t INVALID_EXPORT_LENGTH = ~0U;
24
Gilles Peskinea7aa4422018-08-14 15:17:54 +020025/** Test if a buffer contains a constant byte value.
26 *
27 * `mem_is_char(buffer, c, size)` is true after `memset(buffer, c, size)`.
Gilles Peskinee66ca3b2018-06-20 00:11:45 +020028 *
29 * \param buffer Pointer to the beginning of the buffer.
Gilles Peskinea7aa4422018-08-14 15:17:54 +020030 * \param c Expected value of every byte.
Gilles Peskinee66ca3b2018-06-20 00:11:45 +020031 * \param size Size of the buffer in bytes.
32 *
Gilles Peskine3f669c32018-06-21 09:21:51 +020033 * \return 1 if the buffer is all-bits-zero.
34 * \return 0 if there is at least one nonzero byte.
Gilles Peskinee66ca3b2018-06-20 00:11:45 +020035 */
Gilles Peskinea7aa4422018-08-14 15:17:54 +020036static int mem_is_char( void *buffer, unsigned char c, size_t size )
Gilles Peskinee66ca3b2018-06-20 00:11:45 +020037{
38 size_t i;
39 for( i = 0; i < size; i++ )
40 {
Gilles Peskinea7aa4422018-08-14 15:17:54 +020041 if( ( (unsigned char *) buffer )[i] != c )
Gilles Peskine3f669c32018-06-21 09:21:51 +020042 return( 0 );
Gilles Peskinee66ca3b2018-06-20 00:11:45 +020043 }
Gilles Peskine3f669c32018-06-21 09:21:51 +020044 return( 1 );
Gilles Peskinee66ca3b2018-06-20 00:11:45 +020045}
Gilles Peskine818ca122018-06-20 18:16:48 +020046
Gilles Peskine0b352bc2018-06-28 00:16:11 +020047/* Write the ASN.1 INTEGER with the value 2^(bits-1)+x backwards from *p. */
48static int asn1_write_10x( unsigned char **p,
49 unsigned char *start,
50 size_t bits,
51 unsigned char x )
52{
53 int ret;
54 int len = bits / 8 + 1;
Gilles Peskine480416a2018-06-28 19:04:07 +020055 if( bits == 0 )
56 return( MBEDTLS_ERR_ASN1_INVALID_DATA );
57 if( bits <= 8 && x >= 1 << ( bits - 1 ) )
Gilles Peskine0b352bc2018-06-28 00:16:11 +020058 return( MBEDTLS_ERR_ASN1_INVALID_DATA );
Moran Pekercb088e72018-07-17 17:36:59 +030059 if( *p < start || *p - start < (ptrdiff_t) len )
Gilles Peskine0b352bc2018-06-28 00:16:11 +020060 return( MBEDTLS_ERR_ASN1_BUF_TOO_SMALL );
61 *p -= len;
62 ( *p )[len-1] = x;
63 if( bits % 8 == 0 )
64 ( *p )[1] |= 1;
65 else
66 ( *p )[0] |= 1 << ( bits % 8 );
67 MBEDTLS_ASN1_CHK_ADD( len, mbedtls_asn1_write_len( p, start, len ) );
68 MBEDTLS_ASN1_CHK_ADD( len, mbedtls_asn1_write_tag( p, start,
69 MBEDTLS_ASN1_INTEGER ) );
70 return( len );
71}
72
73static int construct_fake_rsa_key( unsigned char *buffer,
74 size_t buffer_size,
75 unsigned char **p,
76 size_t bits,
77 int keypair )
78{
79 size_t half_bits = ( bits + 1 ) / 2;
80 int ret;
81 int len = 0;
82 /* Construct something that looks like a DER encoding of
83 * as defined by PKCS#1 v2.2 (RFC 8017) section A.1.2:
84 * RSAPrivateKey ::= SEQUENCE {
85 * version Version,
86 * modulus INTEGER, -- n
87 * publicExponent INTEGER, -- e
88 * privateExponent INTEGER, -- d
89 * prime1 INTEGER, -- p
90 * prime2 INTEGER, -- q
91 * exponent1 INTEGER, -- d mod (p-1)
92 * exponent2 INTEGER, -- d mod (q-1)
93 * coefficient INTEGER, -- (inverse of q) mod p
94 * otherPrimeInfos OtherPrimeInfos OPTIONAL
95 * }
96 * Or, for a public key, the same structure with only
97 * version, modulus and publicExponent.
98 */
99 *p = buffer + buffer_size;
100 if( keypair )
101 {
102 MBEDTLS_ASN1_CHK_ADD( len, /* pq */
103 asn1_write_10x( p, buffer, half_bits, 1 ) );
104 MBEDTLS_ASN1_CHK_ADD( len, /* dq */
105 asn1_write_10x( p, buffer, half_bits, 1 ) );
106 MBEDTLS_ASN1_CHK_ADD( len, /* dp */
107 asn1_write_10x( p, buffer, half_bits, 1 ) );
108 MBEDTLS_ASN1_CHK_ADD( len, /* q */
109 asn1_write_10x( p, buffer, half_bits, 1 ) );
110 MBEDTLS_ASN1_CHK_ADD( len, /* p != q to pass mbedtls sanity checks */
111 asn1_write_10x( p, buffer, half_bits, 3 ) );
112 MBEDTLS_ASN1_CHK_ADD( len, /* d */
113 asn1_write_10x( p, buffer, bits, 1 ) );
114 }
115 MBEDTLS_ASN1_CHK_ADD( len, /* e = 65537 */
116 asn1_write_10x( p, buffer, 17, 1 ) );
117 MBEDTLS_ASN1_CHK_ADD( len, /* n */
118 asn1_write_10x( p, buffer, bits, 1 ) );
119 if( keypair )
120 MBEDTLS_ASN1_CHK_ADD( len, /* version = 0 */
121 mbedtls_asn1_write_int( p, buffer, 0 ) );
122 MBEDTLS_ASN1_CHK_ADD( len, mbedtls_asn1_write_len( p, buffer, len ) );
123 {
124 const unsigned char tag =
125 MBEDTLS_ASN1_CONSTRUCTED | MBEDTLS_ASN1_SEQUENCE;
126 MBEDTLS_ASN1_CHK_ADD( len, mbedtls_asn1_write_tag( p, buffer, tag ) );
127 }
128 return( len );
129}
130
Gilles Peskine818ca122018-06-20 18:16:48 +0200131static int exercise_mac_key( psa_key_slot_t key,
132 psa_key_usage_t usage,
133 psa_algorithm_t alg )
134{
135 psa_mac_operation_t operation;
136 const unsigned char input[] = "foo";
Gilles Peskine69c12672018-06-28 00:07:19 +0200137 unsigned char mac[PSA_MAC_MAX_SIZE] = {0};
Gilles Peskine818ca122018-06-20 18:16:48 +0200138 size_t mac_length = sizeof( mac );
139
140 if( usage & PSA_KEY_USAGE_SIGN )
141 {
Gilles Peskine89167cb2018-07-08 20:12:23 +0200142 TEST_ASSERT( psa_mac_sign_setup( &operation,
143 key, alg ) == PSA_SUCCESS );
Gilles Peskine818ca122018-06-20 18:16:48 +0200144 TEST_ASSERT( psa_mac_update( &operation,
145 input, sizeof( input ) ) == PSA_SUCCESS );
Gilles Peskineacd4be32018-07-08 19:56:25 +0200146 TEST_ASSERT( psa_mac_sign_finish( &operation,
Gilles Peskineef0cb402018-07-12 16:55:59 +0200147 mac, sizeof( mac ),
Gilles Peskineacd4be32018-07-08 19:56:25 +0200148 &mac_length ) == PSA_SUCCESS );
Gilles Peskine818ca122018-06-20 18:16:48 +0200149 }
150
151 if( usage & PSA_KEY_USAGE_VERIFY )
152 {
153 psa_status_t verify_status =
154 ( usage & PSA_KEY_USAGE_SIGN ?
155 PSA_SUCCESS :
156 PSA_ERROR_INVALID_SIGNATURE );
Gilles Peskine89167cb2018-07-08 20:12:23 +0200157 TEST_ASSERT( psa_mac_verify_setup( &operation,
158 key, alg ) == PSA_SUCCESS );
Gilles Peskine818ca122018-06-20 18:16:48 +0200159 TEST_ASSERT( psa_mac_update( &operation,
160 input, sizeof( input ) ) == PSA_SUCCESS );
Gilles Peskineacd4be32018-07-08 19:56:25 +0200161 TEST_ASSERT( psa_mac_verify_finish( &operation,
162 mac,
163 mac_length ) == verify_status );
Gilles Peskine818ca122018-06-20 18:16:48 +0200164 }
165
166 return( 1 );
167
168exit:
169 psa_mac_abort( &operation );
170 return( 0 );
171}
172
173static int exercise_cipher_key( psa_key_slot_t key,
174 psa_key_usage_t usage,
175 psa_algorithm_t alg )
176{
177 psa_cipher_operation_t operation;
178 unsigned char iv[16] = {0};
179 size_t iv_length = sizeof( iv );
180 const unsigned char plaintext[16] = "Hello, world...";
181 unsigned char ciphertext[32] = "(wabblewebblewibblewobblewubble)";
182 size_t ciphertext_length = sizeof( ciphertext );
183 unsigned char decrypted[sizeof( ciphertext )];
184 size_t part_length;
185
186 if( usage & PSA_KEY_USAGE_ENCRYPT )
187 {
Gilles Peskinefe119512018-07-08 21:39:34 +0200188 TEST_ASSERT( psa_cipher_encrypt_setup( &operation,
189 key, alg ) == PSA_SUCCESS );
190 TEST_ASSERT( psa_cipher_generate_iv( &operation,
191 iv, sizeof( iv ),
192 &iv_length ) == PSA_SUCCESS );
Gilles Peskine818ca122018-06-20 18:16:48 +0200193 TEST_ASSERT( psa_cipher_update( &operation,
194 plaintext, sizeof( plaintext ),
195 ciphertext, sizeof( ciphertext ),
196 &ciphertext_length ) == PSA_SUCCESS );
197 TEST_ASSERT( psa_cipher_finish( &operation,
198 ciphertext + ciphertext_length,
199 sizeof( ciphertext ) - ciphertext_length,
200 &part_length ) == PSA_SUCCESS );
201 ciphertext_length += part_length;
202 }
203
204 if( usage & PSA_KEY_USAGE_DECRYPT )
205 {
206 psa_status_t status;
Mohammad AboMokhadb9b232018-06-28 01:52:54 -0700207 psa_key_type_t type = PSA_KEY_TYPE_NONE;
Gilles Peskine818ca122018-06-20 18:16:48 +0200208 if( ! ( usage & PSA_KEY_USAGE_ENCRYPT ) )
209 {
Gilles Peskine818ca122018-06-20 18:16:48 +0200210 size_t bits;
211 TEST_ASSERT( psa_get_key_information( key, &type, &bits ) );
212 iv_length = PSA_BLOCK_CIPHER_BLOCK_SIZE( type );
213 }
Gilles Peskinefe119512018-07-08 21:39:34 +0200214 TEST_ASSERT( psa_cipher_decrypt_setup( &operation,
215 key, alg ) == PSA_SUCCESS );
216 TEST_ASSERT( psa_cipher_set_iv( &operation,
217 iv, iv_length ) == PSA_SUCCESS );
Gilles Peskine818ca122018-06-20 18:16:48 +0200218 TEST_ASSERT( psa_cipher_update( &operation,
219 ciphertext, ciphertext_length,
220 decrypted, sizeof( decrypted ),
221 &part_length ) == PSA_SUCCESS );
222 status = psa_cipher_finish( &operation,
223 decrypted + part_length,
224 sizeof( decrypted ) - part_length,
225 &part_length );
226 /* For a stream cipher, all inputs are valid. For a block cipher,
227 * if the input is some aribtrary data rather than an actual
228 ciphertext, a padding error is likely. */
Mohammad AboMokh65fa0b82018-06-28 02:14:00 -0700229 if( ( usage & PSA_KEY_USAGE_ENCRYPT ) ||
Mohammad AboMokhadb9b232018-06-28 01:52:54 -0700230 PSA_BLOCK_CIPHER_BLOCK_SIZE( type ) == 1 )
Gilles Peskine818ca122018-06-20 18:16:48 +0200231 TEST_ASSERT( status == PSA_SUCCESS );
232 else
233 TEST_ASSERT( status == PSA_SUCCESS ||
234 status == PSA_ERROR_INVALID_PADDING );
235 }
236
237 return( 1 );
238
239exit:
240 psa_cipher_abort( &operation );
241 return( 0 );
242}
243
244static int exercise_aead_key( psa_key_slot_t key,
245 psa_key_usage_t usage,
246 psa_algorithm_t alg )
247{
248 unsigned char nonce[16] = {0};
249 size_t nonce_length = sizeof( nonce );
250 unsigned char plaintext[16] = "Hello, world...";
251 unsigned char ciphertext[48] = "(wabblewebblewibblewobblewubble)";
252 size_t ciphertext_length = sizeof( ciphertext );
253 size_t plaintext_length = sizeof( ciphertext );
254
255 if( usage & PSA_KEY_USAGE_ENCRYPT )
256 {
257 TEST_ASSERT( psa_aead_encrypt( key, alg,
258 nonce, nonce_length,
259 NULL, 0,
260 plaintext, sizeof( plaintext ),
261 ciphertext, sizeof( ciphertext ),
262 &ciphertext_length ) == PSA_SUCCESS );
263 }
264
265 if( usage & PSA_KEY_USAGE_DECRYPT )
266 {
267 psa_status_t verify_status =
268 ( usage & PSA_KEY_USAGE_ENCRYPT ?
269 PSA_SUCCESS :
270 PSA_ERROR_INVALID_SIGNATURE );
271 TEST_ASSERT( psa_aead_decrypt( key, alg,
272 nonce, nonce_length,
273 NULL, 0,
274 ciphertext, ciphertext_length,
275 plaintext, sizeof( plaintext ),
276 &plaintext_length ) == verify_status );
277 }
278
279 return( 1 );
280
281exit:
282 return( 0 );
283}
284
285static int exercise_signature_key( psa_key_slot_t key,
286 psa_key_usage_t usage,
287 psa_algorithm_t alg )
288{
Gilles Peskinef969b3a2018-06-30 00:20:25 +0200289 unsigned char payload[PSA_HASH_MAX_SIZE] = {1};
290 size_t payload_length = 16;
Gilles Peskine69c12672018-06-28 00:07:19 +0200291 unsigned char signature[PSA_ASYMMETRIC_SIGNATURE_MAX_SIZE] = {0};
Gilles Peskine818ca122018-06-20 18:16:48 +0200292 size_t signature_length = sizeof( signature );
293
294 if( usage & PSA_KEY_USAGE_SIGN )
295 {
Gilles Peskinef969b3a2018-06-30 00:20:25 +0200296 /* Some algorithms require the payload to have the size of
297 * the hash encoded in the algorithm. Use this input size
298 * even for algorithms that allow other input sizes. */
299 psa_algorithm_t hash_alg = PSA_ALG_SIGN_GET_HASH( alg );
300 if( hash_alg != 0 )
301 payload_length = PSA_HASH_SIZE( hash_alg );
Gilles Peskine818ca122018-06-20 18:16:48 +0200302 TEST_ASSERT( psa_asymmetric_sign( key, alg,
303 payload, payload_length,
Gilles Peskine818ca122018-06-20 18:16:48 +0200304 signature, sizeof( signature ),
305 &signature_length ) == PSA_SUCCESS );
306 }
307
308 if( usage & PSA_KEY_USAGE_VERIFY )
309 {
310 psa_status_t verify_status =
311 ( usage & PSA_KEY_USAGE_SIGN ?
312 PSA_SUCCESS :
313 PSA_ERROR_INVALID_SIGNATURE );
314 TEST_ASSERT( psa_asymmetric_verify( key, alg,
315 payload, payload_length,
Gilles Peskine818ca122018-06-20 18:16:48 +0200316 signature, signature_length ) ==
317 verify_status );
318 }
319
320 return( 1 );
321
322exit:
323 return( 0 );
324}
325
326static int exercise_asymmetric_encryption_key( psa_key_slot_t key,
327 psa_key_usage_t usage,
328 psa_algorithm_t alg )
329{
330 unsigned char plaintext[256] = "Hello, world...";
331 unsigned char ciphertext[256] = "(wabblewebblewibblewobblewubble)";
332 size_t ciphertext_length = sizeof( ciphertext );
333 size_t plaintext_length = 16;
334
335 if( usage & PSA_KEY_USAGE_ENCRYPT )
336 {
337 TEST_ASSERT(
338 psa_asymmetric_encrypt( key, alg,
339 plaintext, plaintext_length,
340 NULL, 0,
341 ciphertext, sizeof( ciphertext ),
342 &ciphertext_length ) == PSA_SUCCESS );
343 }
344
345 if( usage & PSA_KEY_USAGE_DECRYPT )
346 {
347 psa_status_t status =
348 psa_asymmetric_decrypt( key, alg,
349 ciphertext, ciphertext_length,
350 NULL, 0,
351 plaintext, sizeof( plaintext ),
352 &plaintext_length );
353 TEST_ASSERT( status == PSA_SUCCESS ||
354 ( ( usage & PSA_KEY_USAGE_ENCRYPT ) == 0 &&
355 ( status == PSA_ERROR_INVALID_ARGUMENT ||
356 status == PSA_ERROR_INVALID_PADDING ) ) );
357 }
358
359 return( 1 );
360
361exit:
362 return( 0 );
363}
Gilles Peskine02b75072018-07-01 22:31:34 +0200364
Gilles Peskineea0fb492018-07-12 17:17:20 +0200365static int exercise_key_derivation_key( psa_key_slot_t key,
366 psa_key_usage_t usage,
367 psa_algorithm_t alg )
368{
369 psa_crypto_generator_t generator = PSA_CRYPTO_GENERATOR_INIT;
370 unsigned char label[16] = "This is a label.";
371 size_t label_length = sizeof( label );
372 unsigned char seed[16] = "abcdefghijklmnop";
373 size_t seed_length = sizeof( seed );
374 unsigned char output[1];
375
376 if( usage & PSA_KEY_USAGE_DERIVE )
377 {
378 TEST_ASSERT( psa_key_derivation( &generator,
379 key, alg,
380 label, label_length,
381 seed, seed_length,
382 sizeof( output ) ) == PSA_SUCCESS );
383 TEST_ASSERT( psa_generator_read( &generator,
384 output,
385 sizeof( output ) ) == PSA_SUCCESS );
386 TEST_ASSERT( psa_generator_abort( &generator ) == PSA_SUCCESS );
387 }
388
389 return( 1 );
390
391exit:
392 return( 0 );
393}
394
Gilles Peskinedd2f95b2018-08-11 01:22:42 +0200395static int is_oid_of_key_type( psa_key_type_t type,
396 const uint8_t *oid, size_t oid_length )
397{
Gilles Peskineae3d2a22018-08-13 14:14:22 +0200398 const uint8_t *expected_oid = NULL;
399 size_t expected_oid_length = 0;
Gilles Peskinedd2f95b2018-08-11 01:22:42 +0200400#if defined(MBEDTLS_RSA_C)
Gilles Peskineae3d2a22018-08-13 14:14:22 +0200401 if( PSA_KEY_TYPE_IS_RSA( type ) )
402 {
403 expected_oid = (uint8_t *) MBEDTLS_OID_PKCS1_RSA;
404 expected_oid_length = sizeof( MBEDTLS_OID_PKCS1_RSA ) - 1;
405 }
406 else
Gilles Peskinedd2f95b2018-08-11 01:22:42 +0200407#endif /* MBEDTLS_RSA_C */
408#if defined(MBEDTLS_ECP_C)
Gilles Peskineae3d2a22018-08-13 14:14:22 +0200409 if( PSA_KEY_TYPE_IS_ECC( type ) )
410 {
411 expected_oid = (uint8_t *) MBEDTLS_OID_EC_ALG_UNRESTRICTED;
412 expected_oid_length = sizeof( MBEDTLS_OID_EC_ALG_UNRESTRICTED ) - 1;
413 }
414 else
Gilles Peskinedd2f95b2018-08-11 01:22:42 +0200415#endif /* MBEDTLS_ECP_C */
Gilles Peskinedd2f95b2018-08-11 01:22:42 +0200416 {
417 char message[40];
418 mbedtls_snprintf( message, sizeof( message ),
419 "OID not known for key type=0x%08lx",
420 (unsigned long) type );
421 test_fail( message, __LINE__, __FILE__ );
422 return( 0 );
423 }
424
Gilles Peskinebd7dea92018-09-27 13:57:19 +0200425 ASSERT_COMPARE( expected_oid, expected_oid_length, oid, oid_length );
Gilles Peskinedd2f95b2018-08-11 01:22:42 +0200426 return( 1 );
427
428exit:
429 return( 0 );
430}
431
432static int asn1_skip_integer( unsigned char **p, const unsigned char *end,
433 size_t min_bits, size_t max_bits,
434 int must_be_odd )
435{
436 size_t len;
437 size_t actual_bits;
438 unsigned char msb;
439 TEST_ASSERT( mbedtls_asn1_get_tag( p, end, &len,
440 MBEDTLS_ASN1_INTEGER ) == 0 );
441 /* Tolerate a slight departure from DER encoding:
442 * - 0 may be represented by an empty string or a 1-byte string.
443 * - The sign bit may be used as a value bit. */
444 if( ( len == 1 && ( *p )[0] == 0 ) ||
445 ( len > 1 && ( *p )[0] == 0 && ( ( *p )[1] & 0x80 ) != 0 ) )
446 {
447 ++( *p );
448 --len;
449 }
450 if( min_bits == 0 && len == 0 )
451 return( 1 );
452 msb = ( *p )[0];
453 TEST_ASSERT( msb != 0 );
454 actual_bits = 8 * ( len - 1 );
455 while( msb != 0 )
456 {
457 msb >>= 1;
458 ++actual_bits;
459 }
460 TEST_ASSERT( actual_bits >= min_bits );
461 TEST_ASSERT( actual_bits <= max_bits );
462 if( must_be_odd )
463 TEST_ASSERT( ( ( *p )[len-1] & 1 ) != 0 );
464 *p += len;
465 return( 1 );
466exit:
467 return( 0 );
468}
469
470static int asn1_get_implicit_tag( unsigned char **p, const unsigned char *end,
471 size_t *len,
472 unsigned char n, unsigned char tag )
473{
474 int ret;
475 ret = mbedtls_asn1_get_tag( p, end, len,
476 MBEDTLS_ASN1_CONTEXT_SPECIFIC |
477 MBEDTLS_ASN1_CONSTRUCTED | ( n ) );
478 if( ret != 0 )
479 return( ret );
480 end = *p + *len;
481 ret = mbedtls_asn1_get_tag( p, end, len, tag );
482 if( ret != 0 )
483 return( ret );
484 if( *p + *len != end )
485 return( MBEDTLS_ERR_ASN1_LENGTH_MISMATCH );
486 return( 0 );
487}
488
489static int exported_key_sanity_check( psa_key_type_t type, size_t bits,
490 uint8_t *exported, size_t exported_length )
491{
492 if( PSA_KEY_TYPE_IS_UNSTRUCTURED( type ) )
Gilles Peskined14664a2018-08-10 19:07:32 +0200493 TEST_ASSERT( exported_length == ( bits + 7 ) / 8 );
Gilles Peskinedd2f95b2018-08-11 01:22:42 +0200494 else
495 TEST_ASSERT( exported_length <= PSA_KEY_EXPORT_MAX_SIZE( type, bits ) );
Gilles Peskined14664a2018-08-10 19:07:32 +0200496
497#if defined(MBEDTLS_DES_C)
498 if( type == PSA_KEY_TYPE_DES )
499 {
500 /* Check the parity bits. */
501 unsigned i;
502 for( i = 0; i < bits / 8; i++ )
503 {
504 unsigned bit_count = 0;
505 unsigned m;
506 for( m = 1; m <= 0x100; m <<= 1 )
507 {
508 if( exported[i] & m )
509 ++bit_count;
510 }
511 TEST_ASSERT( bit_count % 2 != 0 );
512 }
513 }
Gilles Peskinedd2f95b2018-08-11 01:22:42 +0200514 else
Gilles Peskined14664a2018-08-10 19:07:32 +0200515#endif
516
517#if defined(MBEDTLS_RSA_C) && defined(MBEDTLS_PK_PARSE_C)
518 if( type == PSA_KEY_TYPE_RSA_KEYPAIR )
519 {
Gilles Peskinedd2f95b2018-08-11 01:22:42 +0200520 uint8_t *p = exported;
521 uint8_t *end = exported + exported_length;
522 size_t len;
523 /* RSAPrivateKey ::= SEQUENCE {
Gilles Peskinedea46cf2018-08-21 16:12:54 +0200524 * version INTEGER, -- must be 0
Gilles Peskinedd2f95b2018-08-11 01:22:42 +0200525 * modulus INTEGER, -- n
526 * publicExponent INTEGER, -- e
527 * privateExponent INTEGER, -- d
528 * prime1 INTEGER, -- p
529 * prime2 INTEGER, -- q
530 * exponent1 INTEGER, -- d mod (p-1)
531 * exponent2 INTEGER, -- d mod (q-1)
532 * coefficient INTEGER, -- (inverse of q) mod p
533 * }
534 */
535 TEST_ASSERT( mbedtls_asn1_get_tag( &p, end, &len,
536 MBEDTLS_ASN1_SEQUENCE |
537 MBEDTLS_ASN1_CONSTRUCTED ) == 0 );
538 TEST_ASSERT( p + len == end );
539 if( ! asn1_skip_integer( &p, end, 0, 0, 0 ) )
540 goto exit;
541 if( ! asn1_skip_integer( &p, end, bits, bits, 1 ) )
542 goto exit;
543 if( ! asn1_skip_integer( &p, end, 2, bits, 1 ) )
544 goto exit;
545 /* Require d to be at least half the size of n. */
546 if( ! asn1_skip_integer( &p, end, bits / 2, bits, 1 ) )
547 goto exit;
548 /* Require p and q to be at most half the size of n, rounded up. */
549 if( ! asn1_skip_integer( &p, end, bits / 2, bits / 2 + 1, 1 ) )
550 goto exit;
551 if( ! asn1_skip_integer( &p, end, bits / 2, bits / 2 + 1, 1 ) )
552 goto exit;
553 if( ! asn1_skip_integer( &p, end, 1, bits / 2 + 1, 0 ) )
554 goto exit;
555 if( ! asn1_skip_integer( &p, end, 1, bits / 2 + 1, 0 ) )
556 goto exit;
557 if( ! asn1_skip_integer( &p, end, 1, bits / 2 + 1, 0 ) )
558 goto exit;
559 TEST_ASSERT( p == end );
560 }
561 else
Gilles Peskined14664a2018-08-10 19:07:32 +0200562#endif /* MBEDTLS_RSA_C */
563
564#if defined(MBEDTLS_ECP_C)
565 if( PSA_KEY_TYPE_IS_ECC_KEYPAIR( type ) )
566 {
Gilles Peskinedd2f95b2018-08-11 01:22:42 +0200567 uint8_t *p = exported;
568 uint8_t *end = exported + exported_length;
569 size_t len;
570 int version;
571 /* ECPrivateKey ::= SEQUENCE {
572 * version INTEGER, -- must be 1
573 * privateKey OCTET STRING,
574 * -- `ceiling(log_{256}(n))`-byte string, big endian,
575 * -- where n is the order of the curve.
576 * parameters ECParameters {{ NamedCurve }}, -- mandatory
577 * publicKey BIT STRING -- mandatory
578 * }
579 */
580 TEST_ASSERT( mbedtls_asn1_get_tag( &p, end, &len,
581 MBEDTLS_ASN1_SEQUENCE |
582 MBEDTLS_ASN1_CONSTRUCTED ) == 0 );
583 TEST_ASSERT( p + len == end );
584 TEST_ASSERT( mbedtls_asn1_get_int( &p, end, &version ) == 0 );
585 TEST_ASSERT( version == 1 );
586 TEST_ASSERT( mbedtls_asn1_get_tag( &p, end, &len,
587 MBEDTLS_ASN1_OCTET_STRING ) == 0 );
588 /* Bug in Mbed TLS: the length of the octet string depends on the value */
589 // TEST_ASSERT( len == PSA_BITS_TO_BYTES( bits ) );
590 p += len;
591 TEST_ASSERT( asn1_get_implicit_tag( &p, end, &len, 0,
592 MBEDTLS_ASN1_OID ) == 0 );
593 p += len;
Gilles Peskinec6290c02018-08-13 17:24:59 +0200594 /* publicKey: ECPoint in uncompressed representation (as below) */
Gilles Peskinedd2f95b2018-08-11 01:22:42 +0200595 TEST_ASSERT( asn1_get_implicit_tag( &p, end, &len, 1,
596 MBEDTLS_ASN1_BIT_STRING ) == 0 );
597 TEST_ASSERT( p + len == end );
598 TEST_ASSERT( p[0] == 0 ); /* 0 unused bits in the bit string */
599 ++p;
600 TEST_ASSERT( p + 1 + 2 * PSA_BITS_TO_BYTES( bits ) == end );
601 TEST_ASSERT( p[0] == 4 );
602 }
603 else
Gilles Peskined14664a2018-08-10 19:07:32 +0200604#endif /* MBEDTLS_ECP_C */
605
Gilles Peskinedd2f95b2018-08-11 01:22:42 +0200606 if( PSA_KEY_TYPE_IS_PUBLIC_KEY( type ) )
607 {
608 uint8_t *p = exported;
609 uint8_t *end = exported + exported_length;
610 size_t len;
611 mbedtls_asn1_buf alg;
612 mbedtls_asn1_buf params;
613 mbedtls_asn1_bitstring bitstring;
614 /* SubjectPublicKeyInfo ::= SEQUENCE {
615 * algorithm AlgorithmIdentifier,
616 * subjectPublicKey BIT STRING }
617 * AlgorithmIdentifier ::= SEQUENCE {
618 * algorithm OBJECT IDENTIFIER,
619 * parameters ANY DEFINED BY algorithm OPTIONAL }
620 */
621 TEST_ASSERT( mbedtls_asn1_get_tag( &p, end, &len,
622 MBEDTLS_ASN1_SEQUENCE |
623 MBEDTLS_ASN1_CONSTRUCTED ) == 0 );
624 TEST_ASSERT( p + len == end );
625 TEST_ASSERT( mbedtls_asn1_get_alg( &p, end, &alg, &params ) == 0 );
626 if( ! is_oid_of_key_type( type, alg.p, alg.len ) )
627 goto exit;
628 TEST_ASSERT( mbedtls_asn1_get_bitstring( &p, end, &bitstring ) == 0 );
629 TEST_ASSERT( p == end );
630 p = bitstring.p;
631#if defined(MBEDTLS_RSA_C)
632 if( type == PSA_KEY_TYPE_RSA_PUBLIC_KEY )
633 {
634 /* RSAPublicKey ::= SEQUENCE {
635 * modulus INTEGER, -- n
636 * publicExponent INTEGER } -- e
637 */
638 TEST_ASSERT( bitstring.unused_bits == 0 );
639 TEST_ASSERT( mbedtls_asn1_get_tag( &p, end, &len,
640 MBEDTLS_ASN1_SEQUENCE |
641 MBEDTLS_ASN1_CONSTRUCTED ) == 0 );
642 TEST_ASSERT( p + len == end );
643 if( ! asn1_skip_integer( &p, end, bits, bits, 1 ) )
644 goto exit;
645 if( ! asn1_skip_integer( &p, end, 2, bits, 1 ) )
646 goto exit;
647 TEST_ASSERT( p == end );
648 }
649 else
650#endif /* MBEDTLS_RSA_C */
651#if defined(MBEDTLS_ECP_C)
652 if( PSA_KEY_TYPE_IS_ECC_PUBLIC_KEY( type ) )
653 {
654 /* ECPoint ::= ...
Gilles Peskinec6290c02018-08-13 17:24:59 +0200655 * -- first 8 bits: 0x04 (uncompressed representation);
Gilles Peskinedd2f95b2018-08-11 01:22:42 +0200656 * -- then x_P as an n-bit string, big endian;
657 * -- then y_P as a n-bit string, big endian,
658 * -- where n is the order of the curve.
659 */
660 TEST_ASSERT( bitstring.unused_bits == 0 );
661 TEST_ASSERT( p + 1 + 2 * PSA_BITS_TO_BYTES( bits ) == end );
662 TEST_ASSERT( p[0] == 4 );
663 }
664 else
665#endif /* MBEDTLS_ECP_C */
666 {
667 char message[40];
668 mbedtls_snprintf( message, sizeof( message ),
669 "No sanity check for public key type=0x%08lx",
670 (unsigned long) type );
671 test_fail( message, __LINE__, __FILE__ );
672 return( 0 );
673 }
674 }
675 else
676
677 {
678 /* No sanity checks for other types */
679 }
680
681 return( 1 );
Gilles Peskined14664a2018-08-10 19:07:32 +0200682
683exit:
Gilles Peskinedd2f95b2018-08-11 01:22:42 +0200684 return( 0 );
Gilles Peskined14664a2018-08-10 19:07:32 +0200685}
686
687static int exercise_export_key( psa_key_slot_t slot,
688 psa_key_usage_t usage )
689{
690 psa_key_type_t type;
691 size_t bits;
692 uint8_t *exported = NULL;
693 size_t exported_size = 0;
694 size_t exported_length = 0;
695 int ok = 0;
696
Gilles Peskineacec7b6f2018-09-13 20:34:11 +0200697 TEST_ASSERT( psa_get_key_information( slot, &type, &bits ) == PSA_SUCCESS );
698
699 if( ( usage & PSA_KEY_USAGE_EXPORT ) == 0 &&
700 ! PSA_KEY_TYPE_IS_PUBLIC_KEY( type ) )
Gilles Peskined14664a2018-08-10 19:07:32 +0200701 {
702 TEST_ASSERT( psa_export_key( slot, NULL, 0, &exported_length ) ==
703 PSA_ERROR_NOT_PERMITTED );
704 return( 1 );
705 }
706
Gilles Peskined14664a2018-08-10 19:07:32 +0200707 exported_size = PSA_KEY_EXPORT_MAX_SIZE( type, bits );
Gilles Peskine8cebbba2018-09-27 13:54:18 +0200708 ASSERT_ALLOC( exported, exported_size );
Gilles Peskined14664a2018-08-10 19:07:32 +0200709
710 TEST_ASSERT( psa_export_key( slot,
711 exported, exported_size,
712 &exported_length ) == PSA_SUCCESS );
713 ok = exported_key_sanity_check( type, bits, exported, exported_length );
714
715exit:
716 mbedtls_free( exported );
717 return( ok );
718}
719
720static int exercise_export_public_key( psa_key_slot_t slot )
721{
722 psa_key_type_t type;
723 psa_key_type_t public_type;
724 size_t bits;
725 uint8_t *exported = NULL;
726 size_t exported_size = 0;
727 size_t exported_length = 0;
728 int ok = 0;
729
730 TEST_ASSERT( psa_get_key_information( slot, &type, &bits ) == PSA_SUCCESS );
731 if( ! PSA_KEY_TYPE_IS_ASYMMETRIC( type ) )
732 {
733 TEST_ASSERT( psa_export_public_key( slot,
734 NULL, 0, &exported_length ) ==
735 PSA_ERROR_INVALID_ARGUMENT );
736 return( 1 );
737 }
738
739 public_type = PSA_KEY_TYPE_PUBLIC_KEY_OF_KEYPAIR( type );
740 exported_size = PSA_KEY_EXPORT_MAX_SIZE( public_type, bits );
Gilles Peskine8cebbba2018-09-27 13:54:18 +0200741 ASSERT_ALLOC( exported, exported_size );
Gilles Peskined14664a2018-08-10 19:07:32 +0200742
743 TEST_ASSERT( psa_export_public_key( slot,
744 exported, exported_size,
745 &exported_length ) == PSA_SUCCESS );
746 ok = exported_key_sanity_check( public_type, bits,
747 exported, exported_length );
748
749exit:
750 mbedtls_free( exported );
751 return( ok );
752}
753
Gilles Peskine02b75072018-07-01 22:31:34 +0200754static int exercise_key( psa_key_slot_t slot,
755 psa_key_usage_t usage,
756 psa_algorithm_t alg )
757{
758 int ok;
759 if( alg == 0 )
760 ok = 1; /* If no algorihm, do nothing (used for raw data "keys"). */
761 else if( PSA_ALG_IS_MAC( alg ) )
762 ok = exercise_mac_key( slot, usage, alg );
763 else if( PSA_ALG_IS_CIPHER( alg ) )
764 ok = exercise_cipher_key( slot, usage, alg );
765 else if( PSA_ALG_IS_AEAD( alg ) )
766 ok = exercise_aead_key( slot, usage, alg );
767 else if( PSA_ALG_IS_SIGN( alg ) )
768 ok = exercise_signature_key( slot, usage, alg );
769 else if( PSA_ALG_IS_ASYMMETRIC_ENCRYPTION( alg ) )
770 ok = exercise_asymmetric_encryption_key( slot, usage, alg );
Gilles Peskineea0fb492018-07-12 17:17:20 +0200771 else if( PSA_ALG_IS_KEY_DERIVATION( alg ) )
772 ok = exercise_key_derivation_key( slot, usage, alg );
Gilles Peskine02b75072018-07-01 22:31:34 +0200773 else
774 {
775 char message[40];
776 mbedtls_snprintf( message, sizeof( message ),
777 "No code to exercise alg=0x%08lx",
778 (unsigned long) alg );
779 test_fail( message, __LINE__, __FILE__ );
780 ok = 0;
781 }
Gilles Peskined14664a2018-08-10 19:07:32 +0200782
783 ok = ok && exercise_export_key( slot, usage );
784 ok = ok && exercise_export_public_key( slot );
785
Gilles Peskine02b75072018-07-01 22:31:34 +0200786 return( ok );
787}
788
Gilles Peskinee59236f2018-01-27 23:32:46 +0100789/* END_HEADER */
790
791/* BEGIN_DEPENDENCIES
792 * depends_on:MBEDTLS_PSA_CRYPTO_C
793 * END_DEPENDENCIES
794 */
795
796/* BEGIN_CASE */
Gilles Peskinee1f2d7d2018-08-21 14:54:54 +0200797void static_checks( )
798{
799 size_t max_truncated_mac_size =
800 PSA_ALG_MAC_TRUNCATION_MASK >> PSA_MAC_TRUNCATION_OFFSET;
801
802 /* Check that the length for a truncated MAC always fits in the algorithm
803 * encoding. The shifted mask is the maximum truncated value. The
804 * untruncated algorithm may be one byte larger. */
805 TEST_ASSERT( PSA_MAC_MAX_SIZE <= 1 + max_truncated_mac_size );
806}
807/* END_CASE */
808
809/* BEGIN_CASE */
Gilles Peskine2d277862018-06-18 15:41:12 +0200810void init_deinit( )
Gilles Peskinee59236f2018-01-27 23:32:46 +0100811{
Gilles Peskine2f9c4dc2018-01-28 13:16:24 +0100812 psa_status_t status;
Gilles Peskinee59236f2018-01-27 23:32:46 +0100813 int i;
814 for( i = 0; i <= 1; i++ )
815 {
Gilles Peskine2f9c4dc2018-01-28 13:16:24 +0100816 status = psa_crypto_init( );
817 TEST_ASSERT( status == PSA_SUCCESS );
818 status = psa_crypto_init( );
819 TEST_ASSERT( status == PSA_SUCCESS );
Gilles Peskinee59236f2018-01-27 23:32:46 +0100820 mbedtls_psa_crypto_free( );
821 }
822}
823/* END_CASE */
Gilles Peskine2f9c4dc2018-01-28 13:16:24 +0100824
825/* BEGIN_CASE */
Gilles Peskine996deb12018-08-01 15:45:45 +0200826void fill_slots( int max_arg )
827{
828 /* Fill all the slots until we run out of memory or out of slots,
829 * or until some limit specified in the test data for the sake of
830 * implementations with an essentially unlimited number of slots.
831 * This test assumes that available slots are numbered from 1. */
832
833 psa_key_slot_t slot;
834 psa_key_slot_t max = 0;
835 psa_key_policy_t policy;
836 uint8_t exported[sizeof( max )];
837 size_t exported_size;
838 psa_status_t status;
839
840 TEST_ASSERT( psa_crypto_init( ) == PSA_SUCCESS );
841
842 psa_key_policy_init( &policy );
843 psa_key_policy_set_usage( &policy, PSA_KEY_USAGE_EXPORT, 0 );
844
845 for( max = 1; max <= (size_t) max_arg; max++ )
846 {
847 status = psa_set_key_policy( max, &policy );
848 /* Stop filling slots if we run out of memory or out of
849 * available slots. */
850 TEST_ASSERT( status == PSA_SUCCESS ||
851 status == PSA_ERROR_INSUFFICIENT_MEMORY ||
852 status == PSA_ERROR_INVALID_ARGUMENT );
853 if( status != PSA_SUCCESS )
854 break;
855 status = psa_import_key( max, PSA_KEY_TYPE_RAW_DATA,
856 (uint8_t*) &max, sizeof( max ) );
857 /* Since psa_set_key_policy succeeded, we know that the slot
858 * number is valid. But we may legitimately run out of memory. */
859 TEST_ASSERT( status == PSA_SUCCESS ||
860 status == PSA_ERROR_INSUFFICIENT_MEMORY );
861 if( status != PSA_SUCCESS )
862 break;
863 }
864 /* `max` is now the first slot number that wasn't filled. */
865 max -= 1;
866
867 for( slot = 1; slot <= max; slot++ )
868 {
869 TEST_ASSERT( psa_export_key( slot,
870 exported, sizeof( exported ),
871 &exported_size ) == PSA_SUCCESS );
Gilles Peskinebd7dea92018-09-27 13:57:19 +0200872 ASSERT_COMPARE( &slot, sizeof( slot ), exported, exported_size );
Gilles Peskine996deb12018-08-01 15:45:45 +0200873 }
874
875exit:
Gilles Peskine9a056342018-08-01 15:46:54 +0200876 /* Do not destroy the keys. mbedtls_psa_crypto_free() should do it. */
Gilles Peskine996deb12018-08-01 15:45:45 +0200877 mbedtls_psa_crypto_free( );
878}
879/* END_CASE */
880
881/* BEGIN_CASE */
Gilles Peskineb866e2b2018-06-21 09:25:10 +0200882void import( data_t *data, int type, int expected_status_arg )
Gilles Peskine2f9c4dc2018-01-28 13:16:24 +0100883{
884 int slot = 1;
Gilles Peskineb866e2b2018-06-21 09:25:10 +0200885 psa_status_t expected_status = expected_status_arg;
Gilles Peskine2f9c4dc2018-01-28 13:16:24 +0100886 psa_status_t status;
Gilles Peskine2f9c4dc2018-01-28 13:16:24 +0100887
Gilles Peskine2f9c4dc2018-01-28 13:16:24 +0100888 TEST_ASSERT( data != NULL );
itayzafrir3e02b3b2018-06-12 17:06:52 +0300889 TEST_ASSERT( PSA_CRYPTO_TEST_SIZE_T_RANGE( data->len ) );
Gilles Peskine2f9c4dc2018-01-28 13:16:24 +0100890 TEST_ASSERT( psa_crypto_init( ) == PSA_SUCCESS );
891
Gilles Peskine4abf7412018-06-18 16:35:34 +0200892 status = psa_import_key( slot, type, data->x, data->len );
Gilles Peskineb866e2b2018-06-21 09:25:10 +0200893 TEST_ASSERT( status == expected_status );
Gilles Peskine2f9c4dc2018-01-28 13:16:24 +0100894 if( status == PSA_SUCCESS )
895 TEST_ASSERT( psa_destroy_key( slot ) == PSA_SUCCESS );
896
897exit:
Gilles Peskine2f9c4dc2018-01-28 13:16:24 +0100898 mbedtls_psa_crypto_free( );
899}
900/* END_CASE */
901
902/* BEGIN_CASE */
Gilles Peskine0b352bc2018-06-28 00:16:11 +0200903void import_rsa_made_up( int bits_arg, int keypair, int expected_status_arg )
904{
905 int slot = 1;
906 size_t bits = bits_arg;
907 psa_status_t expected_status = expected_status_arg;
908 psa_status_t status;
909 psa_key_type_t type =
910 keypair ? PSA_KEY_TYPE_RSA_KEYPAIR : PSA_KEY_TYPE_RSA_PUBLIC_KEY;
911 size_t buffer_size = /* Slight overapproximations */
912 keypair ? bits * 9 / 16 + 80 : bits / 8 + 20;
Gilles Peskine8cebbba2018-09-27 13:54:18 +0200913 unsigned char *buffer = NULL;
Gilles Peskine0b352bc2018-06-28 00:16:11 +0200914 unsigned char *p;
915 int ret;
916 size_t length;
917
918 TEST_ASSERT( psa_crypto_init( ) == PSA_SUCCESS );
Gilles Peskine8cebbba2018-09-27 13:54:18 +0200919 ASSERT_ALLOC( buffer, buffer_size );
Gilles Peskine0b352bc2018-06-28 00:16:11 +0200920
921 TEST_ASSERT( ( ret = construct_fake_rsa_key( buffer, buffer_size, &p,
922 bits, keypair ) ) >= 0 );
923 length = ret;
924
925 /* Try importing the key */
926 status = psa_import_key( slot, type, p, length );
927 TEST_ASSERT( status == expected_status );
928 if( status == PSA_SUCCESS )
929 TEST_ASSERT( psa_destroy_key( slot ) == PSA_SUCCESS );
930
931exit:
932 mbedtls_free( buffer );
933 mbedtls_psa_crypto_free( );
934}
935/* END_CASE */
936
937/* BEGIN_CASE */
itayzafrir3e02b3b2018-06-12 17:06:52 +0300938void import_export( data_t *data,
Moran Pekera964a8f2018-06-04 18:42:36 +0300939 int type_arg,
940 int alg_arg,
941 int usage_arg,
Gilles Peskine2f9c4dc2018-01-28 13:16:24 +0100942 int expected_bits,
943 int export_size_delta,
Gilles Peskineb866e2b2018-06-21 09:25:10 +0200944 int expected_export_status_arg,
Gilles Peskine2f9c4dc2018-01-28 13:16:24 +0100945 int canonical_input )
946{
947 int slot = 1;
948 int slot2 = slot + 1;
949 psa_key_type_t type = type_arg;
Gilles Peskine4abf7412018-06-18 16:35:34 +0200950 psa_algorithm_t alg = alg_arg;
Gilles Peskineb866e2b2018-06-21 09:25:10 +0200951 psa_status_t expected_export_status = expected_export_status_arg;
Gilles Peskine2f9c4dc2018-01-28 13:16:24 +0100952 psa_status_t status;
Gilles Peskine2f9c4dc2018-01-28 13:16:24 +0100953 unsigned char *exported = NULL;
954 unsigned char *reexported = NULL;
Gilles Peskine2f9c4dc2018-01-28 13:16:24 +0100955 size_t export_size;
Jaeden Amerof24c7f82018-06-27 17:20:43 +0100956 size_t exported_length = INVALID_EXPORT_LENGTH;
Gilles Peskine2f9c4dc2018-01-28 13:16:24 +0100957 size_t reexported_length;
958 psa_key_type_t got_type;
959 size_t got_bits;
Gilles Peskinedec72612018-06-18 18:12:37 +0200960 psa_key_policy_t policy;
Gilles Peskine2f9c4dc2018-01-28 13:16:24 +0100961
Gilles Peskine2f9c4dc2018-01-28 13:16:24 +0100962 TEST_ASSERT( data != NULL );
itayzafrir3e02b3b2018-06-12 17:06:52 +0300963 TEST_ASSERT( PSA_CRYPTO_TEST_SIZE_T_RANGE( data->len ) );
Moran Pekercb088e72018-07-17 17:36:59 +0300964 export_size = (ptrdiff_t) data->len + export_size_delta;
Gilles Peskine8cebbba2018-09-27 13:54:18 +0200965 ASSERT_ALLOC( exported, export_size );
Gilles Peskine2f9c4dc2018-01-28 13:16:24 +0100966 if( ! canonical_input )
Gilles Peskine8cebbba2018-09-27 13:54:18 +0200967 ASSERT_ALLOC( reexported, export_size );
Gilles Peskine2f9c4dc2018-01-28 13:16:24 +0100968 TEST_ASSERT( psa_crypto_init( ) == PSA_SUCCESS );
969
mohammad1603a97cb8c2018-03-28 03:46:26 -0700970 psa_key_policy_init( &policy );
Gilles Peskine4abf7412018-06-18 16:35:34 +0200971 psa_key_policy_set_usage( &policy, usage_arg, alg );
mohammad1603a97cb8c2018-03-28 03:46:26 -0700972 TEST_ASSERT( psa_set_key_policy( slot, &policy ) == PSA_SUCCESS );
973
Gilles Peskine2f9c4dc2018-01-28 13:16:24 +0100974 /* Import the key */
975 TEST_ASSERT( psa_import_key( slot, type,
Gilles Peskine4abf7412018-06-18 16:35:34 +0200976 data->x, data->len ) == PSA_SUCCESS );
Gilles Peskine2f9c4dc2018-01-28 13:16:24 +0100977
978 /* Test the key information */
979 TEST_ASSERT( psa_get_key_information( slot,
Gilles Peskine4abf7412018-06-18 16:35:34 +0200980 &got_type,
981 &got_bits ) == PSA_SUCCESS );
Gilles Peskine2f9c4dc2018-01-28 13:16:24 +0100982 TEST_ASSERT( got_type == type );
983 TEST_ASSERT( got_bits == (size_t) expected_bits );
984
985 /* Export the key */
986 status = psa_export_key( slot,
987 exported, export_size,
988 &exported_length );
Gilles Peskineb866e2b2018-06-21 09:25:10 +0200989 TEST_ASSERT( status == expected_export_status );
Jaeden Amerof24c7f82018-06-27 17:20:43 +0100990
991 /* The exported length must be set by psa_export_key() to a value between 0
992 * and export_size. On errors, the exported length must be 0. */
993 TEST_ASSERT( exported_length != INVALID_EXPORT_LENGTH );
994 TEST_ASSERT( status == PSA_SUCCESS || exported_length == 0 );
995 TEST_ASSERT( exported_length <= export_size );
996
Gilles Peskinea7aa4422018-08-14 15:17:54 +0200997 TEST_ASSERT( mem_is_char( exported + exported_length, 0,
Gilles Peskine3f669c32018-06-21 09:21:51 +0200998 export_size - exported_length ) );
Gilles Peskine2f9c4dc2018-01-28 13:16:24 +0100999 if( status != PSA_SUCCESS )
Gilles Peskinee66ca3b2018-06-20 00:11:45 +02001000 {
1001 TEST_ASSERT( exported_length == 0 );
Gilles Peskine2f9c4dc2018-01-28 13:16:24 +01001002 goto destroy;
Gilles Peskinee66ca3b2018-06-20 00:11:45 +02001003 }
Gilles Peskine2f9c4dc2018-01-28 13:16:24 +01001004
Gilles Peskine8f609232018-08-11 01:24:55 +02001005 if( ! exercise_export_key( slot, usage_arg ) )
1006 goto exit;
1007
Gilles Peskine2f9c4dc2018-01-28 13:16:24 +01001008 if( canonical_input )
Gilles Peskinebd7dea92018-09-27 13:57:19 +02001009 ASSERT_COMPARE( data->x, data->len, exported, exported_length );
Gilles Peskine2f9c4dc2018-01-28 13:16:24 +01001010 else
1011 {
mohammad1603a97cb8c2018-03-28 03:46:26 -07001012 TEST_ASSERT( psa_set_key_policy( slot2, &policy ) == PSA_SUCCESS );
1013
Gilles Peskine2f9c4dc2018-01-28 13:16:24 +01001014 TEST_ASSERT( psa_import_key( slot2, type,
Gilles Peskine4abf7412018-06-18 16:35:34 +02001015 exported,
Gilles Peskineb67f3082018-08-07 15:33:10 +02001016 exported_length ) == PSA_SUCCESS );
Gilles Peskine2f9c4dc2018-01-28 13:16:24 +01001017 TEST_ASSERT( psa_export_key( slot2,
Gilles Peskine4abf7412018-06-18 16:35:34 +02001018 reexported,
1019 export_size,
1020 &reexported_length ) == PSA_SUCCESS );
Gilles Peskinebd7dea92018-09-27 13:57:19 +02001021 ASSERT_COMPARE( exported, exported_length,
1022 reexported, reexported_length );
Gilles Peskine2f9c4dc2018-01-28 13:16:24 +01001023 }
1024
1025destroy:
1026 /* Destroy the key */
1027 TEST_ASSERT( psa_destroy_key( slot ) == PSA_SUCCESS );
1028 TEST_ASSERT( psa_get_key_information(
1029 slot, NULL, NULL ) == PSA_ERROR_EMPTY_SLOT );
1030
1031exit:
itayzafrir3e02b3b2018-06-12 17:06:52 +03001032 mbedtls_free( exported );
1033 mbedtls_free( reexported );
Gilles Peskine2f9c4dc2018-01-28 13:16:24 +01001034 mbedtls_psa_crypto_free( );
1035}
1036/* END_CASE */
Gilles Peskine20035e32018-02-03 22:44:14 +01001037
Moran Pekerf709f4a2018-06-06 17:26:04 +03001038/* BEGIN_CASE */
itayzafrir3e02b3b2018-06-12 17:06:52 +03001039void import_export_public_key( data_t *data,
Gilles Peskine2d277862018-06-18 15:41:12 +02001040 int type_arg,
1041 int alg_arg,
1042 int expected_bits,
1043 int public_key_expected_length,
Gilles Peskineb866e2b2018-06-21 09:25:10 +02001044 int expected_export_status_arg )
Moran Pekerf709f4a2018-06-06 17:26:04 +03001045{
1046 int slot = 1;
1047 psa_key_type_t type = type_arg;
Gilles Peskine4abf7412018-06-18 16:35:34 +02001048 psa_algorithm_t alg = alg_arg;
Gilles Peskineb866e2b2018-06-21 09:25:10 +02001049 psa_status_t expected_export_status = expected_export_status_arg;
Moran Pekerf709f4a2018-06-06 17:26:04 +03001050 psa_status_t status;
Moran Pekerf709f4a2018-06-06 17:26:04 +03001051 unsigned char *exported = NULL;
Moran Pekerf709f4a2018-06-06 17:26:04 +03001052 size_t export_size;
Jaeden Amero2a671e92018-06-27 17:47:40 +01001053 size_t exported_length = INVALID_EXPORT_LENGTH;
Moran Pekerf709f4a2018-06-06 17:26:04 +03001054 psa_key_type_t got_type;
1055 size_t got_bits;
Gilles Peskinedec72612018-06-18 18:12:37 +02001056 psa_key_policy_t policy;
Moran Pekerf709f4a2018-06-06 17:26:04 +03001057
Moran Pekerf709f4a2018-06-06 17:26:04 +03001058 TEST_ASSERT( data != NULL );
itayzafrir3e02b3b2018-06-12 17:06:52 +03001059 TEST_ASSERT( PSA_CRYPTO_TEST_SIZE_T_RANGE( data->len ) );
Moran Pekercb088e72018-07-17 17:36:59 +03001060 export_size = (ptrdiff_t) data->len;
Gilles Peskine8cebbba2018-09-27 13:54:18 +02001061 ASSERT_ALLOC( exported, export_size );
Moran Pekerf709f4a2018-06-06 17:26:04 +03001062
1063 TEST_ASSERT( psa_crypto_init( ) == PSA_SUCCESS );
1064
1065 psa_key_policy_init( &policy );
Gilles Peskine4abf7412018-06-18 16:35:34 +02001066 psa_key_policy_set_usage( &policy, PSA_KEY_USAGE_EXPORT, alg );
Moran Pekerf709f4a2018-06-06 17:26:04 +03001067 TEST_ASSERT( psa_set_key_policy( slot, &policy ) == PSA_SUCCESS );
1068
1069 /* Import the key */
1070 TEST_ASSERT( psa_import_key( slot, type,
Gilles Peskine4abf7412018-06-18 16:35:34 +02001071 data->x, data->len ) == PSA_SUCCESS );
Moran Pekerf709f4a2018-06-06 17:26:04 +03001072
1073 /* Test the key information */
1074 TEST_ASSERT( psa_get_key_information( slot,
Gilles Peskinec1bb6c82018-06-18 16:04:39 +02001075 &got_type,
1076 &got_bits ) == PSA_SUCCESS );
Moran Pekerf709f4a2018-06-06 17:26:04 +03001077 TEST_ASSERT( got_type == type );
1078 TEST_ASSERT( got_bits == (size_t) expected_bits );
1079
1080 /* Export the key */
1081 status = psa_export_public_key( slot,
Gilles Peskine2d277862018-06-18 15:41:12 +02001082 exported, export_size,
1083 &exported_length );
Gilles Peskineb866e2b2018-06-21 09:25:10 +02001084 TEST_ASSERT( status == expected_export_status );
Jaeden Amero2a671e92018-06-27 17:47:40 +01001085 TEST_ASSERT( exported_length == (size_t) public_key_expected_length );
Gilles Peskinea7aa4422018-08-14 15:17:54 +02001086 TEST_ASSERT( mem_is_char( exported + exported_length, 0,
Jaeden Amero2a671e92018-06-27 17:47:40 +01001087 export_size - exported_length ) );
Moran Pekerf709f4a2018-06-06 17:26:04 +03001088 if( status != PSA_SUCCESS )
1089 goto destroy;
1090
Moran Pekerf709f4a2018-06-06 17:26:04 +03001091destroy:
1092 /* Destroy the key */
1093 TEST_ASSERT( psa_destroy_key( slot ) == PSA_SUCCESS );
1094 TEST_ASSERT( psa_get_key_information(
1095 slot, NULL, NULL ) == PSA_ERROR_EMPTY_SLOT );
1096
1097exit:
itayzafrir3e02b3b2018-06-12 17:06:52 +03001098 mbedtls_free( exported );
Moran Pekerf709f4a2018-06-06 17:26:04 +03001099 mbedtls_psa_crypto_free( );
1100}
1101/* END_CASE */
1102
Gilles Peskine20035e32018-02-03 22:44:14 +01001103/* BEGIN_CASE */
Gilles Peskinea680c7a2018-06-26 16:12:43 +02001104void import_and_exercise_key( data_t *data,
1105 int type_arg,
1106 int bits_arg,
1107 int alg_arg )
1108{
1109 int slot = 1;
1110 psa_key_type_t type = type_arg;
1111 size_t bits = bits_arg;
1112 psa_algorithm_t alg = alg_arg;
1113 psa_key_usage_t usage =
1114 ( PSA_ALG_IS_MAC( alg ) || PSA_ALG_IS_SIGN( alg ) ?
1115 ( PSA_KEY_TYPE_IS_PUBLIC_KEY( type ) ?
1116 PSA_KEY_USAGE_VERIFY :
1117 PSA_KEY_USAGE_SIGN | PSA_KEY_USAGE_VERIFY ) :
1118 PSA_ALG_IS_CIPHER( alg ) || PSA_ALG_IS_AEAD( alg ) ||
1119 PSA_ALG_IS_ASYMMETRIC_ENCRYPTION( alg ) ?
1120 ( PSA_KEY_TYPE_IS_PUBLIC_KEY( type ) ?
1121 PSA_KEY_USAGE_ENCRYPT :
1122 PSA_KEY_USAGE_ENCRYPT | PSA_KEY_USAGE_DECRYPT ) :
Gilles Peskineea0fb492018-07-12 17:17:20 +02001123 PSA_ALG_IS_KEY_DERIVATION( alg ) ? PSA_KEY_USAGE_DERIVE :
Gilles Peskinea680c7a2018-06-26 16:12:43 +02001124 0 );
1125 psa_key_policy_t policy;
1126 psa_key_type_t got_type;
1127 size_t got_bits;
1128 psa_status_t status;
1129
1130 TEST_ASSERT( psa_crypto_init( ) == PSA_SUCCESS );
1131
1132 psa_key_policy_init( &policy );
1133 psa_key_policy_set_usage( &policy, usage, alg );
1134 TEST_ASSERT( psa_set_key_policy( slot, &policy ) == PSA_SUCCESS );
1135
1136 /* Import the key */
1137 status = psa_import_key( slot, type, data->x, data->len );
1138 TEST_ASSERT( status == PSA_SUCCESS );
1139
1140 /* Test the key information */
1141 TEST_ASSERT( psa_get_key_information( slot,
1142 &got_type,
1143 &got_bits ) == PSA_SUCCESS );
1144 TEST_ASSERT( got_type == type );
1145 TEST_ASSERT( got_bits == bits );
1146
1147 /* Do something with the key according to its type and permitted usage. */
Gilles Peskine02b75072018-07-01 22:31:34 +02001148 if( ! exercise_key( slot, usage, alg ) )
1149 goto exit;
Gilles Peskinea680c7a2018-06-26 16:12:43 +02001150
1151exit:
1152 psa_destroy_key( slot );
1153 mbedtls_psa_crypto_free( );
1154}
1155/* END_CASE */
1156
1157/* BEGIN_CASE */
Gilles Peskined5b33222018-06-18 22:20:03 +02001158void key_policy( int usage_arg, int alg_arg )
1159{
1160 int key_slot = 1;
1161 psa_algorithm_t alg = alg_arg;
1162 psa_key_usage_t usage = usage_arg;
1163 psa_key_type_t key_type = PSA_KEY_TYPE_AES;
1164 unsigned char key[32] = {0};
1165 psa_key_policy_t policy_set;
1166 psa_key_policy_t policy_get;
1167
1168 memset( key, 0x2a, sizeof( key ) );
1169
1170 TEST_ASSERT( psa_crypto_init( ) == PSA_SUCCESS );
1171
1172 psa_key_policy_init( &policy_set );
1173 psa_key_policy_init( &policy_get );
1174
1175 psa_key_policy_set_usage( &policy_set, usage, alg );
1176
1177 TEST_ASSERT( psa_key_policy_get_usage( &policy_set ) == usage );
1178 TEST_ASSERT( psa_key_policy_get_algorithm( &policy_set ) == alg );
1179 TEST_ASSERT( psa_set_key_policy( key_slot, &policy_set ) == PSA_SUCCESS );
1180
1181 TEST_ASSERT( psa_import_key( key_slot, key_type,
1182 key, sizeof( key ) ) == PSA_SUCCESS );
1183
1184 TEST_ASSERT( psa_get_key_policy( key_slot, &policy_get ) == PSA_SUCCESS );
1185
1186 TEST_ASSERT( policy_get.usage == policy_set.usage );
1187 TEST_ASSERT( policy_get.alg == policy_set.alg );
1188
1189exit:
1190 psa_destroy_key( key_slot );
1191 mbedtls_psa_crypto_free( );
1192}
1193/* END_CASE */
1194
1195/* BEGIN_CASE */
Gilles Peskine76f5c7b2018-07-06 16:53:09 +02001196void mac_key_policy( int policy_usage,
1197 int policy_alg,
1198 int key_type,
1199 data_t *key_data,
1200 int exercise_alg )
Gilles Peskined5b33222018-06-18 22:20:03 +02001201{
1202 int key_slot = 1;
Gilles Peskined5b33222018-06-18 22:20:03 +02001203 psa_key_policy_t policy;
Gilles Peskine76f5c7b2018-07-06 16:53:09 +02001204 psa_mac_operation_t operation;
1205 psa_status_t status;
1206 unsigned char mac[PSA_MAC_MAX_SIZE];
Gilles Peskined5b33222018-06-18 22:20:03 +02001207
1208 TEST_ASSERT( psa_crypto_init( ) == PSA_SUCCESS );
1209
1210 psa_key_policy_init( &policy );
Gilles Peskine76f5c7b2018-07-06 16:53:09 +02001211 psa_key_policy_set_usage( &policy, policy_usage, policy_alg );
Gilles Peskined5b33222018-06-18 22:20:03 +02001212 TEST_ASSERT( psa_set_key_policy( key_slot, &policy ) == PSA_SUCCESS );
1213
Gilles Peskine76f5c7b2018-07-06 16:53:09 +02001214 TEST_ASSERT( psa_import_key( key_slot, key_type,
1215 key_data->x, key_data->len ) == PSA_SUCCESS );
Gilles Peskined5b33222018-06-18 22:20:03 +02001216
Gilles Peskine89167cb2018-07-08 20:12:23 +02001217 status = psa_mac_sign_setup( &operation, key_slot, exercise_alg );
Gilles Peskine76f5c7b2018-07-06 16:53:09 +02001218 if( policy_alg == exercise_alg &&
1219 ( policy_usage & PSA_KEY_USAGE_SIGN ) != 0 )
1220 TEST_ASSERT( status == PSA_SUCCESS );
1221 else
1222 TEST_ASSERT( status == PSA_ERROR_NOT_PERMITTED );
1223 psa_mac_abort( &operation );
Gilles Peskined5b33222018-06-18 22:20:03 +02001224
Gilles Peskine76f5c7b2018-07-06 16:53:09 +02001225 memset( mac, 0, sizeof( mac ) );
Gilles Peskine89167cb2018-07-08 20:12:23 +02001226 status = psa_mac_verify_setup( &operation, key_slot, exercise_alg );
Gilles Peskine76f5c7b2018-07-06 16:53:09 +02001227 if( policy_alg == exercise_alg &&
1228 ( policy_usage & PSA_KEY_USAGE_VERIFY ) != 0 )
Gilles Peskine89167cb2018-07-08 20:12:23 +02001229 TEST_ASSERT( status == PSA_SUCCESS );
Gilles Peskine76f5c7b2018-07-06 16:53:09 +02001230 else
1231 TEST_ASSERT( status == PSA_ERROR_NOT_PERMITTED );
1232
1233exit:
1234 psa_mac_abort( &operation );
1235 psa_destroy_key( key_slot );
1236 mbedtls_psa_crypto_free( );
1237}
1238/* END_CASE */
1239
1240/* BEGIN_CASE */
1241void cipher_key_policy( int policy_usage,
1242 int policy_alg,
1243 int key_type,
1244 data_t *key_data,
1245 int exercise_alg )
1246{
1247 int key_slot = 1;
1248 psa_key_policy_t policy;
1249 psa_cipher_operation_t operation;
1250 psa_status_t status;
1251
1252 TEST_ASSERT( psa_crypto_init( ) == PSA_SUCCESS );
1253
1254 psa_key_policy_init( &policy );
1255 psa_key_policy_set_usage( &policy, policy_usage, policy_alg );
1256 TEST_ASSERT( psa_set_key_policy( key_slot, &policy ) == PSA_SUCCESS );
1257
1258 TEST_ASSERT( psa_import_key( key_slot, key_type,
1259 key_data->x, key_data->len ) == PSA_SUCCESS );
1260
Gilles Peskinefe119512018-07-08 21:39:34 +02001261 status = psa_cipher_encrypt_setup( &operation, key_slot, exercise_alg );
Gilles Peskine76f5c7b2018-07-06 16:53:09 +02001262 if( policy_alg == exercise_alg &&
1263 ( policy_usage & PSA_KEY_USAGE_ENCRYPT ) != 0 )
1264 TEST_ASSERT( status == PSA_SUCCESS );
1265 else
1266 TEST_ASSERT( status == PSA_ERROR_NOT_PERMITTED );
1267 psa_cipher_abort( &operation );
1268
Gilles Peskinefe119512018-07-08 21:39:34 +02001269 status = psa_cipher_decrypt_setup( &operation, key_slot, exercise_alg );
Gilles Peskine76f5c7b2018-07-06 16:53:09 +02001270 if( policy_alg == exercise_alg &&
1271 ( policy_usage & PSA_KEY_USAGE_DECRYPT ) != 0 )
1272 TEST_ASSERT( status == PSA_SUCCESS );
1273 else
1274 TEST_ASSERT( status == PSA_ERROR_NOT_PERMITTED );
1275
1276exit:
1277 psa_cipher_abort( &operation );
1278 psa_destroy_key( key_slot );
1279 mbedtls_psa_crypto_free( );
1280}
1281/* END_CASE */
1282
1283/* BEGIN_CASE */
1284void aead_key_policy( int policy_usage,
1285 int policy_alg,
1286 int key_type,
1287 data_t *key_data,
1288 int nonce_length_arg,
1289 int tag_length_arg,
1290 int exercise_alg )
1291{
1292 int key_slot = 1;
1293 psa_key_policy_t policy;
1294 psa_status_t status;
1295 unsigned char nonce[16] = {0};
1296 size_t nonce_length = nonce_length_arg;
1297 unsigned char tag[16];
1298 size_t tag_length = tag_length_arg;
1299 size_t output_length;
1300
1301 TEST_ASSERT( nonce_length <= sizeof( nonce ) );
1302 TEST_ASSERT( tag_length <= sizeof( tag ) );
1303
1304 TEST_ASSERT( psa_crypto_init( ) == PSA_SUCCESS );
1305
1306 psa_key_policy_init( &policy );
1307 psa_key_policy_set_usage( &policy, policy_usage, policy_alg );
1308 TEST_ASSERT( psa_set_key_policy( key_slot, &policy ) == PSA_SUCCESS );
1309
1310 TEST_ASSERT( psa_import_key( key_slot, key_type,
1311 key_data->x, key_data->len ) == PSA_SUCCESS );
1312
1313 status = psa_aead_encrypt( key_slot, exercise_alg,
1314 nonce, nonce_length,
1315 NULL, 0,
1316 NULL, 0,
1317 tag, tag_length,
1318 &output_length );
1319 if( policy_alg == exercise_alg &&
1320 ( policy_usage & PSA_KEY_USAGE_ENCRYPT ) != 0 )
1321 TEST_ASSERT( status == PSA_SUCCESS );
1322 else
1323 TEST_ASSERT( status == PSA_ERROR_NOT_PERMITTED );
1324
1325 memset( tag, 0, sizeof( tag ) );
1326 status = psa_aead_decrypt( key_slot, exercise_alg,
1327 nonce, nonce_length,
1328 NULL, 0,
1329 tag, tag_length,
1330 NULL, 0,
1331 &output_length );
1332 if( policy_alg == exercise_alg &&
1333 ( policy_usage & PSA_KEY_USAGE_DECRYPT ) != 0 )
1334 TEST_ASSERT( status == PSA_ERROR_INVALID_SIGNATURE );
1335 else
1336 TEST_ASSERT( status == PSA_ERROR_NOT_PERMITTED );
1337
1338exit:
1339 psa_destroy_key( key_slot );
1340 mbedtls_psa_crypto_free( );
1341}
1342/* END_CASE */
1343
1344/* BEGIN_CASE */
1345void asymmetric_encryption_key_policy( int policy_usage,
1346 int policy_alg,
1347 int key_type,
1348 data_t *key_data,
1349 int exercise_alg )
1350{
1351 int key_slot = 1;
1352 psa_key_policy_t policy;
1353 psa_status_t status;
1354 size_t key_bits;
1355 size_t buffer_length;
1356 unsigned char *buffer = NULL;
1357 size_t output_length;
1358
1359 TEST_ASSERT( psa_crypto_init( ) == PSA_SUCCESS );
1360
1361 psa_key_policy_init( &policy );
1362 psa_key_policy_set_usage( &policy, policy_usage, policy_alg );
1363 TEST_ASSERT( psa_set_key_policy( key_slot, &policy ) == PSA_SUCCESS );
1364
1365 TEST_ASSERT( psa_import_key( key_slot, key_type,
1366 key_data->x, key_data->len ) == PSA_SUCCESS );
1367
1368 TEST_ASSERT( psa_get_key_information( key_slot,
1369 NULL,
1370 &key_bits ) == PSA_SUCCESS );
1371 buffer_length = PSA_ASYMMETRIC_ENCRYPT_OUTPUT_SIZE( key_type, key_bits,
1372 exercise_alg );
Gilles Peskine8cebbba2018-09-27 13:54:18 +02001373 ASSERT_ALLOC( buffer, buffer_length );
Gilles Peskine76f5c7b2018-07-06 16:53:09 +02001374
1375 status = psa_asymmetric_encrypt( key_slot, exercise_alg,
1376 NULL, 0,
1377 NULL, 0,
1378 buffer, buffer_length,
1379 &output_length );
1380 if( policy_alg == exercise_alg &&
1381 ( policy_usage & PSA_KEY_USAGE_ENCRYPT ) != 0 )
1382 TEST_ASSERT( status == PSA_SUCCESS );
1383 else
1384 TEST_ASSERT( status == PSA_ERROR_NOT_PERMITTED );
1385
Gilles Peskinef7ab5ad2018-09-26 18:19:24 +02001386 if( buffer_length != 0 )
1387 memset( buffer, 0, buffer_length );
Gilles Peskine76f5c7b2018-07-06 16:53:09 +02001388 status = psa_asymmetric_decrypt( key_slot, exercise_alg,
1389 buffer, buffer_length,
1390 NULL, 0,
1391 buffer, buffer_length,
1392 &output_length );
1393 if( policy_alg == exercise_alg &&
1394 ( policy_usage & PSA_KEY_USAGE_DECRYPT ) != 0 )
1395 TEST_ASSERT( status == PSA_ERROR_INVALID_PADDING );
1396 else
1397 TEST_ASSERT( status == PSA_ERROR_NOT_PERMITTED );
1398
1399exit:
1400 psa_destroy_key( key_slot );
1401 mbedtls_psa_crypto_free( );
1402 mbedtls_free( buffer );
1403}
1404/* END_CASE */
1405
1406/* BEGIN_CASE */
1407void asymmetric_signature_key_policy( int policy_usage,
1408 int policy_alg,
1409 int key_type,
1410 data_t *key_data,
1411 int exercise_alg )
1412{
1413 int key_slot = 1;
1414 psa_key_policy_t policy;
1415 psa_status_t status;
1416 unsigned char payload[16] = {1};
1417 size_t payload_length = sizeof( payload );
1418 unsigned char signature[PSA_ASYMMETRIC_SIGNATURE_MAX_SIZE] = {0};
1419 size_t signature_length;
1420
1421 TEST_ASSERT( psa_crypto_init( ) == PSA_SUCCESS );
1422
1423 psa_key_policy_init( &policy );
1424 psa_key_policy_set_usage( &policy, policy_usage, policy_alg );
1425 TEST_ASSERT( psa_set_key_policy( key_slot, &policy ) == PSA_SUCCESS );
1426
1427 TEST_ASSERT( psa_import_key( key_slot, key_type,
1428 key_data->x, key_data->len ) == PSA_SUCCESS );
1429
1430 status = psa_asymmetric_sign( key_slot, exercise_alg,
1431 payload, payload_length,
Gilles Peskine76f5c7b2018-07-06 16:53:09 +02001432 signature, sizeof( signature ),
1433 &signature_length );
1434 if( policy_alg == exercise_alg &&
1435 ( policy_usage & PSA_KEY_USAGE_SIGN ) != 0 )
1436 TEST_ASSERT( status == PSA_SUCCESS );
1437 else
1438 TEST_ASSERT( status == PSA_ERROR_NOT_PERMITTED );
1439
1440 memset( signature, 0, sizeof( signature ) );
1441 status = psa_asymmetric_verify( key_slot, exercise_alg,
1442 payload, payload_length,
Gilles Peskine76f5c7b2018-07-06 16:53:09 +02001443 signature, sizeof( signature ) );
1444 if( policy_alg == exercise_alg &&
1445 ( policy_usage & PSA_KEY_USAGE_VERIFY ) != 0 )
1446 TEST_ASSERT( status == PSA_ERROR_INVALID_SIGNATURE );
1447 else
1448 TEST_ASSERT( status == PSA_ERROR_NOT_PERMITTED );
Gilles Peskined5b33222018-06-18 22:20:03 +02001449
1450exit:
1451 psa_destroy_key( key_slot );
1452 mbedtls_psa_crypto_free( );
1453}
1454/* END_CASE */
1455
1456/* BEGIN_CASE */
Gilles Peskineea0fb492018-07-12 17:17:20 +02001457void derive_key_policy( int policy_usage,
1458 int policy_alg,
1459 int key_type,
1460 data_t *key_data,
1461 int exercise_alg )
1462{
1463 int key_slot = 1;
1464 psa_key_policy_t policy;
1465 psa_crypto_generator_t generator = PSA_CRYPTO_GENERATOR_INIT;
1466 psa_status_t status;
1467
1468 TEST_ASSERT( psa_crypto_init( ) == PSA_SUCCESS );
1469
1470 psa_key_policy_init( &policy );
1471 psa_key_policy_set_usage( &policy, policy_usage, policy_alg );
1472 TEST_ASSERT( psa_set_key_policy( key_slot, &policy ) == PSA_SUCCESS );
1473
1474 TEST_ASSERT( psa_import_key( key_slot, key_type,
1475 key_data->x, key_data->len ) == PSA_SUCCESS );
1476
1477 status = psa_key_derivation( &generator, key_slot,
1478 exercise_alg,
1479 NULL, 0,
1480 NULL, 0,
1481 1 );
1482 if( policy_alg == exercise_alg &&
1483 ( policy_usage & PSA_KEY_USAGE_DERIVE ) != 0 )
1484 TEST_ASSERT( status == PSA_SUCCESS );
1485 else
1486 TEST_ASSERT( status == PSA_ERROR_NOT_PERMITTED );
1487
1488exit:
1489 psa_generator_abort( &generator );
1490 psa_destroy_key( key_slot );
1491 mbedtls_psa_crypto_free( );
1492}
1493/* END_CASE */
1494
1495/* BEGIN_CASE */
Gilles Peskined5b33222018-06-18 22:20:03 +02001496void key_lifetime( int lifetime_arg )
1497{
1498 int key_slot = 1;
Gilles Peskinec32f0302018-08-10 16:02:11 +02001499 psa_key_type_t key_type = PSA_KEY_TYPE_RAW_DATA;
Gilles Peskined5b33222018-06-18 22:20:03 +02001500 unsigned char key[32] = {0};
1501 psa_key_lifetime_t lifetime_set = lifetime_arg;
1502 psa_key_lifetime_t lifetime_get;
1503
1504 memset( key, 0x2a, sizeof( key ) );
1505
1506 TEST_ASSERT( psa_crypto_init( ) == PSA_SUCCESS );
1507
1508 TEST_ASSERT( psa_set_key_lifetime( key_slot,
1509 lifetime_set ) == PSA_SUCCESS );
1510
1511 TEST_ASSERT( psa_import_key( key_slot, key_type,
1512 key, sizeof( key ) ) == PSA_SUCCESS );
1513
1514 TEST_ASSERT( psa_get_key_lifetime( key_slot,
1515 &lifetime_get ) == PSA_SUCCESS );
1516
1517 TEST_ASSERT( lifetime_get == lifetime_set );
1518
1519exit:
1520 psa_destroy_key( key_slot );
1521 mbedtls_psa_crypto_free( );
1522}
1523/* END_CASE */
1524
1525/* BEGIN_CASE */
1526void key_lifetime_set_fail( int key_slot_arg,
1527 int lifetime_arg,
1528 int expected_status_arg )
1529{
1530 psa_key_slot_t key_slot = key_slot_arg;
1531 psa_key_lifetime_t lifetime_set = lifetime_arg;
1532 psa_status_t actual_status;
1533 psa_status_t expected_status = expected_status_arg;
1534
1535 TEST_ASSERT( psa_crypto_init( ) == PSA_SUCCESS );
1536
1537 actual_status = psa_set_key_lifetime( key_slot, lifetime_set );
1538
1539 if( actual_status == PSA_SUCCESS )
1540 actual_status = psa_set_key_lifetime( key_slot, lifetime_set );
1541
1542 TEST_ASSERT( expected_status == actual_status );
1543
1544exit:
1545 psa_destroy_key( key_slot );
1546 mbedtls_psa_crypto_free( );
1547}
1548/* END_CASE */
1549
1550/* BEGIN_CASE */
Gilles Peskine16c0f4f2018-06-20 16:05:20 +02001551void hash_setup( int alg_arg,
1552 int expected_status_arg )
1553{
1554 psa_algorithm_t alg = alg_arg;
Gilles Peskineb866e2b2018-06-21 09:25:10 +02001555 psa_status_t expected_status = expected_status_arg;
Gilles Peskine16c0f4f2018-06-20 16:05:20 +02001556 psa_hash_operation_t operation;
1557 psa_status_t status;
1558
1559 TEST_ASSERT( psa_crypto_init( ) == PSA_SUCCESS );
1560
Gilles Peskineda8191d1c2018-07-08 19:46:38 +02001561 status = psa_hash_setup( &operation, alg );
Gilles Peskine16c0f4f2018-06-20 16:05:20 +02001562 psa_hash_abort( &operation );
Gilles Peskineb866e2b2018-06-21 09:25:10 +02001563 TEST_ASSERT( status == expected_status );
Gilles Peskine16c0f4f2018-06-20 16:05:20 +02001564
1565exit:
1566 mbedtls_psa_crypto_free( );
1567}
1568/* END_CASE */
1569
1570/* BEGIN_CASE */
itayzafrir3e02b3b2018-06-12 17:06:52 +03001571void hash_finish( int alg_arg, data_t *input, data_t *expected_hash )
Gilles Peskine9ef733f2018-02-07 21:05:37 +01001572{
1573 psa_algorithm_t alg = alg_arg;
Gilles Peskineb3e6e5d2018-06-18 22:16:43 +02001574 unsigned char actual_hash[PSA_HASH_MAX_SIZE];
Gilles Peskine9ef733f2018-02-07 21:05:37 +01001575 size_t actual_hash_length;
1576 psa_hash_operation_t operation;
1577
Gilles Peskine9ef733f2018-02-07 21:05:37 +01001578 TEST_ASSERT( psa_crypto_init( ) == PSA_SUCCESS );
1579
Gilles Peskineda8191d1c2018-07-08 19:46:38 +02001580 TEST_ASSERT( psa_hash_setup( &operation, alg ) == PSA_SUCCESS );
Gilles Peskine9ef733f2018-02-07 21:05:37 +01001581 TEST_ASSERT( psa_hash_update( &operation,
Gilles Peskine4abf7412018-06-18 16:35:34 +02001582 input->x, input->len ) == PSA_SUCCESS );
Gilles Peskine9ef733f2018-02-07 21:05:37 +01001583 TEST_ASSERT( psa_hash_finish( &operation,
1584 actual_hash, sizeof( actual_hash ),
1585 &actual_hash_length ) == PSA_SUCCESS );
Gilles Peskinebd7dea92018-09-27 13:57:19 +02001586 ASSERT_COMPARE( expected_hash->x, expected_hash->len,
1587 actual_hash, actual_hash_length );
Gilles Peskine9ef733f2018-02-07 21:05:37 +01001588
1589exit:
Gilles Peskine9ef733f2018-02-07 21:05:37 +01001590 mbedtls_psa_crypto_free( );
1591}
1592/* END_CASE */
1593
1594/* BEGIN_CASE */
itayzafrir3e02b3b2018-06-12 17:06:52 +03001595void hash_verify( int alg_arg, data_t *input, data_t *expected_hash )
Gilles Peskine9ef733f2018-02-07 21:05:37 +01001596{
1597 psa_algorithm_t alg = alg_arg;
Gilles Peskine9ef733f2018-02-07 21:05:37 +01001598 psa_hash_operation_t operation;
1599
Gilles Peskine9ef733f2018-02-07 21:05:37 +01001600 TEST_ASSERT( psa_crypto_init( ) == PSA_SUCCESS );
1601
Gilles Peskineda8191d1c2018-07-08 19:46:38 +02001602 TEST_ASSERT( psa_hash_setup( &operation, alg ) == PSA_SUCCESS );
Gilles Peskine9ef733f2018-02-07 21:05:37 +01001603 TEST_ASSERT( psa_hash_update( &operation,
Gilles Peskine4abf7412018-06-18 16:35:34 +02001604 input->x,
1605 input->len ) == PSA_SUCCESS );
Gilles Peskine9ef733f2018-02-07 21:05:37 +01001606 TEST_ASSERT( psa_hash_verify( &operation,
itayzafrir3e02b3b2018-06-12 17:06:52 +03001607 expected_hash->x,
Gilles Peskine4abf7412018-06-18 16:35:34 +02001608 expected_hash->len ) == PSA_SUCCESS );
Gilles Peskine9ef733f2018-02-07 21:05:37 +01001609
1610exit:
Gilles Peskine9ef733f2018-02-07 21:05:37 +01001611 mbedtls_psa_crypto_free( );
1612}
1613/* END_CASE */
1614
1615/* BEGIN_CASE */
itayzafrirec93d302018-10-18 18:01:10 +03001616void hash_bad_paths( )
1617{
1618 psa_algorithm_t alg = PSA_ALG_SHA_256;
1619 unsigned char hash[PSA_HASH_MAX_SIZE] = { 0 };
1620 size_t expected_size = PSA_HASH_SIZE( alg );
1621 unsigned char input[] = "input";
1622 psa_hash_operation_t operation;
1623 size_t hash_len;
1624
1625 TEST_ASSERT( psa_crypto_init( ) == PSA_SUCCESS );
1626
1627 /* psa_hash_update without calling psa_hash_setup beforehand */
1628 memset( &operation, 0, sizeof( operation ) );
1629 TEST_ASSERT( psa_hash_update( &operation,
1630 input, sizeof( input ) ) ==
1631 PSA_ERROR_INVALID_ARGUMENT );
1632
1633 /* psa_hash_finish without calling psa_hash_setup beforehand */
1634 memset( &operation, 0, sizeof( operation ) );
1635 TEST_ASSERT( psa_hash_finish( &operation,
1636 hash, expected_size,
1637 &hash_len ) == PSA_ERROR_INVALID_ARGUMENT );
1638
1639 /* psa_hash_verify without calling psa_hash_setup beforehand */
1640 memset( &operation, 0, sizeof( operation ) );
1641 TEST_ASSERT( psa_hash_verify( &operation,
1642 hash, expected_size ) ==
1643 PSA_ERROR_INVALID_ARGUMENT );
1644
1645 /* psa_hash_finish with a smaller hash buffer than expected */
1646 TEST_ASSERT( psa_hash_setup( &operation, alg ) == PSA_SUCCESS );
1647 TEST_ASSERT( psa_hash_finish( &operation,
1648 hash, expected_size - 1,
1649 &hash_len ) == PSA_ERROR_BUFFER_TOO_SMALL );
1650
1651
1652 /* psa_hash_verify with a smaller hash buffer than expected */
1653 TEST_ASSERT( psa_hash_setup( &operation, alg ) == PSA_SUCCESS );
1654 TEST_ASSERT( psa_hash_verify( &operation,
1655 hash, expected_size - 1 ) ==
1656 PSA_ERROR_INVALID_SIGNATURE );
1657
1658 /* psa_hash_verify with a non-matching hash buffer */
1659 TEST_ASSERT( psa_hash_setup( &operation, alg ) == PSA_SUCCESS );
1660 TEST_ASSERT( psa_hash_update( &operation,
1661 input, sizeof( input ) ) == PSA_SUCCESS );
1662 TEST_ASSERT( psa_hash_verify( &operation,
1663 hash, expected_size ) ==
1664 PSA_ERROR_INVALID_SIGNATURE );
1665
1666exit:
1667 mbedtls_psa_crypto_free( );
1668}
1669/* END_CASE */
1670
1671/* BEGIN_CASE */
Gilles Peskine16c0f4f2018-06-20 16:05:20 +02001672void mac_setup( int key_type_arg,
1673 data_t *key,
1674 int alg_arg,
1675 int expected_status_arg )
1676{
1677 int key_slot = 1;
1678 psa_key_type_t key_type = key_type_arg;
1679 psa_algorithm_t alg = alg_arg;
Gilles Peskineb866e2b2018-06-21 09:25:10 +02001680 psa_status_t expected_status = expected_status_arg;
Gilles Peskine16c0f4f2018-06-20 16:05:20 +02001681 psa_mac_operation_t operation;
1682 psa_key_policy_t policy;
1683 psa_status_t status;
1684
1685 TEST_ASSERT( psa_crypto_init( ) == PSA_SUCCESS );
1686
1687 psa_key_policy_init( &policy );
1688 psa_key_policy_set_usage( &policy,
1689 PSA_KEY_USAGE_SIGN | PSA_KEY_USAGE_VERIFY,
1690 alg );
1691 TEST_ASSERT( psa_set_key_policy( key_slot, &policy ) == PSA_SUCCESS );
1692
1693 TEST_ASSERT( psa_import_key( key_slot, key_type,
1694 key->x, key->len ) == PSA_SUCCESS );
1695
Gilles Peskine89167cb2018-07-08 20:12:23 +02001696 status = psa_mac_sign_setup( &operation, key_slot, alg );
Gilles Peskine16c0f4f2018-06-20 16:05:20 +02001697 psa_mac_abort( &operation );
Gilles Peskineb866e2b2018-06-21 09:25:10 +02001698 TEST_ASSERT( status == expected_status );
Gilles Peskine16c0f4f2018-06-20 16:05:20 +02001699
1700exit:
1701 psa_destroy_key( key_slot );
1702 mbedtls_psa_crypto_free( );
1703}
1704/* END_CASE */
1705
1706/* BEGIN_CASE */
Gilles Peskinea7aa4422018-08-14 15:17:54 +02001707void mac_sign( int key_type_arg,
1708 data_t *key,
1709 int alg_arg,
1710 data_t *input,
1711 data_t *expected_mac )
1712{
1713 int key_slot = 1;
1714 psa_key_type_t key_type = key_type_arg;
1715 psa_algorithm_t alg = alg_arg;
1716 psa_mac_operation_t operation;
1717 psa_key_policy_t policy;
1718 /* Leave a little extra room in the output buffer. At the end of the
1719 * test, we'll check that the implementation didn't overwrite onto
1720 * this extra room. */
1721 uint8_t actual_mac[PSA_MAC_MAX_SIZE + 10];
1722 size_t mac_buffer_size =
1723 PSA_MAC_FINAL_SIZE( key_type, PSA_BYTES_TO_BITS( key->len ), alg );
1724 size_t mac_length = 0;
1725
1726 memset( actual_mac, '+', sizeof( actual_mac ) );
1727 TEST_ASSERT( mac_buffer_size <= PSA_MAC_MAX_SIZE );
1728 TEST_ASSERT( expected_mac->len <= mac_buffer_size );
1729
1730 TEST_ASSERT( psa_crypto_init( ) == PSA_SUCCESS );
1731
1732 psa_key_policy_init( &policy );
1733 psa_key_policy_set_usage( &policy, PSA_KEY_USAGE_SIGN, alg );
1734 TEST_ASSERT( psa_set_key_policy( key_slot, &policy ) == PSA_SUCCESS );
1735
1736 TEST_ASSERT( psa_import_key( key_slot, key_type,
1737 key->x, key->len ) == PSA_SUCCESS );
1738
1739 /* Calculate the MAC. */
1740 TEST_ASSERT( psa_mac_sign_setup( &operation,
1741 key_slot, alg ) == PSA_SUCCESS );
1742 TEST_ASSERT( psa_mac_update( &operation,
1743 input->x, input->len ) == PSA_SUCCESS );
1744 TEST_ASSERT( psa_mac_sign_finish( &operation,
1745 actual_mac, mac_buffer_size,
1746 &mac_length ) == PSA_SUCCESS );
1747
1748 /* Compare with the expected value. */
1749 TEST_ASSERT( mac_length == expected_mac->len );
1750 TEST_ASSERT( memcmp( actual_mac, expected_mac->x, mac_length ) == 0 );
1751
1752 /* Verify that the end of the buffer is untouched. */
1753 TEST_ASSERT( mem_is_char( actual_mac + mac_length, '+',
1754 sizeof( actual_mac ) - mac_length ) );
1755
1756exit:
1757 psa_destroy_key( key_slot );
1758 mbedtls_psa_crypto_free( );
1759}
1760/* END_CASE */
1761
1762/* BEGIN_CASE */
itayzafrirf5b3eb82018-10-21 17:18:06 +03001763void hash_multi_part( int alg_arg, data_t *input, data_t *expected_hash )
1764{
1765 psa_algorithm_t alg = alg_arg;
1766 unsigned char actual_hash[PSA_HASH_MAX_SIZE] = { 0 };
1767 size_t actual_hash_length;
1768 psa_hash_operation_t operation;
1769 uint32_t halfway;
1770
itayzafrirf5b3eb82018-10-21 17:18:06 +03001771 TEST_ASSERT( psa_crypto_init( ) == PSA_SUCCESS );
1772
1773 TEST_ASSERT( psa_hash_setup( &operation, alg ) == PSA_SUCCESS );
1774
1775 halfway = input->len / 2;
1776 TEST_ASSERT( psa_hash_update( &operation,
1777 input->x,
1778 halfway ) == PSA_SUCCESS );
1779 TEST_ASSERT( psa_hash_update( &operation,
1780 input->x + halfway,
1781 input->len - halfway ) == PSA_SUCCESS );
1782
1783 TEST_ASSERT( psa_hash_finish( &operation,
1784 actual_hash, sizeof( actual_hash ),
1785 &actual_hash_length ) == PSA_SUCCESS );
1786
1787 ASSERT_COMPARE( expected_hash->x, expected_hash->len,
1788 actual_hash, actual_hash_length );
1789
1790exit:
1791 mbedtls_psa_crypto_free( );
1792}
1793/* END_CASE */
1794
1795/* BEGIN_CASE */
Gilles Peskinec0ec9722018-06-18 17:03:37 +02001796void mac_verify( int key_type_arg,
1797 data_t *key,
1798 int alg_arg,
1799 data_t *input,
1800 data_t *expected_mac )
Gilles Peskine8c9def32018-02-08 10:02:12 +01001801{
1802 int key_slot = 1;
1803 psa_key_type_t key_type = key_type_arg;
1804 psa_algorithm_t alg = alg_arg;
Gilles Peskine8c9def32018-02-08 10:02:12 +01001805 psa_mac_operation_t operation;
mohammad16036df908f2018-04-02 08:34:15 -07001806 psa_key_policy_t policy;
Gilles Peskine8c9def32018-02-08 10:02:12 +01001807
Gilles Peskine69c12672018-06-28 00:07:19 +02001808 TEST_ASSERT( expected_mac->len <= PSA_MAC_MAX_SIZE );
1809
Gilles Peskine8c9def32018-02-08 10:02:12 +01001810 TEST_ASSERT( key != NULL );
Gilles Peskine8c9def32018-02-08 10:02:12 +01001811 TEST_ASSERT( input != NULL );
Gilles Peskine8c9def32018-02-08 10:02:12 +01001812 TEST_ASSERT( expected_mac != NULL );
itayzafrir3e02b3b2018-06-12 17:06:52 +03001813 TEST_ASSERT( PSA_CRYPTO_TEST_SIZE_T_RANGE( key->len ) );
itayzafrir3e02b3b2018-06-12 17:06:52 +03001814 TEST_ASSERT( PSA_CRYPTO_TEST_SIZE_T_RANGE( input->len ) );
1815 TEST_ASSERT( PSA_CRYPTO_TEST_SIZE_T_RANGE( expected_mac->len ) );
Gilles Peskine8c9def32018-02-08 10:02:12 +01001816
1817 TEST_ASSERT( psa_crypto_init( ) == PSA_SUCCESS );
1818
mohammad16036df908f2018-04-02 08:34:15 -07001819 psa_key_policy_init( &policy );
Gilles Peskine4abf7412018-06-18 16:35:34 +02001820 psa_key_policy_set_usage( &policy, PSA_KEY_USAGE_VERIFY, alg );
mohammad16036df908f2018-04-02 08:34:15 -07001821 TEST_ASSERT( psa_set_key_policy( key_slot, &policy ) == PSA_SUCCESS );
1822
Gilles Peskine8c9def32018-02-08 10:02:12 +01001823 TEST_ASSERT( psa_import_key( key_slot, key_type,
Gilles Peskine4abf7412018-06-18 16:35:34 +02001824 key->x, key->len ) == PSA_SUCCESS );
Gilles Peskinec0ec9722018-06-18 17:03:37 +02001825
Gilles Peskine89167cb2018-07-08 20:12:23 +02001826 TEST_ASSERT( psa_mac_verify_setup( &operation,
1827 key_slot, alg ) == PSA_SUCCESS );
Gilles Peskine8c9def32018-02-08 10:02:12 +01001828 TEST_ASSERT( psa_destroy_key( key_slot ) == PSA_SUCCESS );
1829 TEST_ASSERT( psa_mac_update( &operation,
Gilles Peskine4abf7412018-06-18 16:35:34 +02001830 input->x, input->len ) == PSA_SUCCESS );
Gilles Peskineacd4be32018-07-08 19:56:25 +02001831 TEST_ASSERT( psa_mac_verify_finish( &operation,
1832 expected_mac->x,
1833 expected_mac->len ) == PSA_SUCCESS );
Gilles Peskine8c9def32018-02-08 10:02:12 +01001834
1835exit:
Gilles Peskine8c9def32018-02-08 10:02:12 +01001836 psa_destroy_key( key_slot );
1837 mbedtls_psa_crypto_free( );
1838}
1839/* END_CASE */
1840
1841/* BEGIN_CASE */
Gilles Peskine16c0f4f2018-06-20 16:05:20 +02001842void cipher_setup( int key_type_arg,
1843 data_t *key,
1844 int alg_arg,
1845 int expected_status_arg )
1846{
1847 int key_slot = 1;
1848 psa_key_type_t key_type = key_type_arg;
1849 psa_algorithm_t alg = alg_arg;
Gilles Peskineb866e2b2018-06-21 09:25:10 +02001850 psa_status_t expected_status = expected_status_arg;
Gilles Peskine16c0f4f2018-06-20 16:05:20 +02001851 psa_cipher_operation_t operation;
1852 psa_key_policy_t policy;
1853 psa_status_t status;
1854
1855 TEST_ASSERT( psa_crypto_init( ) == PSA_SUCCESS );
1856
1857 psa_key_policy_init( &policy );
1858 psa_key_policy_set_usage( &policy, PSA_KEY_USAGE_ENCRYPT, alg );
1859 TEST_ASSERT( psa_set_key_policy( key_slot, &policy ) == PSA_SUCCESS );
1860
1861 TEST_ASSERT( psa_import_key( key_slot, key_type,
1862 key->x, key->len ) == PSA_SUCCESS );
1863
Gilles Peskinefe119512018-07-08 21:39:34 +02001864 status = psa_cipher_encrypt_setup( &operation, key_slot, alg );
Gilles Peskine16c0f4f2018-06-20 16:05:20 +02001865 psa_cipher_abort( &operation );
Gilles Peskineb866e2b2018-06-21 09:25:10 +02001866 TEST_ASSERT( status == expected_status );
Gilles Peskine16c0f4f2018-06-20 16:05:20 +02001867
1868exit:
1869 psa_destroy_key( key_slot );
1870 mbedtls_psa_crypto_free( );
1871}
1872/* END_CASE */
1873
1874/* BEGIN_CASE */
Gilles Peskine50e586b2018-06-08 14:28:46 +02001875void cipher_encrypt( int alg_arg, int key_type_arg,
itayzafrir3e02b3b2018-06-12 17:06:52 +03001876 data_t *key,
1877 data_t *input, data_t *expected_output,
Gilles Peskineb866e2b2018-06-21 09:25:10 +02001878 int expected_status_arg )
Gilles Peskine50e586b2018-06-08 14:28:46 +02001879{
1880 int key_slot = 1;
1881 psa_status_t status;
1882 psa_key_type_t key_type = key_type_arg;
1883 psa_algorithm_t alg = alg_arg;
Gilles Peskineb866e2b2018-06-21 09:25:10 +02001884 psa_status_t expected_status = expected_status_arg;
Gilles Peskine50e586b2018-06-08 14:28:46 +02001885 unsigned char iv[16] = {0};
Gilles Peskine9ad29e22018-06-21 09:40:04 +02001886 size_t iv_size;
itayzafrir3e02b3b2018-06-12 17:06:52 +03001887 unsigned char *output = NULL;
Gilles Peskine50e586b2018-06-08 14:28:46 +02001888 size_t output_buffer_size = 0;
1889 size_t function_output_length = 0;
Gilles Peskinea7ec95f2018-06-08 14:40:59 +02001890 size_t total_output_length = 0;
Gilles Peskine50e586b2018-06-08 14:28:46 +02001891 psa_cipher_operation_t operation;
Moran Pekered346952018-07-05 15:22:45 +03001892 psa_key_policy_t policy;
Gilles Peskine50e586b2018-06-08 14:28:46 +02001893
Gilles Peskine50e586b2018-06-08 14:28:46 +02001894 TEST_ASSERT( key != NULL );
Gilles Peskine50e586b2018-06-08 14:28:46 +02001895 TEST_ASSERT( input != NULL );
Gilles Peskine50e586b2018-06-08 14:28:46 +02001896 TEST_ASSERT( expected_output != NULL );
itayzafrir3e02b3b2018-06-12 17:06:52 +03001897 TEST_ASSERT( PSA_CRYPTO_TEST_SIZE_T_RANGE( key->len ) );
1898 TEST_ASSERT( PSA_CRYPTO_TEST_SIZE_T_RANGE( input->len ) );
1899 TEST_ASSERT( PSA_CRYPTO_TEST_SIZE_T_RANGE( expected_output->len ) );
Gilles Peskine50e586b2018-06-08 14:28:46 +02001900
Gilles Peskine9ad29e22018-06-21 09:40:04 +02001901 iv_size = PSA_BLOCK_CIPHER_BLOCK_SIZE( key_type );
1902 memset( iv, 0x2a, iv_size );
Gilles Peskine50e586b2018-06-08 14:28:46 +02001903
1904 TEST_ASSERT( psa_crypto_init( ) == PSA_SUCCESS );
1905
Moran Pekered346952018-07-05 15:22:45 +03001906 psa_key_policy_init( &policy );
1907 psa_key_policy_set_usage( &policy, PSA_KEY_USAGE_ENCRYPT, alg );
1908 TEST_ASSERT( psa_set_key_policy( key_slot, &policy ) == PSA_SUCCESS );
1909
Gilles Peskine50e586b2018-06-08 14:28:46 +02001910 TEST_ASSERT( psa_import_key( key_slot, key_type,
Gilles Peskine4abf7412018-06-18 16:35:34 +02001911 key->x, key->len ) == PSA_SUCCESS );
Gilles Peskine50e586b2018-06-08 14:28:46 +02001912
Gilles Peskinefe119512018-07-08 21:39:34 +02001913 TEST_ASSERT( psa_cipher_encrypt_setup( &operation,
1914 key_slot, alg ) == PSA_SUCCESS );
Gilles Peskine50e586b2018-06-08 14:28:46 +02001915
Gilles Peskinefe119512018-07-08 21:39:34 +02001916 TEST_ASSERT( psa_cipher_set_iv( &operation,
1917 iv, iv_size ) == PSA_SUCCESS );
mohammad16033d91abe2018-07-03 13:15:54 +03001918 output_buffer_size = (size_t) input->len +
1919 PSA_BLOCK_CIPHER_BLOCK_SIZE( key_type );
Gilles Peskine8cebbba2018-09-27 13:54:18 +02001920 ASSERT_ALLOC( output, output_buffer_size );
Gilles Peskine50e586b2018-06-08 14:28:46 +02001921
Gilles Peskine4abf7412018-06-18 16:35:34 +02001922 TEST_ASSERT( psa_cipher_update( &operation,
1923 input->x, input->len,
Gilles Peskine50e586b2018-06-08 14:28:46 +02001924 output, output_buffer_size,
1925 &function_output_length ) == PSA_SUCCESS );
Gilles Peskinea7ec95f2018-06-08 14:40:59 +02001926 total_output_length += function_output_length;
Gilles Peskine50e586b2018-06-08 14:28:46 +02001927 status = psa_cipher_finish( &operation,
1928 output + function_output_length,
1929 output_buffer_size,
1930 &function_output_length );
Gilles Peskinea7ec95f2018-06-08 14:40:59 +02001931 total_output_length += function_output_length;
1932
Gilles Peskineb866e2b2018-06-21 09:25:10 +02001933 TEST_ASSERT( status == expected_status );
Gilles Peskine50e586b2018-06-08 14:28:46 +02001934 if( expected_status == PSA_SUCCESS )
1935 {
1936 TEST_ASSERT( psa_cipher_abort( &operation ) == PSA_SUCCESS );
Gilles Peskinebd7dea92018-09-27 13:57:19 +02001937 ASSERT_COMPARE( expected_output->x, expected_output->len,
1938 output, total_output_length );
Gilles Peskine50e586b2018-06-08 14:28:46 +02001939 }
Gilles Peskinea7ec95f2018-06-08 14:40:59 +02001940
Gilles Peskine50e586b2018-06-08 14:28:46 +02001941exit:
itayzafrir3e02b3b2018-06-12 17:06:52 +03001942 mbedtls_free( output );
Gilles Peskine50e586b2018-06-08 14:28:46 +02001943 psa_destroy_key( key_slot );
1944 mbedtls_psa_crypto_free( );
1945}
1946/* END_CASE */
1947
1948/* BEGIN_CASE */
1949void cipher_encrypt_multipart( int alg_arg, int key_type_arg,
itayzafrir3e02b3b2018-06-12 17:06:52 +03001950 data_t *key,
1951 data_t *input,
1952 int first_part_size,
1953 data_t *expected_output )
Gilles Peskine50e586b2018-06-08 14:28:46 +02001954{
1955 int key_slot = 1;
1956 psa_key_type_t key_type = key_type_arg;
1957 psa_algorithm_t alg = alg_arg;
Gilles Peskine50e586b2018-06-08 14:28:46 +02001958 unsigned char iv[16] = {0};
Gilles Peskine9ad29e22018-06-21 09:40:04 +02001959 size_t iv_size;
itayzafrir3e02b3b2018-06-12 17:06:52 +03001960 unsigned char *output = NULL;
Gilles Peskine50e586b2018-06-08 14:28:46 +02001961 size_t output_buffer_size = 0;
1962 size_t function_output_length = 0;
Gilles Peskinea7ec95f2018-06-08 14:40:59 +02001963 size_t total_output_length = 0;
Gilles Peskine50e586b2018-06-08 14:28:46 +02001964 psa_cipher_operation_t operation;
Moran Pekered346952018-07-05 15:22:45 +03001965 psa_key_policy_t policy;
Gilles Peskine50e586b2018-06-08 14:28:46 +02001966
Gilles Peskine50e586b2018-06-08 14:28:46 +02001967 TEST_ASSERT( key != NULL );
Gilles Peskine50e586b2018-06-08 14:28:46 +02001968 TEST_ASSERT( input != NULL );
Gilles Peskine50e586b2018-06-08 14:28:46 +02001969 TEST_ASSERT( expected_output != NULL );
itayzafrir3e02b3b2018-06-12 17:06:52 +03001970 TEST_ASSERT( PSA_CRYPTO_TEST_SIZE_T_RANGE( key->len ) );
1971 TEST_ASSERT( PSA_CRYPTO_TEST_SIZE_T_RANGE( input->len ) );
1972 TEST_ASSERT( PSA_CRYPTO_TEST_SIZE_T_RANGE( expected_output->len ) );
Gilles Peskine50e586b2018-06-08 14:28:46 +02001973
Gilles Peskine9ad29e22018-06-21 09:40:04 +02001974 iv_size = PSA_BLOCK_CIPHER_BLOCK_SIZE( key_type );
1975 memset( iv, 0x2a, iv_size );
Gilles Peskine50e586b2018-06-08 14:28:46 +02001976
1977 TEST_ASSERT( psa_crypto_init( ) == PSA_SUCCESS );
1978
Moran Pekered346952018-07-05 15:22:45 +03001979 psa_key_policy_init( &policy );
1980 psa_key_policy_set_usage( &policy, PSA_KEY_USAGE_ENCRYPT, alg );
1981 TEST_ASSERT( psa_set_key_policy( key_slot, &policy ) == PSA_SUCCESS );
1982
Gilles Peskine50e586b2018-06-08 14:28:46 +02001983 TEST_ASSERT( psa_import_key( key_slot, key_type,
Gilles Peskine4abf7412018-06-18 16:35:34 +02001984 key->x, key->len ) == PSA_SUCCESS );
Gilles Peskine50e586b2018-06-08 14:28:46 +02001985
Gilles Peskinefe119512018-07-08 21:39:34 +02001986 TEST_ASSERT( psa_cipher_encrypt_setup( &operation,
1987 key_slot, alg ) == PSA_SUCCESS );
Gilles Peskine50e586b2018-06-08 14:28:46 +02001988
Gilles Peskinefe119512018-07-08 21:39:34 +02001989 TEST_ASSERT( psa_cipher_set_iv( &operation,
1990 iv, sizeof( iv ) ) == PSA_SUCCESS );
mohammad16033d91abe2018-07-03 13:15:54 +03001991 output_buffer_size = (size_t) input->len +
1992 PSA_BLOCK_CIPHER_BLOCK_SIZE( key_type );
Gilles Peskine8cebbba2018-09-27 13:54:18 +02001993 ASSERT_ALLOC( output, output_buffer_size );
Gilles Peskine50e586b2018-06-08 14:28:46 +02001994
Gilles Peskine4abf7412018-06-18 16:35:34 +02001995 TEST_ASSERT( (unsigned int) first_part_size < input->len );
itayzafrir3e02b3b2018-06-12 17:06:52 +03001996 TEST_ASSERT( psa_cipher_update( &operation, input->x, first_part_size,
Gilles Peskine50e586b2018-06-08 14:28:46 +02001997 output, output_buffer_size,
1998 &function_output_length ) == PSA_SUCCESS );
Gilles Peskinea7ec95f2018-06-08 14:40:59 +02001999 total_output_length += function_output_length;
Gilles Peskine50e586b2018-06-08 14:28:46 +02002000 TEST_ASSERT( psa_cipher_update( &operation,
itayzafrir3e02b3b2018-06-12 17:06:52 +03002001 input->x + first_part_size,
Gilles Peskine4abf7412018-06-18 16:35:34 +02002002 input->len - first_part_size,
Gilles Peskine50e586b2018-06-08 14:28:46 +02002003 output, output_buffer_size,
2004 &function_output_length ) == PSA_SUCCESS );
Gilles Peskinea7ec95f2018-06-08 14:40:59 +02002005 total_output_length += function_output_length;
Gilles Peskine50e586b2018-06-08 14:28:46 +02002006 TEST_ASSERT( psa_cipher_finish( &operation,
2007 output + function_output_length,
2008 output_buffer_size,
2009 &function_output_length ) == PSA_SUCCESS );
Gilles Peskinea7ec95f2018-06-08 14:40:59 +02002010 total_output_length += function_output_length;
Gilles Peskine50e586b2018-06-08 14:28:46 +02002011 TEST_ASSERT( psa_cipher_abort( &operation ) == PSA_SUCCESS );
2012
Gilles Peskinebd7dea92018-09-27 13:57:19 +02002013 ASSERT_COMPARE( expected_output->x, expected_output->len,
2014 output, total_output_length );
Gilles Peskine50e586b2018-06-08 14:28:46 +02002015
2016exit:
itayzafrir3e02b3b2018-06-12 17:06:52 +03002017 mbedtls_free( output );
Gilles Peskine50e586b2018-06-08 14:28:46 +02002018 psa_destroy_key( key_slot );
2019 mbedtls_psa_crypto_free( );
2020}
2021/* END_CASE */
2022
2023/* BEGIN_CASE */
2024void cipher_decrypt_multipart( int alg_arg, int key_type_arg,
itayzafrir3e02b3b2018-06-12 17:06:52 +03002025 data_t *key,
2026 data_t *input,
2027 int first_part_size,
2028 data_t *expected_output )
Gilles Peskine50e586b2018-06-08 14:28:46 +02002029{
2030 int key_slot = 1;
2031
2032 psa_key_type_t key_type = key_type_arg;
2033 psa_algorithm_t alg = alg_arg;
Gilles Peskine50e586b2018-06-08 14:28:46 +02002034 unsigned char iv[16] = {0};
Gilles Peskine9ad29e22018-06-21 09:40:04 +02002035 size_t iv_size;
itayzafrir3e02b3b2018-06-12 17:06:52 +03002036 unsigned char *output = NULL;
Gilles Peskine50e586b2018-06-08 14:28:46 +02002037 size_t output_buffer_size = 0;
2038 size_t function_output_length = 0;
Gilles Peskinea7ec95f2018-06-08 14:40:59 +02002039 size_t total_output_length = 0;
Gilles Peskine50e586b2018-06-08 14:28:46 +02002040 psa_cipher_operation_t operation;
Moran Pekered346952018-07-05 15:22:45 +03002041 psa_key_policy_t policy;
Gilles Peskine50e586b2018-06-08 14:28:46 +02002042
Gilles Peskine50e586b2018-06-08 14:28:46 +02002043 TEST_ASSERT( key != NULL );
Gilles Peskine50e586b2018-06-08 14:28:46 +02002044 TEST_ASSERT( input != NULL );
Gilles Peskine50e586b2018-06-08 14:28:46 +02002045 TEST_ASSERT( expected_output != NULL );
itayzafrir3e02b3b2018-06-12 17:06:52 +03002046 TEST_ASSERT( PSA_CRYPTO_TEST_SIZE_T_RANGE( key->len ) );
2047 TEST_ASSERT( PSA_CRYPTO_TEST_SIZE_T_RANGE( input->len ) );
2048 TEST_ASSERT( PSA_CRYPTO_TEST_SIZE_T_RANGE( expected_output->len ) );
Gilles Peskine50e586b2018-06-08 14:28:46 +02002049
Gilles Peskine9ad29e22018-06-21 09:40:04 +02002050 iv_size = PSA_BLOCK_CIPHER_BLOCK_SIZE( key_type );
2051 memset( iv, 0x2a, iv_size );
Gilles Peskine50e586b2018-06-08 14:28:46 +02002052
2053 TEST_ASSERT( psa_crypto_init( ) == PSA_SUCCESS );
2054
Moran Pekered346952018-07-05 15:22:45 +03002055 psa_key_policy_init( &policy );
2056 psa_key_policy_set_usage( &policy, PSA_KEY_USAGE_DECRYPT, alg );
2057 TEST_ASSERT( psa_set_key_policy( key_slot, &policy ) == PSA_SUCCESS );
2058
Gilles Peskine50e586b2018-06-08 14:28:46 +02002059 TEST_ASSERT( psa_import_key( key_slot, key_type,
Gilles Peskine4abf7412018-06-18 16:35:34 +02002060 key->x, key->len ) == PSA_SUCCESS );
Gilles Peskine50e586b2018-06-08 14:28:46 +02002061
Gilles Peskinefe119512018-07-08 21:39:34 +02002062 TEST_ASSERT( psa_cipher_decrypt_setup( &operation,
2063 key_slot, alg ) == PSA_SUCCESS );
Gilles Peskine50e586b2018-06-08 14:28:46 +02002064
Gilles Peskinefe119512018-07-08 21:39:34 +02002065 TEST_ASSERT( psa_cipher_set_iv( &operation,
2066 iv, sizeof( iv ) ) == PSA_SUCCESS );
Gilles Peskine50e586b2018-06-08 14:28:46 +02002067
mohammad16033d91abe2018-07-03 13:15:54 +03002068 output_buffer_size = (size_t) input->len +
2069 PSA_BLOCK_CIPHER_BLOCK_SIZE( key_type );
Gilles Peskine8cebbba2018-09-27 13:54:18 +02002070 ASSERT_ALLOC( output, output_buffer_size );
Gilles Peskine50e586b2018-06-08 14:28:46 +02002071
Gilles Peskine4abf7412018-06-18 16:35:34 +02002072 TEST_ASSERT( (unsigned int) first_part_size < input->len );
2073 TEST_ASSERT( psa_cipher_update( &operation,
2074 input->x, first_part_size,
Gilles Peskine50e586b2018-06-08 14:28:46 +02002075 output, output_buffer_size,
2076 &function_output_length ) == PSA_SUCCESS );
Gilles Peskinea7ec95f2018-06-08 14:40:59 +02002077 total_output_length += function_output_length;
Gilles Peskine50e586b2018-06-08 14:28:46 +02002078 TEST_ASSERT( psa_cipher_update( &operation,
itayzafrir3e02b3b2018-06-12 17:06:52 +03002079 input->x + first_part_size,
Gilles Peskine4abf7412018-06-18 16:35:34 +02002080 input->len - first_part_size,
Gilles Peskine50e586b2018-06-08 14:28:46 +02002081 output, output_buffer_size,
2082 &function_output_length ) == PSA_SUCCESS );
Gilles Peskinea7ec95f2018-06-08 14:40:59 +02002083 total_output_length += function_output_length;
Gilles Peskine50e586b2018-06-08 14:28:46 +02002084 TEST_ASSERT( psa_cipher_finish( &operation,
2085 output + function_output_length,
2086 output_buffer_size,
2087 &function_output_length ) == PSA_SUCCESS );
Gilles Peskinea7ec95f2018-06-08 14:40:59 +02002088 total_output_length += function_output_length;
Gilles Peskine50e586b2018-06-08 14:28:46 +02002089 TEST_ASSERT( psa_cipher_abort( &operation ) == PSA_SUCCESS );
2090
Gilles Peskinebd7dea92018-09-27 13:57:19 +02002091 ASSERT_COMPARE( expected_output->x, expected_output->len,
2092 output, total_output_length );
Gilles Peskine50e586b2018-06-08 14:28:46 +02002093
2094exit:
itayzafrir3e02b3b2018-06-12 17:06:52 +03002095 mbedtls_free( output );
Gilles Peskine50e586b2018-06-08 14:28:46 +02002096 psa_destroy_key( key_slot );
2097 mbedtls_psa_crypto_free( );
2098}
2099/* END_CASE */
2100
Gilles Peskine50e586b2018-06-08 14:28:46 +02002101/* BEGIN_CASE */
2102void cipher_decrypt( int alg_arg, int key_type_arg,
itayzafrir3e02b3b2018-06-12 17:06:52 +03002103 data_t *key,
2104 data_t *input, data_t *expected_output,
Gilles Peskineb866e2b2018-06-21 09:25:10 +02002105 int expected_status_arg )
Gilles Peskine50e586b2018-06-08 14:28:46 +02002106{
2107 int key_slot = 1;
2108 psa_status_t status;
2109 psa_key_type_t key_type = key_type_arg;
2110 psa_algorithm_t alg = alg_arg;
Gilles Peskineb866e2b2018-06-21 09:25:10 +02002111 psa_status_t expected_status = expected_status_arg;
Gilles Peskine50e586b2018-06-08 14:28:46 +02002112 unsigned char iv[16] = {0};
Gilles Peskine9ad29e22018-06-21 09:40:04 +02002113 size_t iv_size;
itayzafrir3e02b3b2018-06-12 17:06:52 +03002114 unsigned char *output = NULL;
Gilles Peskine50e586b2018-06-08 14:28:46 +02002115 size_t output_buffer_size = 0;
2116 size_t function_output_length = 0;
Gilles Peskinea7ec95f2018-06-08 14:40:59 +02002117 size_t total_output_length = 0;
Gilles Peskine50e586b2018-06-08 14:28:46 +02002118 psa_cipher_operation_t operation;
Moran Pekered346952018-07-05 15:22:45 +03002119 psa_key_policy_t policy;
Gilles Peskine50e586b2018-06-08 14:28:46 +02002120
Gilles Peskine50e586b2018-06-08 14:28:46 +02002121 TEST_ASSERT( key != NULL );
Gilles Peskine50e586b2018-06-08 14:28:46 +02002122 TEST_ASSERT( input != NULL );
Gilles Peskine50e586b2018-06-08 14:28:46 +02002123 TEST_ASSERT( expected_output != NULL );
itayzafrir3e02b3b2018-06-12 17:06:52 +03002124 TEST_ASSERT( PSA_CRYPTO_TEST_SIZE_T_RANGE( key->len ) );
2125 TEST_ASSERT( PSA_CRYPTO_TEST_SIZE_T_RANGE( input->len ) );
2126 TEST_ASSERT( PSA_CRYPTO_TEST_SIZE_T_RANGE( expected_output->len ) );
Gilles Peskine50e586b2018-06-08 14:28:46 +02002127
Gilles Peskine9ad29e22018-06-21 09:40:04 +02002128 iv_size = PSA_BLOCK_CIPHER_BLOCK_SIZE( key_type );
2129 memset( iv, 0x2a, iv_size );
Gilles Peskine50e586b2018-06-08 14:28:46 +02002130
2131 TEST_ASSERT( psa_crypto_init( ) == PSA_SUCCESS );
2132
Moran Pekered346952018-07-05 15:22:45 +03002133 psa_key_policy_init( &policy );
2134 psa_key_policy_set_usage( &policy, PSA_KEY_USAGE_DECRYPT, alg );
2135 TEST_ASSERT( psa_set_key_policy( key_slot, &policy ) == PSA_SUCCESS );
2136
Gilles Peskine50e586b2018-06-08 14:28:46 +02002137 TEST_ASSERT( psa_import_key( key_slot, key_type,
Gilles Peskine4abf7412018-06-18 16:35:34 +02002138 key->x, key->len ) == PSA_SUCCESS );
Gilles Peskine50e586b2018-06-08 14:28:46 +02002139
Gilles Peskinefe119512018-07-08 21:39:34 +02002140 TEST_ASSERT( psa_cipher_decrypt_setup( &operation,
2141 key_slot, alg ) == PSA_SUCCESS );
Gilles Peskine50e586b2018-06-08 14:28:46 +02002142
Gilles Peskinefe119512018-07-08 21:39:34 +02002143 TEST_ASSERT( psa_cipher_set_iv( &operation,
2144 iv, iv_size ) == PSA_SUCCESS );
Gilles Peskine50e586b2018-06-08 14:28:46 +02002145
mohammad16033d91abe2018-07-03 13:15:54 +03002146 output_buffer_size = (size_t) input->len +
2147 PSA_BLOCK_CIPHER_BLOCK_SIZE( key_type );
Gilles Peskine8cebbba2018-09-27 13:54:18 +02002148 ASSERT_ALLOC( output, output_buffer_size );
Gilles Peskine50e586b2018-06-08 14:28:46 +02002149
Gilles Peskine4abf7412018-06-18 16:35:34 +02002150 TEST_ASSERT( psa_cipher_update( &operation,
2151 input->x, input->len,
Gilles Peskine50e586b2018-06-08 14:28:46 +02002152 output, output_buffer_size,
2153 &function_output_length ) == PSA_SUCCESS );
Gilles Peskinea7ec95f2018-06-08 14:40:59 +02002154 total_output_length += function_output_length;
Gilles Peskine50e586b2018-06-08 14:28:46 +02002155 status = psa_cipher_finish( &operation,
2156 output + function_output_length,
2157 output_buffer_size,
2158 &function_output_length );
Gilles Peskinea7ec95f2018-06-08 14:40:59 +02002159 total_output_length += function_output_length;
Gilles Peskineb866e2b2018-06-21 09:25:10 +02002160 TEST_ASSERT( status == expected_status );
Gilles Peskine50e586b2018-06-08 14:28:46 +02002161
2162 if( expected_status == PSA_SUCCESS )
2163 {
2164 TEST_ASSERT( psa_cipher_abort( &operation ) == PSA_SUCCESS );
Gilles Peskinebd7dea92018-09-27 13:57:19 +02002165 ASSERT_COMPARE( expected_output->x, expected_output->len,
2166 output, total_output_length );
Gilles Peskine50e586b2018-06-08 14:28:46 +02002167 }
2168
Gilles Peskine50e586b2018-06-08 14:28:46 +02002169exit:
itayzafrir3e02b3b2018-06-12 17:06:52 +03002170 mbedtls_free( output );
Gilles Peskine50e586b2018-06-08 14:28:46 +02002171 psa_destroy_key( key_slot );
2172 mbedtls_psa_crypto_free( );
2173}
2174/* END_CASE */
2175
Gilles Peskine50e586b2018-06-08 14:28:46 +02002176/* BEGIN_CASE */
2177void cipher_verify_output( int alg_arg, int key_type_arg,
itayzafrir3e02b3b2018-06-12 17:06:52 +03002178 data_t *key,
2179 data_t *input )
mohammad1603d7d7ba52018-03-12 18:51:53 +02002180{
2181 int key_slot = 1;
2182 psa_key_type_t key_type = key_type_arg;
2183 psa_algorithm_t alg = alg_arg;
mohammad1603e6b67a12018-03-12 10:38:49 -07002184 unsigned char iv[16] = {0};
mohammad1603d7d7ba52018-03-12 18:51:53 +02002185 size_t iv_size = 16;
2186 size_t iv_length = 0;
itayzafrir3e02b3b2018-06-12 17:06:52 +03002187 unsigned char *output1 = NULL;
mohammad1603d7d7ba52018-03-12 18:51:53 +02002188 size_t output1_size = 0;
2189 size_t output1_length = 0;
itayzafrir3e02b3b2018-06-12 17:06:52 +03002190 unsigned char *output2 = NULL;
mohammad1603d7d7ba52018-03-12 18:51:53 +02002191 size_t output2_size = 0;
2192 size_t output2_length = 0;
Gilles Peskine048b7f02018-06-08 14:20:49 +02002193 size_t function_output_length = 0;
mohammad1603d7d7ba52018-03-12 18:51:53 +02002194 psa_cipher_operation_t operation1;
2195 psa_cipher_operation_t operation2;
Moran Pekered346952018-07-05 15:22:45 +03002196 psa_key_policy_t policy;
mohammad1603d7d7ba52018-03-12 18:51:53 +02002197
mohammad1603d7d7ba52018-03-12 18:51:53 +02002198 TEST_ASSERT( key != NULL );
mohammad1603d7d7ba52018-03-12 18:51:53 +02002199 TEST_ASSERT( input != NULL );
itayzafrir3e02b3b2018-06-12 17:06:52 +03002200 TEST_ASSERT( PSA_CRYPTO_TEST_SIZE_T_RANGE( key->len ) );
2201 TEST_ASSERT( PSA_CRYPTO_TEST_SIZE_T_RANGE( input->len ) );
Gilles Peskine4ca9c3f2018-06-06 18:44:09 +02002202
mohammad1603d7d7ba52018-03-12 18:51:53 +02002203 TEST_ASSERT( psa_crypto_init( ) == PSA_SUCCESS );
2204
Moran Pekered346952018-07-05 15:22:45 +03002205 psa_key_policy_init( &policy );
2206 psa_key_policy_set_usage( &policy, PSA_KEY_USAGE_ENCRYPT | PSA_KEY_USAGE_DECRYPT, alg );
2207 TEST_ASSERT( psa_set_key_policy( key_slot, &policy ) == PSA_SUCCESS );
2208
mohammad1603d7d7ba52018-03-12 18:51:53 +02002209 TEST_ASSERT( psa_import_key( key_slot, key_type,
Gilles Peskine4abf7412018-06-18 16:35:34 +02002210 key->x, key->len ) == PSA_SUCCESS );
mohammad1603d7d7ba52018-03-12 18:51:53 +02002211
Gilles Peskinefe119512018-07-08 21:39:34 +02002212 TEST_ASSERT( psa_cipher_encrypt_setup( &operation1,
2213 key_slot, alg ) == PSA_SUCCESS );
2214 TEST_ASSERT( psa_cipher_decrypt_setup( &operation2,
2215 key_slot, alg ) == PSA_SUCCESS );
mohammad1603d7d7ba52018-03-12 18:51:53 +02002216
Gilles Peskinefe119512018-07-08 21:39:34 +02002217 TEST_ASSERT( psa_cipher_generate_iv( &operation1,
2218 iv, iv_size,
2219 &iv_length ) == PSA_SUCCESS );
mohammad16033d91abe2018-07-03 13:15:54 +03002220 output1_size = (size_t) input->len +
2221 PSA_BLOCK_CIPHER_BLOCK_SIZE( key_type );
Gilles Peskine8cebbba2018-09-27 13:54:18 +02002222 ASSERT_ALLOC( output1, output1_size );
Moran Pekerded84402018-06-06 16:36:50 +03002223
Gilles Peskine4abf7412018-06-18 16:35:34 +02002224 TEST_ASSERT( psa_cipher_update( &operation1, input->x, input->len,
Gilles Peskine4ca9c3f2018-06-06 18:44:09 +02002225 output1, output1_size,
2226 &output1_length ) == PSA_SUCCESS );
2227 TEST_ASSERT( psa_cipher_finish( &operation1,
2228 output1 + output1_length, output1_size,
Gilles Peskine048b7f02018-06-08 14:20:49 +02002229 &function_output_length ) == PSA_SUCCESS );
Gilles Peskine4ca9c3f2018-06-06 18:44:09 +02002230
Gilles Peskine048b7f02018-06-08 14:20:49 +02002231 output1_length += function_output_length;
Moran Pekerded84402018-06-06 16:36:50 +03002232
2233 TEST_ASSERT( psa_cipher_abort( &operation1 ) == PSA_SUCCESS );
2234
2235 output2_size = output1_length;
Gilles Peskine8cebbba2018-09-27 13:54:18 +02002236 ASSERT_ALLOC( output2, output2_size );
Moran Pekerded84402018-06-06 16:36:50 +03002237
Gilles Peskinefe119512018-07-08 21:39:34 +02002238 TEST_ASSERT( psa_cipher_set_iv( &operation2,
2239 iv, iv_length ) == PSA_SUCCESS );
Gilles Peskine4ca9c3f2018-06-06 18:44:09 +02002240 TEST_ASSERT( psa_cipher_update( &operation2, output1, output1_length,
2241 output2, output2_size,
2242 &output2_length ) == PSA_SUCCESS );
Gilles Peskine048b7f02018-06-08 14:20:49 +02002243 function_output_length = 0;
Gilles Peskine4ca9c3f2018-06-06 18:44:09 +02002244 TEST_ASSERT( psa_cipher_finish( &operation2,
2245 output2 + output2_length,
2246 output2_size,
Gilles Peskine048b7f02018-06-08 14:20:49 +02002247 &function_output_length ) == PSA_SUCCESS );
Moran Pekerded84402018-06-06 16:36:50 +03002248
Gilles Peskine048b7f02018-06-08 14:20:49 +02002249 output2_length += function_output_length;
Gilles Peskine4ca9c3f2018-06-06 18:44:09 +02002250
Janos Follath25c4fa82018-07-06 16:23:25 +01002251 TEST_ASSERT( psa_cipher_abort( &operation2 ) == PSA_SUCCESS );
Moran Pekerded84402018-06-06 16:36:50 +03002252
Gilles Peskinebd7dea92018-09-27 13:57:19 +02002253 ASSERT_COMPARE( input->x, input->len, output2, output2_length );
Moran Pekerded84402018-06-06 16:36:50 +03002254
2255exit:
itayzafrir3e02b3b2018-06-12 17:06:52 +03002256 mbedtls_free( output1 );
2257 mbedtls_free( output2 );
Moran Pekerded84402018-06-06 16:36:50 +03002258 psa_destroy_key( key_slot );
2259 mbedtls_psa_crypto_free( );
2260}
2261/* END_CASE */
2262
2263/* BEGIN_CASE */
Gilles Peskine50e586b2018-06-08 14:28:46 +02002264void cipher_verify_output_multipart( int alg_arg,
2265 int key_type_arg,
itayzafrir3e02b3b2018-06-12 17:06:52 +03002266 data_t *key,
2267 data_t *input,
Gilles Peskine50e586b2018-06-08 14:28:46 +02002268 int first_part_size )
Moran Pekerded84402018-06-06 16:36:50 +03002269{
2270 int key_slot = 1;
2271 psa_key_type_t key_type = key_type_arg;
2272 psa_algorithm_t alg = alg_arg;
Moran Pekerded84402018-06-06 16:36:50 +03002273 unsigned char iv[16] = {0};
2274 size_t iv_size = 16;
2275 size_t iv_length = 0;
itayzafrir3e02b3b2018-06-12 17:06:52 +03002276 unsigned char *output1 = NULL;
Gilles Peskine048b7f02018-06-08 14:20:49 +02002277 size_t output1_buffer_size = 0;
Moran Pekerded84402018-06-06 16:36:50 +03002278 size_t output1_length = 0;
itayzafrir3e02b3b2018-06-12 17:06:52 +03002279 unsigned char *output2 = NULL;
Gilles Peskine048b7f02018-06-08 14:20:49 +02002280 size_t output2_buffer_size = 0;
Moran Pekerded84402018-06-06 16:36:50 +03002281 size_t output2_length = 0;
Gilles Peskine048b7f02018-06-08 14:20:49 +02002282 size_t function_output_length;
Moran Pekerded84402018-06-06 16:36:50 +03002283 psa_cipher_operation_t operation1;
2284 psa_cipher_operation_t operation2;
Moran Pekered346952018-07-05 15:22:45 +03002285 psa_key_policy_t policy;
Moran Pekerded84402018-06-06 16:36:50 +03002286
Moran Pekerded84402018-06-06 16:36:50 +03002287 TEST_ASSERT( key != NULL );
Moran Pekerded84402018-06-06 16:36:50 +03002288 TEST_ASSERT( input != NULL );
itayzafrir3e02b3b2018-06-12 17:06:52 +03002289 TEST_ASSERT( PSA_CRYPTO_TEST_SIZE_T_RANGE( key->len ) );
2290 TEST_ASSERT( PSA_CRYPTO_TEST_SIZE_T_RANGE( input->len ) );
Gilles Peskine4ca9c3f2018-06-06 18:44:09 +02002291
Moran Pekerded84402018-06-06 16:36:50 +03002292 TEST_ASSERT( psa_crypto_init( ) == PSA_SUCCESS );
2293
Moran Pekered346952018-07-05 15:22:45 +03002294 psa_key_policy_init( &policy );
2295 psa_key_policy_set_usage( &policy, PSA_KEY_USAGE_ENCRYPT | PSA_KEY_USAGE_DECRYPT, alg );
2296 TEST_ASSERT( psa_set_key_policy( key_slot, &policy ) == PSA_SUCCESS );
2297
Moran Pekerded84402018-06-06 16:36:50 +03002298 TEST_ASSERT( psa_import_key( key_slot, key_type,
Gilles Peskine4abf7412018-06-18 16:35:34 +02002299 key->x, key->len ) == PSA_SUCCESS );
Moran Pekerded84402018-06-06 16:36:50 +03002300
Gilles Peskinefe119512018-07-08 21:39:34 +02002301 TEST_ASSERT( psa_cipher_encrypt_setup( &operation1,
2302 key_slot, alg ) == PSA_SUCCESS );
2303 TEST_ASSERT( psa_cipher_decrypt_setup( &operation2,
2304 key_slot, alg ) == PSA_SUCCESS );
Moran Pekerded84402018-06-06 16:36:50 +03002305
Gilles Peskinefe119512018-07-08 21:39:34 +02002306 TEST_ASSERT( psa_cipher_generate_iv( &operation1,
2307 iv, iv_size,
2308 &iv_length ) == PSA_SUCCESS );
mohammad16033d91abe2018-07-03 13:15:54 +03002309 output1_buffer_size = (size_t) input->len +
2310 PSA_BLOCK_CIPHER_BLOCK_SIZE( key_type );
Gilles Peskine8cebbba2018-09-27 13:54:18 +02002311 ASSERT_ALLOC( output1, output1_buffer_size );
Moran Pekerded84402018-06-06 16:36:50 +03002312
Gilles Peskine4abf7412018-06-18 16:35:34 +02002313 TEST_ASSERT( (unsigned int) first_part_size < input->len );
Gilles Peskine4ca9c3f2018-06-06 18:44:09 +02002314
itayzafrir3e02b3b2018-06-12 17:06:52 +03002315 TEST_ASSERT( psa_cipher_update( &operation1, input->x, first_part_size,
Gilles Peskine048b7f02018-06-08 14:20:49 +02002316 output1, output1_buffer_size,
2317 &function_output_length ) == PSA_SUCCESS );
2318 output1_length += function_output_length;
Moran Pekerded84402018-06-06 16:36:50 +03002319
Gilles Peskine4ca9c3f2018-06-06 18:44:09 +02002320 TEST_ASSERT( psa_cipher_update( &operation1,
itayzafrir3e02b3b2018-06-12 17:06:52 +03002321 input->x + first_part_size,
Gilles Peskine4abf7412018-06-18 16:35:34 +02002322 input->len - first_part_size,
Gilles Peskine048b7f02018-06-08 14:20:49 +02002323 output1, output1_buffer_size,
2324 &function_output_length ) == PSA_SUCCESS );
2325 output1_length += function_output_length;
Moran Pekerded84402018-06-06 16:36:50 +03002326
Gilles Peskine048b7f02018-06-08 14:20:49 +02002327 TEST_ASSERT( psa_cipher_finish( &operation1,
2328 output1 + output1_length,
2329 output1_buffer_size - output1_length,
2330 &function_output_length ) == PSA_SUCCESS );
2331 output1_length += function_output_length;
mohammad1603d7d7ba52018-03-12 18:51:53 +02002332
2333 TEST_ASSERT( psa_cipher_abort( &operation1 ) == PSA_SUCCESS );
2334
Gilles Peskine048b7f02018-06-08 14:20:49 +02002335 output2_buffer_size = output1_length;
Gilles Peskine8cebbba2018-09-27 13:54:18 +02002336 ASSERT_ALLOC( output2, output2_buffer_size );
mohammad1603d7d7ba52018-03-12 18:51:53 +02002337
Gilles Peskinefe119512018-07-08 21:39:34 +02002338 TEST_ASSERT( psa_cipher_set_iv( &operation2,
2339 iv, iv_length ) == PSA_SUCCESS );
Moran Pekerded84402018-06-06 16:36:50 +03002340
2341 TEST_ASSERT( psa_cipher_update( &operation2, output1, first_part_size,
Gilles Peskine048b7f02018-06-08 14:20:49 +02002342 output2, output2_buffer_size,
2343 &function_output_length ) == PSA_SUCCESS );
2344 output2_length += function_output_length;
Moran Pekerded84402018-06-06 16:36:50 +03002345
Gilles Peskine048b7f02018-06-08 14:20:49 +02002346 TEST_ASSERT( psa_cipher_update( &operation2,
2347 output1 + first_part_size,
Gilles Peskine4ca9c3f2018-06-06 18:44:09 +02002348 output1_length - first_part_size,
Gilles Peskine048b7f02018-06-08 14:20:49 +02002349 output2, output2_buffer_size,
2350 &function_output_length ) == PSA_SUCCESS );
2351 output2_length += function_output_length;
Moran Pekerded84402018-06-06 16:36:50 +03002352
Gilles Peskine4ca9c3f2018-06-06 18:44:09 +02002353 TEST_ASSERT( psa_cipher_finish( &operation2,
2354 output2 + output2_length,
Gilles Peskine048b7f02018-06-08 14:20:49 +02002355 output2_buffer_size - output2_length,
2356 &function_output_length ) == PSA_SUCCESS );
2357 output2_length += function_output_length;
Gilles Peskine4ca9c3f2018-06-06 18:44:09 +02002358
Janos Follath25c4fa82018-07-06 16:23:25 +01002359 TEST_ASSERT( psa_cipher_abort( &operation2 ) == PSA_SUCCESS );
mohammad1603d7d7ba52018-03-12 18:51:53 +02002360
Gilles Peskinebd7dea92018-09-27 13:57:19 +02002361 ASSERT_COMPARE( input->x, input->len, output2, output2_length );
mohammad1603d7d7ba52018-03-12 18:51:53 +02002362
2363exit:
itayzafrir3e02b3b2018-06-12 17:06:52 +03002364 mbedtls_free( output1 );
2365 mbedtls_free( output2 );
mohammad1603d7d7ba52018-03-12 18:51:53 +02002366 psa_destroy_key( key_slot );
2367 mbedtls_psa_crypto_free( );
2368}
2369/* END_CASE */
Gilles Peskine7268afc2018-06-06 15:19:24 +02002370
Gilles Peskine20035e32018-02-03 22:44:14 +01002371/* BEGIN_CASE */
Gilles Peskine7da96b02018-08-17 18:45:42 +02002372void aead_encrypt_decrypt( int key_type_arg, data_t *key_data,
Gilles Peskinec1bb6c82018-06-18 16:04:39 +02002373 int alg_arg,
Gilles Peskine7da96b02018-08-17 18:45:42 +02002374 data_t *nonce,
2375 data_t *additional_data,
2376 data_t *input_data,
Gilles Peskinec1bb6c82018-06-18 16:04:39 +02002377 int expected_result_arg )
Gilles Peskinea1cac842018-06-11 19:33:02 +02002378{
2379 int slot = 1;
2380 psa_key_type_t key_type = key_type_arg;
2381 psa_algorithm_t alg = alg_arg;
Gilles Peskinea1cac842018-06-11 19:33:02 +02002382 unsigned char *output_data = NULL;
2383 size_t output_size = 0;
2384 size_t output_length = 0;
2385 unsigned char *output_data2 = NULL;
2386 size_t output_length2 = 0;
Gilles Peskinea1cac842018-06-11 19:33:02 +02002387 size_t tag_length = 16;
Gilles Peskine4abf7412018-06-18 16:35:34 +02002388 psa_status_t expected_result = expected_result_arg;
Gilles Peskinedec72612018-06-18 18:12:37 +02002389 psa_key_policy_t policy;
Gilles Peskinea1cac842018-06-11 19:33:02 +02002390
Gilles Peskinea1cac842018-06-11 19:33:02 +02002391 TEST_ASSERT( key_data != NULL );
Gilles Peskinea1cac842018-06-11 19:33:02 +02002392 TEST_ASSERT( input_data != NULL );
itayzafrir3e02b3b2018-06-12 17:06:52 +03002393 TEST_ASSERT( nonce != NULL );
2394 TEST_ASSERT( additional_data != NULL );
2395 TEST_ASSERT( PSA_CRYPTO_TEST_SIZE_T_RANGE( key_data->len ) );
2396 TEST_ASSERT( PSA_CRYPTO_TEST_SIZE_T_RANGE( input_data->len ) );
2397 TEST_ASSERT( PSA_CRYPTO_TEST_SIZE_T_RANGE( nonce->len ) );
2398 TEST_ASSERT( PSA_CRYPTO_TEST_SIZE_T_RANGE( additional_data->len ) );
2399
Gilles Peskine4abf7412018-06-18 16:35:34 +02002400 output_size = input_data->len + tag_length;
Gilles Peskine8cebbba2018-09-27 13:54:18 +02002401 ASSERT_ALLOC( output_data, output_size );
Gilles Peskinea1cac842018-06-11 19:33:02 +02002402
2403 TEST_ASSERT( psa_crypto_init( ) == PSA_SUCCESS );
2404
2405 psa_key_policy_init( &policy );
Gilles Peskinec1bb6c82018-06-18 16:04:39 +02002406 psa_key_policy_set_usage( &policy,
2407 PSA_KEY_USAGE_ENCRYPT | PSA_KEY_USAGE_DECRYPT,
2408 alg );
Gilles Peskinea1cac842018-06-11 19:33:02 +02002409 TEST_ASSERT( psa_set_key_policy( slot, &policy ) == PSA_SUCCESS );
2410
2411 TEST_ASSERT( psa_import_key( slot, key_type,
Gilles Peskine4abf7412018-06-18 16:35:34 +02002412 key_data->x, key_data->len ) == PSA_SUCCESS );
Gilles Peskinea1cac842018-06-11 19:33:02 +02002413
2414 TEST_ASSERT( psa_aead_encrypt( slot, alg,
Gilles Peskine4abf7412018-06-18 16:35:34 +02002415 nonce->x, nonce->len,
Gilles Peskine2d277862018-06-18 15:41:12 +02002416 additional_data->x,
Gilles Peskine4abf7412018-06-18 16:35:34 +02002417 additional_data->len,
2418 input_data->x, input_data->len,
2419 output_data, output_size,
2420 &output_length ) == expected_result );
Gilles Peskinea1cac842018-06-11 19:33:02 +02002421
2422 if( PSA_SUCCESS == expected_result )
2423 {
Gilles Peskine8cebbba2018-09-27 13:54:18 +02002424 ASSERT_ALLOC( output_data2, output_length );
Gilles Peskinea1cac842018-06-11 19:33:02 +02002425
2426 TEST_ASSERT( psa_aead_decrypt( slot, alg,
Gilles Peskine4abf7412018-06-18 16:35:34 +02002427 nonce->x, nonce->len,
Gilles Peskine2d277862018-06-18 15:41:12 +02002428 additional_data->x,
Gilles Peskine4abf7412018-06-18 16:35:34 +02002429 additional_data->len,
Gilles Peskinec1bb6c82018-06-18 16:04:39 +02002430 output_data, output_length,
2431 output_data2, output_length,
Gilles Peskine4abf7412018-06-18 16:35:34 +02002432 &output_length2 ) == expected_result );
Gilles Peskine2d277862018-06-18 15:41:12 +02002433
Gilles Peskinebd7dea92018-09-27 13:57:19 +02002434 ASSERT_COMPARE( input_data->x, input_data->len,
2435 output_data2, output_length2 );
Gilles Peskinea1cac842018-06-11 19:33:02 +02002436 }
Gilles Peskine2d277862018-06-18 15:41:12 +02002437
Gilles Peskinea1cac842018-06-11 19:33:02 +02002438exit:
2439 psa_destroy_key( slot );
Gilles Peskinea1cac842018-06-11 19:33:02 +02002440 mbedtls_free( output_data );
2441 mbedtls_free( output_data2 );
2442 mbedtls_psa_crypto_free( );
2443}
2444/* END_CASE */
2445
2446/* BEGIN_CASE */
Gilles Peskine7da96b02018-08-17 18:45:42 +02002447void aead_encrypt( int key_type_arg, data_t *key_data,
2448 int alg_arg,
2449 data_t *nonce,
2450 data_t *additional_data,
2451 data_t *input_data,
2452 data_t *expected_result )
Gilles Peskinea1cac842018-06-11 19:33:02 +02002453{
2454 int slot = 1;
2455 psa_key_type_t key_type = key_type_arg;
2456 psa_algorithm_t alg = alg_arg;
Gilles Peskinea1cac842018-06-11 19:33:02 +02002457 unsigned char *output_data = NULL;
2458 size_t output_size = 0;
2459 size_t output_length = 0;
Gilles Peskinea1cac842018-06-11 19:33:02 +02002460 size_t tag_length = 16;
Gilles Peskinedec72612018-06-18 18:12:37 +02002461 psa_key_policy_t policy;
Gilles Peskinea1cac842018-06-11 19:33:02 +02002462
Gilles Peskinea1cac842018-06-11 19:33:02 +02002463 TEST_ASSERT( key_data != NULL );
Gilles Peskinea1cac842018-06-11 19:33:02 +02002464 TEST_ASSERT( input_data != NULL );
itayzafrir3e02b3b2018-06-12 17:06:52 +03002465 TEST_ASSERT( additional_data != NULL );
2466 TEST_ASSERT( nonce != NULL );
2467 TEST_ASSERT( expected_result != NULL );
2468 TEST_ASSERT( PSA_CRYPTO_TEST_SIZE_T_RANGE( key_data->len ) );
2469 TEST_ASSERT( PSA_CRYPTO_TEST_SIZE_T_RANGE( input_data->len ) );
2470 TEST_ASSERT( PSA_CRYPTO_TEST_SIZE_T_RANGE( additional_data->len ) );
2471 TEST_ASSERT( PSA_CRYPTO_TEST_SIZE_T_RANGE( nonce->len ) );
2472 TEST_ASSERT( PSA_CRYPTO_TEST_SIZE_T_RANGE( expected_result->len ) );
2473
Gilles Peskine4abf7412018-06-18 16:35:34 +02002474 output_size = input_data->len + tag_length;
Gilles Peskine8cebbba2018-09-27 13:54:18 +02002475 ASSERT_ALLOC( output_data, output_size );
Gilles Peskine2d277862018-06-18 15:41:12 +02002476
Gilles Peskinea1cac842018-06-11 19:33:02 +02002477 TEST_ASSERT( psa_crypto_init( ) == PSA_SUCCESS );
2478
2479 psa_key_policy_init( &policy );
Gilles Peskinea1cac842018-06-11 19:33:02 +02002480 psa_key_policy_set_usage( &policy, PSA_KEY_USAGE_ENCRYPT , alg );
Gilles Peskinea1cac842018-06-11 19:33:02 +02002481 TEST_ASSERT( psa_set_key_policy( slot, &policy ) == PSA_SUCCESS );
2482
2483 TEST_ASSERT( psa_import_key( slot, key_type,
Gilles Peskine4abf7412018-06-18 16:35:34 +02002484 key_data->x,
2485 key_data->len ) == PSA_SUCCESS );
Gilles Peskinea1cac842018-06-11 19:33:02 +02002486
2487 TEST_ASSERT( psa_aead_encrypt( slot, alg,
Gilles Peskine4abf7412018-06-18 16:35:34 +02002488 nonce->x, nonce->len,
2489 additional_data->x, additional_data->len,
2490 input_data->x, input_data->len,
Gilles Peskinec1bb6c82018-06-18 16:04:39 +02002491 output_data, output_size,
2492 &output_length ) == PSA_SUCCESS );
Gilles Peskinea1cac842018-06-11 19:33:02 +02002493
Gilles Peskinebd7dea92018-09-27 13:57:19 +02002494 ASSERT_COMPARE( expected_result->x, expected_result->len,
2495 output_data, output_length );
Gilles Peskine2d277862018-06-18 15:41:12 +02002496
Gilles Peskinea1cac842018-06-11 19:33:02 +02002497exit:
2498 psa_destroy_key( slot );
Gilles Peskinea1cac842018-06-11 19:33:02 +02002499 mbedtls_free( output_data );
Gilles Peskinea1cac842018-06-11 19:33:02 +02002500 mbedtls_psa_crypto_free( );
2501}
2502/* END_CASE */
2503
2504/* BEGIN_CASE */
Gilles Peskine7da96b02018-08-17 18:45:42 +02002505void aead_decrypt( int key_type_arg, data_t *key_data,
2506 int alg_arg,
2507 data_t *nonce,
2508 data_t *additional_data,
2509 data_t *input_data,
2510 data_t *expected_data,
2511 int expected_result_arg )
Gilles Peskinea1cac842018-06-11 19:33:02 +02002512{
2513 int slot = 1;
2514 psa_key_type_t key_type = key_type_arg;
2515 psa_algorithm_t alg = alg_arg;
Gilles Peskinea1cac842018-06-11 19:33:02 +02002516 unsigned char *output_data = NULL;
2517 size_t output_size = 0;
2518 size_t output_length = 0;
Gilles Peskinea1cac842018-06-11 19:33:02 +02002519 size_t tag_length = 16;
Gilles Peskinedec72612018-06-18 18:12:37 +02002520 psa_key_policy_t policy;
Gilles Peskine4abf7412018-06-18 16:35:34 +02002521 psa_status_t expected_result = expected_result_arg;
Gilles Peskinea1cac842018-06-11 19:33:02 +02002522
Gilles Peskinea1cac842018-06-11 19:33:02 +02002523 TEST_ASSERT( key_data != NULL );
Gilles Peskinea1cac842018-06-11 19:33:02 +02002524 TEST_ASSERT( input_data != NULL );
itayzafrir3e02b3b2018-06-12 17:06:52 +03002525 TEST_ASSERT( additional_data != NULL );
2526 TEST_ASSERT( nonce != NULL );
2527 TEST_ASSERT( expected_data != NULL );
2528 TEST_ASSERT( PSA_CRYPTO_TEST_SIZE_T_RANGE( key_data->len ) );
2529 TEST_ASSERT( PSA_CRYPTO_TEST_SIZE_T_RANGE( input_data->len ) );
2530 TEST_ASSERT( PSA_CRYPTO_TEST_SIZE_T_RANGE( additional_data->len ) );
2531 TEST_ASSERT( PSA_CRYPTO_TEST_SIZE_T_RANGE( nonce->len ) );
2532 TEST_ASSERT( PSA_CRYPTO_TEST_SIZE_T_RANGE( expected_data->len ) );
2533
Gilles Peskine4abf7412018-06-18 16:35:34 +02002534 output_size = input_data->len + tag_length;
Gilles Peskine8cebbba2018-09-27 13:54:18 +02002535 ASSERT_ALLOC( output_data, output_size );
Gilles Peskine2d277862018-06-18 15:41:12 +02002536
Gilles Peskinea1cac842018-06-11 19:33:02 +02002537 TEST_ASSERT( psa_crypto_init( ) == PSA_SUCCESS );
2538
2539 psa_key_policy_init( &policy );
Gilles Peskinea1cac842018-06-11 19:33:02 +02002540 psa_key_policy_set_usage( &policy, PSA_KEY_USAGE_DECRYPT , alg );
Gilles Peskinea1cac842018-06-11 19:33:02 +02002541 TEST_ASSERT( psa_set_key_policy( slot, &policy ) == PSA_SUCCESS );
2542
2543 TEST_ASSERT( psa_import_key( slot, key_type,
Gilles Peskine4abf7412018-06-18 16:35:34 +02002544 key_data->x,
2545 key_data->len ) == PSA_SUCCESS );
Gilles Peskinea1cac842018-06-11 19:33:02 +02002546
2547 TEST_ASSERT( psa_aead_decrypt( slot, alg,
Gilles Peskine4abf7412018-06-18 16:35:34 +02002548 nonce->x, nonce->len,
Gilles Peskinec1bb6c82018-06-18 16:04:39 +02002549 additional_data->x,
Gilles Peskine4abf7412018-06-18 16:35:34 +02002550 additional_data->len,
2551 input_data->x, input_data->len,
2552 output_data, output_size,
2553 &output_length ) == expected_result );
Gilles Peskinea1cac842018-06-11 19:33:02 +02002554
Gilles Peskine2d277862018-06-18 15:41:12 +02002555 if( expected_result == PSA_SUCCESS )
Gilles Peskinebd7dea92018-09-27 13:57:19 +02002556 ASSERT_COMPARE( expected_data->x, expected_data->len,
2557 output_data, output_length );
Gilles Peskinea1cac842018-06-11 19:33:02 +02002558
Gilles Peskinea1cac842018-06-11 19:33:02 +02002559exit:
2560 psa_destroy_key( slot );
Gilles Peskinea1cac842018-06-11 19:33:02 +02002561 mbedtls_free( output_data );
Gilles Peskinea1cac842018-06-11 19:33:02 +02002562 mbedtls_psa_crypto_free( );
2563}
2564/* END_CASE */
2565
2566/* BEGIN_CASE */
Gilles Peskinec1bb6c82018-06-18 16:04:39 +02002567void signature_size( int type_arg,
2568 int bits,
2569 int alg_arg,
2570 int expected_size_arg )
Gilles Peskinee59236f2018-01-27 23:32:46 +01002571{
2572 psa_key_type_t type = type_arg;
2573 psa_algorithm_t alg = alg_arg;
Gilles Peskine2d277862018-06-18 15:41:12 +02002574 size_t actual_size = PSA_ASYMMETRIC_SIGN_OUTPUT_SIZE( type, bits, alg );
Gilles Peskinee59236f2018-01-27 23:32:46 +01002575 TEST_ASSERT( actual_size == (size_t) expected_size_arg );
2576exit:
2577 ;
2578}
2579/* END_CASE */
2580
2581/* BEGIN_CASE */
itayzafrir3e02b3b2018-06-12 17:06:52 +03002582void sign_deterministic( int key_type_arg, data_t *key_data,
2583 int alg_arg, data_t *input_data,
2584 data_t *output_data )
Gilles Peskinee59236f2018-01-27 23:32:46 +01002585{
2586 int slot = 1;
2587 psa_key_type_t key_type = key_type_arg;
2588 psa_algorithm_t alg = alg_arg;
Gilles Peskine20035e32018-02-03 22:44:14 +01002589 size_t key_bits;
Gilles Peskine20035e32018-02-03 22:44:14 +01002590 unsigned char *signature = NULL;
2591 size_t signature_size;
2592 size_t signature_length = 0xdeadbeef;
Gilles Peskinedec72612018-06-18 18:12:37 +02002593 psa_key_policy_t policy;
Gilles Peskine20035e32018-02-03 22:44:14 +01002594
Gilles Peskine20035e32018-02-03 22:44:14 +01002595 TEST_ASSERT( key_data != NULL );
Gilles Peskine20035e32018-02-03 22:44:14 +01002596 TEST_ASSERT( input_data != NULL );
Gilles Peskine20035e32018-02-03 22:44:14 +01002597 TEST_ASSERT( output_data != NULL );
itayzafrir3e02b3b2018-06-12 17:06:52 +03002598 TEST_ASSERT( PSA_CRYPTO_TEST_SIZE_T_RANGE( key_data->len ) );
2599 TEST_ASSERT( PSA_CRYPTO_TEST_SIZE_T_RANGE( input_data->len ) );
2600 TEST_ASSERT( PSA_CRYPTO_TEST_SIZE_T_RANGE( output_data->len ) );
Gilles Peskine20035e32018-02-03 22:44:14 +01002601
2602 TEST_ASSERT( psa_crypto_init( ) == PSA_SUCCESS );
2603
mohammad1603a97cb8c2018-03-28 03:46:26 -07002604 psa_key_policy_init( &policy );
Gilles Peskine4abf7412018-06-18 16:35:34 +02002605 psa_key_policy_set_usage( &policy, PSA_KEY_USAGE_SIGN, alg );
mohammad1603a97cb8c2018-03-28 03:46:26 -07002606 TEST_ASSERT( psa_set_key_policy( slot, &policy ) == PSA_SUCCESS );
2607
Gilles Peskine20035e32018-02-03 22:44:14 +01002608 TEST_ASSERT( psa_import_key( slot, key_type,
Gilles Peskine4abf7412018-06-18 16:35:34 +02002609 key_data->x,
2610 key_data->len ) == PSA_SUCCESS );
Gilles Peskine20035e32018-02-03 22:44:14 +01002611 TEST_ASSERT( psa_get_key_information( slot,
2612 NULL,
2613 &key_bits ) == PSA_SUCCESS );
2614
Gilles Peskine860ce9d2018-06-28 12:23:00 +02002615 /* Allocate a buffer which has the size advertized by the
2616 * library. */
Gilles Peskinec1bb6c82018-06-18 16:04:39 +02002617 signature_size = PSA_ASYMMETRIC_SIGN_OUTPUT_SIZE( key_type,
2618 key_bits, alg );
Gilles Peskine20035e32018-02-03 22:44:14 +01002619 TEST_ASSERT( signature_size != 0 );
Gilles Peskine69c12672018-06-28 00:07:19 +02002620 TEST_ASSERT( signature_size <= PSA_ASYMMETRIC_SIGNATURE_MAX_SIZE );
Gilles Peskine8cebbba2018-09-27 13:54:18 +02002621 ASSERT_ALLOC( signature, signature_size );
Gilles Peskine20035e32018-02-03 22:44:14 +01002622
Gilles Peskine860ce9d2018-06-28 12:23:00 +02002623 /* Perform the signature. */
Gilles Peskine20035e32018-02-03 22:44:14 +01002624 TEST_ASSERT( psa_asymmetric_sign( slot, alg,
Gilles Peskine4abf7412018-06-18 16:35:34 +02002625 input_data->x, input_data->len,
Gilles Peskine20035e32018-02-03 22:44:14 +01002626 signature, signature_size,
2627 &signature_length ) == PSA_SUCCESS );
Gilles Peskine9911b022018-06-29 17:30:48 +02002628 /* Verify that the signature is what is expected. */
Gilles Peskinebd7dea92018-09-27 13:57:19 +02002629 ASSERT_COMPARE( output_data->x, output_data->len,
2630 signature, signature_length );
Gilles Peskine20035e32018-02-03 22:44:14 +01002631
2632exit:
2633 psa_destroy_key( slot );
Gilles Peskine0189e752018-02-03 23:57:22 +01002634 mbedtls_free( signature );
Gilles Peskine20035e32018-02-03 22:44:14 +01002635 mbedtls_psa_crypto_free( );
2636}
2637/* END_CASE */
2638
2639/* BEGIN_CASE */
itayzafrir3e02b3b2018-06-12 17:06:52 +03002640void sign_fail( int key_type_arg, data_t *key_data,
2641 int alg_arg, data_t *input_data,
Gilles Peskine860ce9d2018-06-28 12:23:00 +02002642 int signature_size_arg, int expected_status_arg )
Gilles Peskine20035e32018-02-03 22:44:14 +01002643{
2644 int slot = 1;
2645 psa_key_type_t key_type = key_type_arg;
2646 psa_algorithm_t alg = alg_arg;
Gilles Peskine860ce9d2018-06-28 12:23:00 +02002647 size_t signature_size = signature_size_arg;
Gilles Peskine20035e32018-02-03 22:44:14 +01002648 psa_status_t actual_status;
2649 psa_status_t expected_status = expected_status_arg;
Gilles Peskine40f68b92018-03-07 16:43:36 +01002650 unsigned char *signature = NULL;
Gilles Peskine93aa0332018-02-03 23:58:03 +01002651 size_t signature_length = 0xdeadbeef;
Gilles Peskinedec72612018-06-18 18:12:37 +02002652 psa_key_policy_t policy;
Gilles Peskine20035e32018-02-03 22:44:14 +01002653
Gilles Peskine20035e32018-02-03 22:44:14 +01002654 TEST_ASSERT( key_data != NULL );
Gilles Peskine20035e32018-02-03 22:44:14 +01002655 TEST_ASSERT( input_data != NULL );
itayzafrir3e02b3b2018-06-12 17:06:52 +03002656 TEST_ASSERT( PSA_CRYPTO_TEST_SIZE_T_RANGE( key_data->len ) );
2657 TEST_ASSERT( PSA_CRYPTO_TEST_SIZE_T_RANGE( input_data->len ) );
2658
Gilles Peskine8cebbba2018-09-27 13:54:18 +02002659 ASSERT_ALLOC( signature, signature_size );
Gilles Peskine20035e32018-02-03 22:44:14 +01002660
2661 TEST_ASSERT( psa_crypto_init( ) == PSA_SUCCESS );
2662
mohammad1603a97cb8c2018-03-28 03:46:26 -07002663 psa_key_policy_init( &policy );
Gilles Peskine4abf7412018-06-18 16:35:34 +02002664 psa_key_policy_set_usage( &policy, PSA_KEY_USAGE_SIGN, alg );
mohammad1603a97cb8c2018-03-28 03:46:26 -07002665 TEST_ASSERT( psa_set_key_policy( slot, &policy ) == PSA_SUCCESS );
2666
Gilles Peskine20035e32018-02-03 22:44:14 +01002667 TEST_ASSERT( psa_import_key( slot, key_type,
Gilles Peskine4abf7412018-06-18 16:35:34 +02002668 key_data->x,
2669 key_data->len ) == PSA_SUCCESS );
Gilles Peskine20035e32018-02-03 22:44:14 +01002670
2671 actual_status = psa_asymmetric_sign( slot, alg,
Gilles Peskine4abf7412018-06-18 16:35:34 +02002672 input_data->x, input_data->len,
Gilles Peskine20035e32018-02-03 22:44:14 +01002673 signature, signature_size,
2674 &signature_length );
2675 TEST_ASSERT( actual_status == expected_status );
Gilles Peskine860ce9d2018-06-28 12:23:00 +02002676 /* The value of *signature_length is unspecified on error, but
2677 * whatever it is, it should be less than signature_size, so that
2678 * if the caller tries to read *signature_length bytes without
2679 * checking the error code then they don't overflow a buffer. */
2680 TEST_ASSERT( signature_length <= signature_size );
Gilles Peskine20035e32018-02-03 22:44:14 +01002681
2682exit:
2683 psa_destroy_key( slot );
Gilles Peskine20035e32018-02-03 22:44:14 +01002684 mbedtls_free( signature );
2685 mbedtls_psa_crypto_free( );
2686}
2687/* END_CASE */
mohammad16038cc1cee2018-03-28 01:21:33 +03002688
2689/* BEGIN_CASE */
Gilles Peskine9911b022018-06-29 17:30:48 +02002690void sign_verify( int key_type_arg, data_t *key_data,
2691 int alg_arg, data_t *input_data )
2692{
2693 int slot = 1;
2694 psa_key_type_t key_type = key_type_arg;
2695 psa_algorithm_t alg = alg_arg;
2696 size_t key_bits;
2697 unsigned char *signature = NULL;
2698 size_t signature_size;
2699 size_t signature_length = 0xdeadbeef;
2700 psa_key_policy_t policy;
2701
2702 TEST_ASSERT( psa_crypto_init( ) == PSA_SUCCESS );
2703
2704 psa_key_policy_init( &policy );
2705 psa_key_policy_set_usage( &policy,
2706 PSA_KEY_USAGE_SIGN | PSA_KEY_USAGE_VERIFY,
2707 alg );
2708 TEST_ASSERT( psa_set_key_policy( slot, &policy ) == PSA_SUCCESS );
2709
2710 TEST_ASSERT( psa_import_key( slot, key_type,
2711 key_data->x,
2712 key_data->len ) == PSA_SUCCESS );
2713 TEST_ASSERT( psa_get_key_information( slot,
2714 NULL,
2715 &key_bits ) == PSA_SUCCESS );
2716
2717 /* Allocate a buffer which has the size advertized by the
2718 * library. */
2719 signature_size = PSA_ASYMMETRIC_SIGN_OUTPUT_SIZE( key_type,
2720 key_bits, alg );
2721 TEST_ASSERT( signature_size != 0 );
2722 TEST_ASSERT( signature_size <= PSA_ASYMMETRIC_SIGNATURE_MAX_SIZE );
Gilles Peskine8cebbba2018-09-27 13:54:18 +02002723 ASSERT_ALLOC( signature, signature_size );
Gilles Peskine9911b022018-06-29 17:30:48 +02002724
2725 /* Perform the signature. */
2726 TEST_ASSERT( psa_asymmetric_sign( slot, alg,
2727 input_data->x, input_data->len,
Gilles Peskine9911b022018-06-29 17:30:48 +02002728 signature, signature_size,
2729 &signature_length ) == PSA_SUCCESS );
2730 /* Check that the signature length looks sensible. */
2731 TEST_ASSERT( signature_length <= signature_size );
2732 TEST_ASSERT( signature_length > 0 );
2733
2734 /* Use the library to verify that the signature is correct. */
2735 TEST_ASSERT( psa_asymmetric_verify(
2736 slot, alg,
2737 input_data->x, input_data->len,
Gilles Peskine9911b022018-06-29 17:30:48 +02002738 signature, signature_length ) == PSA_SUCCESS );
2739
2740 if( input_data->len != 0 )
2741 {
2742 /* Flip a bit in the input and verify that the signature is now
2743 * detected as invalid. Flip a bit at the beginning, not at the end,
2744 * because ECDSA may ignore the last few bits of the input. */
2745 input_data->x[0] ^= 1;
2746 TEST_ASSERT( psa_asymmetric_verify(
2747 slot, alg,
2748 input_data->x, input_data->len,
Gilles Peskine9911b022018-06-29 17:30:48 +02002749 signature,
2750 signature_length ) == PSA_ERROR_INVALID_SIGNATURE );
2751 }
2752
2753exit:
2754 psa_destroy_key( slot );
2755 mbedtls_free( signature );
2756 mbedtls_psa_crypto_free( );
2757}
2758/* END_CASE */
2759
2760/* BEGIN_CASE */
itayzafrir3e02b3b2018-06-12 17:06:52 +03002761void asymmetric_verify( int key_type_arg, data_t *key_data,
2762 int alg_arg, data_t *hash_data,
2763 data_t *signature_data )
itayzafrir5c753392018-05-08 11:18:38 +03002764{
2765 int slot = 1;
2766 psa_key_type_t key_type = key_type_arg;
2767 psa_algorithm_t alg = alg_arg;
Gilles Peskinedec72612018-06-18 18:12:37 +02002768 psa_key_policy_t policy;
itayzafrir5c753392018-05-08 11:18:38 +03002769
Gilles Peskine69c12672018-06-28 00:07:19 +02002770 TEST_ASSERT( signature_data->len <= PSA_ASYMMETRIC_SIGNATURE_MAX_SIZE );
2771
itayzafrir5c753392018-05-08 11:18:38 +03002772 TEST_ASSERT( key_data != NULL );
itayzafrir5c753392018-05-08 11:18:38 +03002773 TEST_ASSERT( hash_data != NULL );
itayzafrir5c753392018-05-08 11:18:38 +03002774 TEST_ASSERT( signature_data != NULL );
itayzafrir3e02b3b2018-06-12 17:06:52 +03002775 TEST_ASSERT( PSA_CRYPTO_TEST_SIZE_T_RANGE( key_data->len ) );
2776 TEST_ASSERT( PSA_CRYPTO_TEST_SIZE_T_RANGE( hash_data->len ) );
2777 TEST_ASSERT( PSA_CRYPTO_TEST_SIZE_T_RANGE( signature_data->len ) );
itayzafrir5c753392018-05-08 11:18:38 +03002778
2779 TEST_ASSERT( psa_crypto_init( ) == PSA_SUCCESS );
2780
2781 psa_key_policy_init( &policy );
Gilles Peskine4abf7412018-06-18 16:35:34 +02002782 psa_key_policy_set_usage( &policy, PSA_KEY_USAGE_VERIFY, alg );
itayzafrir5c753392018-05-08 11:18:38 +03002783 TEST_ASSERT( psa_set_key_policy( slot, &policy ) == PSA_SUCCESS );
2784
2785 TEST_ASSERT( psa_import_key( slot, key_type,
Gilles Peskine4abf7412018-06-18 16:35:34 +02002786 key_data->x,
2787 key_data->len ) == PSA_SUCCESS );
itayzafrir5c753392018-05-08 11:18:38 +03002788
2789 TEST_ASSERT( psa_asymmetric_verify( slot, alg,
Gilles Peskine4abf7412018-06-18 16:35:34 +02002790 hash_data->x, hash_data->len,
itayzafrir3e02b3b2018-06-12 17:06:52 +03002791 signature_data->x,
Gilles Peskine4abf7412018-06-18 16:35:34 +02002792 signature_data->len ) == PSA_SUCCESS );
itayzafrir5c753392018-05-08 11:18:38 +03002793exit:
2794 psa_destroy_key( slot );
itayzafrir5c753392018-05-08 11:18:38 +03002795 mbedtls_psa_crypto_free( );
2796}
2797/* END_CASE */
Nir Sonnenschein39e59142018-05-02 23:16:26 +03002798
2799/* BEGIN_CASE */
itayzafrir3e02b3b2018-06-12 17:06:52 +03002800void asymmetric_verify_fail( int key_type_arg, data_t *key_data,
2801 int alg_arg, data_t *hash_data,
2802 data_t *signature_data,
2803 int expected_status_arg )
Nir Sonnenschein39e59142018-05-02 23:16:26 +03002804{
Nir Sonnenschein39e59142018-05-02 23:16:26 +03002805 int slot = 1;
2806 psa_key_type_t key_type = key_type_arg;
2807 psa_algorithm_t alg = alg_arg;
Nir Sonnenschein39e59142018-05-02 23:16:26 +03002808 psa_status_t actual_status;
2809 psa_status_t expected_status = expected_status_arg;
Gilles Peskinedec72612018-06-18 18:12:37 +02002810 psa_key_policy_t policy;
Nir Sonnenschein39e59142018-05-02 23:16:26 +03002811
Nir Sonnenschein39e59142018-05-02 23:16:26 +03002812 TEST_ASSERT( key_data != NULL );
Nir Sonnenschein39e59142018-05-02 23:16:26 +03002813 TEST_ASSERT( hash_data != NULL );
Nir Sonnenschein39e59142018-05-02 23:16:26 +03002814 TEST_ASSERT( signature_data != NULL );
itayzafrir3e02b3b2018-06-12 17:06:52 +03002815 TEST_ASSERT( PSA_CRYPTO_TEST_SIZE_T_RANGE( key_data->len ) );
2816 TEST_ASSERT( PSA_CRYPTO_TEST_SIZE_T_RANGE( hash_data->len ) );
2817 TEST_ASSERT( PSA_CRYPTO_TEST_SIZE_T_RANGE( signature_data->len ) );
Nir Sonnenschein39e59142018-05-02 23:16:26 +03002818
2819 TEST_ASSERT( psa_crypto_init( ) == PSA_SUCCESS );
2820
Nir Sonnenscheind7082602018-06-04 16:45:27 +03002821 psa_key_policy_init( &policy );
Gilles Peskine4abf7412018-06-18 16:35:34 +02002822 psa_key_policy_set_usage( &policy, PSA_KEY_USAGE_VERIFY, alg );
Nir Sonnenscheind7082602018-06-04 16:45:27 +03002823 TEST_ASSERT( psa_set_key_policy( slot, &policy ) == PSA_SUCCESS );
2824
Nir Sonnenschein39e59142018-05-02 23:16:26 +03002825 TEST_ASSERT( psa_import_key( slot, key_type,
Gilles Peskine4abf7412018-06-18 16:35:34 +02002826 key_data->x,
2827 key_data->len ) == PSA_SUCCESS );
Nir Sonnenschein39e59142018-05-02 23:16:26 +03002828
2829 actual_status = psa_asymmetric_verify( slot, alg,
Gilles Peskine4abf7412018-06-18 16:35:34 +02002830 hash_data->x, hash_data->len,
Gilles Peskine2d277862018-06-18 15:41:12 +02002831 signature_data->x,
Gilles Peskine4abf7412018-06-18 16:35:34 +02002832 signature_data->len );
Nir Sonnenschein39e59142018-05-02 23:16:26 +03002833
Nir Sonnenschein39e59142018-05-02 23:16:26 +03002834 TEST_ASSERT( actual_status == expected_status );
2835
2836exit:
2837 psa_destroy_key( slot );
Nir Sonnenschein39e59142018-05-02 23:16:26 +03002838 mbedtls_psa_crypto_free( );
2839}
2840/* END_CASE */
2841
Nir Sonnenschein39e59142018-05-02 23:16:26 +03002842/* BEGIN_CASE */
Gilles Peskine656896e2018-06-29 19:12:28 +02002843void asymmetric_encrypt( int key_type_arg,
2844 data_t *key_data,
2845 int alg_arg,
2846 data_t *input_data,
Gilles Peskine68428122018-06-30 18:42:41 +02002847 data_t *label,
Gilles Peskine656896e2018-06-29 19:12:28 +02002848 int expected_output_length_arg,
2849 int expected_status_arg )
2850{
2851 int slot = 1;
2852 psa_key_type_t key_type = key_type_arg;
2853 psa_algorithm_t alg = alg_arg;
2854 size_t expected_output_length = expected_output_length_arg;
2855 size_t key_bits;
2856 unsigned char *output = NULL;
2857 size_t output_size;
2858 size_t output_length = ~0;
2859 psa_status_t actual_status;
2860 psa_status_t expected_status = expected_status_arg;
2861 psa_key_policy_t policy;
2862
2863 TEST_ASSERT( psa_crypto_init( ) == PSA_SUCCESS );
2864
2865 /* Import the key */
2866 psa_key_policy_init( &policy );
2867 psa_key_policy_set_usage( &policy, PSA_KEY_USAGE_ENCRYPT, alg );
2868 TEST_ASSERT( psa_set_key_policy( slot, &policy ) == PSA_SUCCESS );
2869 TEST_ASSERT( psa_import_key( slot, key_type,
2870 key_data->x,
2871 key_data->len ) == PSA_SUCCESS );
2872
2873 /* Determine the maximum output length */
2874 TEST_ASSERT( psa_get_key_information( slot,
2875 NULL,
2876 &key_bits ) == PSA_SUCCESS );
2877 output_size = PSA_ASYMMETRIC_ENCRYPT_OUTPUT_SIZE( key_type, key_bits, alg );
Gilles Peskine8cebbba2018-09-27 13:54:18 +02002878 ASSERT_ALLOC( output, output_size );
Gilles Peskine656896e2018-06-29 19:12:28 +02002879
2880 /* Encrypt the input */
2881 actual_status = psa_asymmetric_encrypt( slot, alg,
2882 input_data->x, input_data->len,
Gilles Peskine68428122018-06-30 18:42:41 +02002883 label->x, label->len,
Gilles Peskine656896e2018-06-29 19:12:28 +02002884 output, output_size,
2885 &output_length );
2886 TEST_ASSERT( actual_status == expected_status );
2887 TEST_ASSERT( output_length == expected_output_length );
2888
Gilles Peskine68428122018-06-30 18:42:41 +02002889 /* If the label is empty, the test framework puts a non-null pointer
2890 * in label->x. Test that a null pointer works as well. */
2891 if( label->len == 0 )
2892 {
2893 output_length = ~0;
Gilles Peskinef7ab5ad2018-09-26 18:19:24 +02002894 if( output_size != 0 )
2895 memset( output, 0, output_size );
Gilles Peskine68428122018-06-30 18:42:41 +02002896 actual_status = psa_asymmetric_encrypt( slot, alg,
2897 input_data->x, input_data->len,
2898 NULL, label->len,
2899 output, output_size,
2900 &output_length );
2901 TEST_ASSERT( actual_status == expected_status );
2902 TEST_ASSERT( output_length == expected_output_length );
2903 }
2904
Gilles Peskine656896e2018-06-29 19:12:28 +02002905exit:
2906 psa_destroy_key( slot );
2907 mbedtls_free( output );
2908 mbedtls_psa_crypto_free( );
2909}
2910/* END_CASE */
2911
2912/* BEGIN_CASE */
Gilles Peskine68428122018-06-30 18:42:41 +02002913void asymmetric_encrypt_decrypt( int key_type_arg,
2914 data_t *key_data,
2915 int alg_arg,
2916 data_t *input_data,
2917 data_t *label )
Nir Sonnenschein39e59142018-05-02 23:16:26 +03002918{
2919 int slot = 1;
2920 psa_key_type_t key_type = key_type_arg;
2921 psa_algorithm_t alg = alg_arg;
Gilles Peskine55c94dd2018-06-30 18:54:48 +02002922 size_t key_bits;
Nir Sonnenschein39e59142018-05-02 23:16:26 +03002923 unsigned char *output = NULL;
Gilles Peskine55c94dd2018-06-30 18:54:48 +02002924 size_t output_size;
2925 size_t output_length = ~0;
Nir Sonnenschein0f3bdbd2018-05-02 23:56:12 +03002926 unsigned char *output2 = NULL;
Gilles Peskine55c94dd2018-06-30 18:54:48 +02002927 size_t output2_size;
2928 size_t output2_length = ~0;
Gilles Peskinedec72612018-06-18 18:12:37 +02002929 psa_key_policy_t policy;
Nir Sonnenschein39e59142018-05-02 23:16:26 +03002930
Nir Sonnenschein39e59142018-05-02 23:16:26 +03002931 TEST_ASSERT( key_data != NULL );
Nir Sonnenschein39e59142018-05-02 23:16:26 +03002932 TEST_ASSERT( input_data != NULL );
itayzafrir3e02b3b2018-06-12 17:06:52 +03002933 TEST_ASSERT( PSA_CRYPTO_TEST_SIZE_T_RANGE( key_data->len ) );
2934 TEST_ASSERT( PSA_CRYPTO_TEST_SIZE_T_RANGE( input_data->len ) );
2935
Nir Sonnenschein39e59142018-05-02 23:16:26 +03002936 TEST_ASSERT( psa_crypto_init( ) == PSA_SUCCESS );
2937
Nir Sonnenscheind7082602018-06-04 16:45:27 +03002938 psa_key_policy_init( &policy );
Gilles Peskinec1bb6c82018-06-18 16:04:39 +02002939 psa_key_policy_set_usage( &policy,
2940 PSA_KEY_USAGE_ENCRYPT | PSA_KEY_USAGE_DECRYPT,
Gilles Peskine4abf7412018-06-18 16:35:34 +02002941 alg );
Nir Sonnenscheind7082602018-06-04 16:45:27 +03002942 TEST_ASSERT( psa_set_key_policy( slot, &policy ) == PSA_SUCCESS );
2943
Nir Sonnenschein39e59142018-05-02 23:16:26 +03002944 TEST_ASSERT( psa_import_key( slot, key_type,
Gilles Peskine4abf7412018-06-18 16:35:34 +02002945 key_data->x,
2946 key_data->len ) == PSA_SUCCESS );
Nir Sonnenschein39e59142018-05-02 23:16:26 +03002947
Gilles Peskine55c94dd2018-06-30 18:54:48 +02002948
2949 /* Determine the maximum ciphertext length */
2950 TEST_ASSERT( psa_get_key_information( slot,
2951 NULL,
2952 &key_bits ) == PSA_SUCCESS );
2953 output_size = PSA_ASYMMETRIC_ENCRYPT_OUTPUT_SIZE( key_type, key_bits, alg );
Gilles Peskine8cebbba2018-09-27 13:54:18 +02002954 ASSERT_ALLOC( output, output_size );
Gilles Peskine55c94dd2018-06-30 18:54:48 +02002955 output2_size = input_data->len;
Gilles Peskine8cebbba2018-09-27 13:54:18 +02002956 ASSERT_ALLOC( output2, output2_size );
Gilles Peskine55c94dd2018-06-30 18:54:48 +02002957
Gilles Peskineeebd7382018-06-08 18:11:54 +02002958 /* We test encryption by checking that encrypt-then-decrypt gives back
2959 * the original plaintext because of the non-optional random
2960 * part of encryption process which prevents using fixed vectors. */
Gilles Peskine2d277862018-06-18 15:41:12 +02002961 TEST_ASSERT( psa_asymmetric_encrypt( slot, alg,
Gilles Peskine4abf7412018-06-18 16:35:34 +02002962 input_data->x, input_data->len,
Gilles Peskine68428122018-06-30 18:42:41 +02002963 label->x, label->len,
Gilles Peskine4abf7412018-06-18 16:35:34 +02002964 output, output_size,
Gilles Peskine2d277862018-06-18 15:41:12 +02002965 &output_length ) == PSA_SUCCESS );
Gilles Peskine55c94dd2018-06-30 18:54:48 +02002966 /* We don't know what ciphertext length to expect, but check that
2967 * it looks sensible. */
2968 TEST_ASSERT( output_length <= output_size );
Nir Sonnenschein0f3bdbd2018-05-02 23:56:12 +03002969
Gilles Peskine2d277862018-06-18 15:41:12 +02002970 TEST_ASSERT( psa_asymmetric_decrypt( slot, alg,
Gilles Peskine4abf7412018-06-18 16:35:34 +02002971 output, output_length,
Gilles Peskine68428122018-06-30 18:42:41 +02002972 label->x, label->len,
Gilles Peskine4abf7412018-06-18 16:35:34 +02002973 output2, output2_size,
Gilles Peskine2d277862018-06-18 15:41:12 +02002974 &output2_length ) == PSA_SUCCESS );
Gilles Peskinebd7dea92018-09-27 13:57:19 +02002975 ASSERT_COMPARE( input_data->x, input_data->len,
2976 output2, output2_length );
Nir Sonnenschein39e59142018-05-02 23:16:26 +03002977
2978exit:
2979 psa_destroy_key( slot );
itayzafrir3e02b3b2018-06-12 17:06:52 +03002980 mbedtls_free( output );
2981 mbedtls_free( output2 );
Nir Sonnenschein39e59142018-05-02 23:16:26 +03002982 mbedtls_psa_crypto_free( );
Nir Sonnenschein39e59142018-05-02 23:16:26 +03002983}
2984/* END_CASE */
2985
Nir Sonnenschein39e59142018-05-02 23:16:26 +03002986/* BEGIN_CASE */
Gilles Peskine68428122018-06-30 18:42:41 +02002987void asymmetric_decrypt( int key_type_arg,
2988 data_t *key_data,
2989 int alg_arg,
2990 data_t *input_data,
2991 data_t *label,
Gilles Peskine66763a02018-06-29 21:54:10 +02002992 data_t *expected_data )
Nir Sonnenschein39e59142018-05-02 23:16:26 +03002993{
2994 int slot = 1;
2995 psa_key_type_t key_type = key_type_arg;
2996 psa_algorithm_t alg = alg_arg;
Nir Sonnenschein39e59142018-05-02 23:16:26 +03002997 unsigned char *output = NULL;
Nir Sonnenscheind70bc482018-06-04 16:31:13 +03002998 size_t output_size = 0;
Gilles Peskine55c94dd2018-06-30 18:54:48 +02002999 size_t output_length = ~0;
Gilles Peskinedec72612018-06-18 18:12:37 +02003000 psa_key_policy_t policy;
Nir Sonnenschein39e59142018-05-02 23:16:26 +03003001
Nir Sonnenschein39e59142018-05-02 23:16:26 +03003002 TEST_ASSERT( key_data != NULL );
Nir Sonnenschein39e59142018-05-02 23:16:26 +03003003 TEST_ASSERT( input_data != NULL );
Nir Sonnenschein39e59142018-05-02 23:16:26 +03003004 TEST_ASSERT( expected_data != NULL );
itayzafrir3e02b3b2018-06-12 17:06:52 +03003005 TEST_ASSERT( PSA_CRYPTO_TEST_SIZE_T_RANGE( key_data->len ) );
3006 TEST_ASSERT( PSA_CRYPTO_TEST_SIZE_T_RANGE( input_data->len ) );
3007 TEST_ASSERT( PSA_CRYPTO_TEST_SIZE_T_RANGE( expected_data->len ) );
3008
Gilles Peskine4abf7412018-06-18 16:35:34 +02003009 output_size = key_data->len;
Gilles Peskine8cebbba2018-09-27 13:54:18 +02003010 ASSERT_ALLOC( output, output_size );
Gilles Peskine5b051bc2018-05-31 13:25:48 +02003011
Nir Sonnenschein39e59142018-05-02 23:16:26 +03003012 TEST_ASSERT( psa_crypto_init( ) == PSA_SUCCESS );
3013
Nir Sonnenscheind7082602018-06-04 16:45:27 +03003014 psa_key_policy_init( &policy );
Gilles Peskine4abf7412018-06-18 16:35:34 +02003015 psa_key_policy_set_usage( &policy, PSA_KEY_USAGE_DECRYPT, alg );
Nir Sonnenscheind7082602018-06-04 16:45:27 +03003016 TEST_ASSERT( psa_set_key_policy( slot, &policy ) == PSA_SUCCESS );
3017
Nir Sonnenschein39e59142018-05-02 23:16:26 +03003018 TEST_ASSERT( psa_import_key( slot, key_type,
Gilles Peskine4abf7412018-06-18 16:35:34 +02003019 key_data->x,
3020 key_data->len ) == PSA_SUCCESS );
Nir Sonnenschein39e59142018-05-02 23:16:26 +03003021
Nir Sonnenschein0f3bdbd2018-05-02 23:56:12 +03003022 TEST_ASSERT( psa_asymmetric_decrypt( slot, alg,
Gilles Peskine4abf7412018-06-18 16:35:34 +02003023 input_data->x, input_data->len,
Gilles Peskine68428122018-06-30 18:42:41 +02003024 label->x, label->len,
Gilles Peskine2d277862018-06-18 15:41:12 +02003025 output,
3026 output_size,
3027 &output_length ) == PSA_SUCCESS );
Gilles Peskinebd7dea92018-09-27 13:57:19 +02003028 ASSERT_COMPARE( expected_data->x, expected_data->len,
3029 output, output_length );
Nir Sonnenschein39e59142018-05-02 23:16:26 +03003030
Gilles Peskine68428122018-06-30 18:42:41 +02003031 /* If the label is empty, the test framework puts a non-null pointer
3032 * in label->x. Test that a null pointer works as well. */
3033 if( label->len == 0 )
3034 {
3035 output_length = ~0;
Gilles Peskinef7ab5ad2018-09-26 18:19:24 +02003036 if( output_size != 0 )
3037 memset( output, 0, output_size );
Gilles Peskine68428122018-06-30 18:42:41 +02003038 TEST_ASSERT( psa_asymmetric_decrypt( slot, alg,
3039 input_data->x, input_data->len,
3040 NULL, label->len,
3041 output,
3042 output_size,
3043 &output_length ) == PSA_SUCCESS );
Gilles Peskinebd7dea92018-09-27 13:57:19 +02003044 ASSERT_COMPARE( expected_data->x, expected_data->len,
3045 output, output_length );
Gilles Peskine68428122018-06-30 18:42:41 +02003046 }
3047
Nir Sonnenschein39e59142018-05-02 23:16:26 +03003048exit:
3049 psa_destroy_key( slot );
itayzafrir3e02b3b2018-06-12 17:06:52 +03003050 mbedtls_free( output );
Nir Sonnenschein39e59142018-05-02 23:16:26 +03003051 mbedtls_psa_crypto_free( );
Nir Sonnenschein39e59142018-05-02 23:16:26 +03003052}
3053/* END_CASE */
3054
Nir Sonnenschein39e59142018-05-02 23:16:26 +03003055/* BEGIN_CASE */
Gilles Peskine68428122018-06-30 18:42:41 +02003056void asymmetric_decrypt_fail( int key_type_arg,
3057 data_t *key_data,
3058 int alg_arg,
3059 data_t *input_data,
3060 data_t *label,
Gilles Peskine2d277862018-06-18 15:41:12 +02003061 int expected_status_arg )
Nir Sonnenschein39e59142018-05-02 23:16:26 +03003062{
Nir Sonnenschein39e59142018-05-02 23:16:26 +03003063 int slot = 1;
3064 psa_key_type_t key_type = key_type_arg;
3065 psa_algorithm_t alg = alg_arg;
Nir Sonnenschein39e59142018-05-02 23:16:26 +03003066 unsigned char *output = NULL;
Nir Sonnenscheind70bc482018-06-04 16:31:13 +03003067 size_t output_size = 0;
Gilles Peskine55c94dd2018-06-30 18:54:48 +02003068 size_t output_length = ~0;
Nir Sonnenschein39e59142018-05-02 23:16:26 +03003069 psa_status_t actual_status;
3070 psa_status_t expected_status = expected_status_arg;
Gilles Peskinedec72612018-06-18 18:12:37 +02003071 psa_key_policy_t policy;
Nir Sonnenschein39e59142018-05-02 23:16:26 +03003072
Nir Sonnenschein39e59142018-05-02 23:16:26 +03003073 TEST_ASSERT( key_data != NULL );
Nir Sonnenschein39e59142018-05-02 23:16:26 +03003074 TEST_ASSERT( input_data != NULL );
itayzafrir3e02b3b2018-06-12 17:06:52 +03003075 TEST_ASSERT( PSA_CRYPTO_TEST_SIZE_T_RANGE( key_data->len ) );
3076 TEST_ASSERT( PSA_CRYPTO_TEST_SIZE_T_RANGE( input_data->len ) );
3077
Gilles Peskine4abf7412018-06-18 16:35:34 +02003078 output_size = key_data->len;
Gilles Peskine8cebbba2018-09-27 13:54:18 +02003079 ASSERT_ALLOC( output, output_size );
Gilles Peskine5b051bc2018-05-31 13:25:48 +02003080
Nir Sonnenschein39e59142018-05-02 23:16:26 +03003081 TEST_ASSERT( psa_crypto_init( ) == PSA_SUCCESS );
3082
Nir Sonnenscheind7082602018-06-04 16:45:27 +03003083 psa_key_policy_init( &policy );
Gilles Peskine4abf7412018-06-18 16:35:34 +02003084 psa_key_policy_set_usage( &policy, PSA_KEY_USAGE_DECRYPT, alg );
Nir Sonnenscheind7082602018-06-04 16:45:27 +03003085 TEST_ASSERT( psa_set_key_policy( slot, &policy ) == PSA_SUCCESS );
3086
Nir Sonnenschein39e59142018-05-02 23:16:26 +03003087 TEST_ASSERT( psa_import_key( slot, key_type,
Gilles Peskine4abf7412018-06-18 16:35:34 +02003088 key_data->x,
3089 key_data->len ) == PSA_SUCCESS );
Nir Sonnenschein39e59142018-05-02 23:16:26 +03003090
Gilles Peskine2d277862018-06-18 15:41:12 +02003091 actual_status = psa_asymmetric_decrypt( slot, alg,
Gilles Peskine4abf7412018-06-18 16:35:34 +02003092 input_data->x, input_data->len,
Gilles Peskine68428122018-06-30 18:42:41 +02003093 label->x, label->len,
Gilles Peskine4abf7412018-06-18 16:35:34 +02003094 output, output_size,
Gilles Peskine2d277862018-06-18 15:41:12 +02003095 &output_length );
Nir Sonnenschein39e59142018-05-02 23:16:26 +03003096 TEST_ASSERT( actual_status == expected_status );
Gilles Peskine55c94dd2018-06-30 18:54:48 +02003097 TEST_ASSERT( output_length <= output_size );
Nir Sonnenschein39e59142018-05-02 23:16:26 +03003098
Gilles Peskine68428122018-06-30 18:42:41 +02003099 /* If the label is empty, the test framework puts a non-null pointer
3100 * in label->x. Test that a null pointer works as well. */
3101 if( label->len == 0 )
3102 {
3103 output_length = ~0;
Gilles Peskinef7ab5ad2018-09-26 18:19:24 +02003104 if( output_size != 0 )
3105 memset( output, 0, output_size );
Gilles Peskine68428122018-06-30 18:42:41 +02003106 actual_status = psa_asymmetric_decrypt( slot, alg,
3107 input_data->x, input_data->len,
3108 NULL, label->len,
3109 output, output_size,
3110 &output_length );
3111 TEST_ASSERT( actual_status == expected_status );
Gilles Peskine55c94dd2018-06-30 18:54:48 +02003112 TEST_ASSERT( output_length <= output_size );
Gilles Peskine68428122018-06-30 18:42:41 +02003113 }
3114
Nir Sonnenschein39e59142018-05-02 23:16:26 +03003115exit:
3116 psa_destroy_key( slot );
Gilles Peskine2d277862018-06-18 15:41:12 +02003117 mbedtls_free( output );
Nir Sonnenschein39e59142018-05-02 23:16:26 +03003118 mbedtls_psa_crypto_free( );
3119}
Gilles Peskine5b051bc2018-05-31 13:25:48 +02003120/* END_CASE */
Gilles Peskine05d69892018-06-19 22:00:52 +02003121
3122/* BEGIN_CASE */
Gilles Peskineea0fb492018-07-12 17:17:20 +02003123void derive_setup( int key_type_arg,
3124 data_t *key_data,
3125 int alg_arg,
3126 data_t *salt,
3127 data_t *label,
3128 int requested_capacity_arg,
3129 int expected_status_arg )
3130{
3131 psa_key_slot_t slot = 1;
3132 size_t key_type = key_type_arg;
3133 psa_algorithm_t alg = alg_arg;
3134 size_t requested_capacity = requested_capacity_arg;
3135 psa_status_t expected_status = expected_status_arg;
3136 psa_crypto_generator_t generator = PSA_CRYPTO_GENERATOR_INIT;
3137 psa_key_policy_t policy;
3138
3139 TEST_ASSERT( psa_crypto_init( ) == PSA_SUCCESS );
3140
3141 psa_key_policy_init( &policy );
3142 psa_key_policy_set_usage( &policy, PSA_KEY_USAGE_DERIVE, alg );
3143 TEST_ASSERT( psa_set_key_policy( slot, &policy ) == PSA_SUCCESS );
3144
3145 TEST_ASSERT( psa_import_key( slot, key_type,
3146 key_data->x,
3147 key_data->len ) == PSA_SUCCESS );
3148
3149 TEST_ASSERT( psa_key_derivation( &generator, slot, alg,
3150 salt->x, salt->len,
3151 label->x, label->len,
3152 requested_capacity ) == expected_status );
3153
3154exit:
3155 psa_generator_abort( &generator );
3156 psa_destroy_key( slot );
3157 mbedtls_psa_crypto_free( );
3158}
3159/* END_CASE */
3160
3161/* BEGIN_CASE */
Gilles Peskine96ee5c72018-07-12 17:24:54 +02003162void derive_output( int alg_arg,
3163 data_t *key_data,
3164 data_t *salt,
3165 data_t *label,
3166 int requested_capacity_arg,
3167 data_t *expected_output1,
3168 data_t *expected_output2 )
3169{
3170 psa_key_slot_t slot = 1;
3171 psa_algorithm_t alg = alg_arg;
3172 size_t requested_capacity = requested_capacity_arg;
3173 psa_crypto_generator_t generator = PSA_CRYPTO_GENERATOR_INIT;
3174 uint8_t *expected_outputs[2] =
3175 {expected_output1->x, expected_output2->x};
3176 size_t output_sizes[2] =
3177 {expected_output1->len, expected_output2->len};
3178 size_t output_buffer_size = 0;
3179 uint8_t *output_buffer = NULL;
3180 size_t expected_capacity;
3181 size_t current_capacity;
3182 psa_key_policy_t policy;
3183 psa_status_t status;
3184 unsigned i;
3185
3186 for( i = 0; i < ARRAY_LENGTH( expected_outputs ); i++ )
3187 {
3188 if( output_sizes[i] > output_buffer_size )
3189 output_buffer_size = output_sizes[i];
3190 if( output_sizes[i] == 0 )
3191 expected_outputs[i] = NULL;
3192 }
Gilles Peskine8cebbba2018-09-27 13:54:18 +02003193 ASSERT_ALLOC( output_buffer, output_buffer_size );
Gilles Peskine96ee5c72018-07-12 17:24:54 +02003194 TEST_ASSERT( psa_crypto_init( ) == PSA_SUCCESS );
3195
3196 psa_key_policy_init( &policy );
3197 psa_key_policy_set_usage( &policy, PSA_KEY_USAGE_DERIVE, alg );
3198 TEST_ASSERT( psa_set_key_policy( slot, &policy ) == PSA_SUCCESS );
3199
3200 TEST_ASSERT( psa_import_key( slot, PSA_KEY_TYPE_DERIVE,
3201 key_data->x,
3202 key_data->len ) == PSA_SUCCESS );
3203
3204 /* Extraction phase. */
3205 TEST_ASSERT( psa_key_derivation( &generator, slot, alg,
3206 salt->x, salt->len,
3207 label->x, label->len,
3208 requested_capacity ) == PSA_SUCCESS );
3209 TEST_ASSERT( psa_get_generator_capacity( &generator,
3210 &current_capacity ) ==
3211 PSA_SUCCESS );
3212 TEST_ASSERT( current_capacity == requested_capacity );
3213 expected_capacity = requested_capacity;
3214
3215 /* Expansion phase. */
3216 for( i = 0; i < ARRAY_LENGTH( expected_outputs ); i++ )
3217 {
3218 /* Read some bytes. */
3219 status = psa_generator_read( &generator,
3220 output_buffer, output_sizes[i] );
3221 if( expected_capacity == 0 && output_sizes[i] == 0 )
3222 {
3223 /* Reading 0 bytes when 0 bytes are available can go either way. */
3224 TEST_ASSERT( status == PSA_SUCCESS ||
3225 status == PSA_ERROR_INSUFFICIENT_CAPACITY );
3226 continue;
3227 }
3228 else if( expected_capacity == 0 ||
3229 output_sizes[i] > expected_capacity )
3230 {
3231 /* Capacity exceeded. */
3232 TEST_ASSERT( status == PSA_ERROR_INSUFFICIENT_CAPACITY );
3233 expected_capacity = 0;
3234 continue;
3235 }
3236 /* Success. Check the read data. */
3237 TEST_ASSERT( status == PSA_SUCCESS );
3238 if( output_sizes[i] != 0 )
3239 TEST_ASSERT( memcmp( output_buffer, expected_outputs[i],
3240 output_sizes[i] ) == 0 );
3241 /* Check the generator status. */
3242 expected_capacity -= output_sizes[i];
3243 TEST_ASSERT( psa_get_generator_capacity( &generator,
3244 &current_capacity ) ==
3245 PSA_SUCCESS );
3246 TEST_ASSERT( expected_capacity == current_capacity );
3247 }
3248 TEST_ASSERT( psa_generator_abort( &generator ) == PSA_SUCCESS );
3249
3250exit:
3251 mbedtls_free( output_buffer );
3252 psa_generator_abort( &generator );
3253 psa_destroy_key( slot );
3254 mbedtls_psa_crypto_free( );
3255}
3256/* END_CASE */
3257
3258/* BEGIN_CASE */
Gilles Peskined54931c2018-07-17 21:06:59 +02003259void derive_full( int alg_arg,
3260 data_t *key_data,
3261 data_t *salt,
3262 data_t *label,
3263 int requested_capacity_arg )
3264{
3265 psa_key_slot_t slot = 1;
3266 psa_algorithm_t alg = alg_arg;
3267 size_t requested_capacity = requested_capacity_arg;
3268 psa_crypto_generator_t generator = PSA_CRYPTO_GENERATOR_INIT;
3269 unsigned char output_buffer[16];
3270 size_t expected_capacity = requested_capacity;
3271 size_t current_capacity;
3272 psa_key_policy_t policy;
3273
3274 TEST_ASSERT( psa_crypto_init( ) == PSA_SUCCESS );
3275
3276 psa_key_policy_init( &policy );
3277 psa_key_policy_set_usage( &policy, PSA_KEY_USAGE_DERIVE, alg );
3278 TEST_ASSERT( psa_set_key_policy( slot, &policy ) == PSA_SUCCESS );
3279
3280 TEST_ASSERT( psa_import_key( slot, PSA_KEY_TYPE_DERIVE,
3281 key_data->x,
3282 key_data->len ) == PSA_SUCCESS );
3283
3284 /* Extraction phase. */
3285 TEST_ASSERT( psa_key_derivation( &generator, slot, alg,
3286 salt->x, salt->len,
3287 label->x, label->len,
3288 requested_capacity ) == PSA_SUCCESS );
3289 TEST_ASSERT( psa_get_generator_capacity( &generator,
3290 &current_capacity ) ==
3291 PSA_SUCCESS );
3292 TEST_ASSERT( current_capacity == expected_capacity );
3293
3294 /* Expansion phase. */
3295 while( current_capacity > 0 )
3296 {
3297 size_t read_size = sizeof( output_buffer );
3298 if( read_size > current_capacity )
3299 read_size = current_capacity;
3300 TEST_ASSERT( psa_generator_read( &generator,
3301 output_buffer,
3302 read_size ) == PSA_SUCCESS );
3303 expected_capacity -= read_size;
3304 TEST_ASSERT( psa_get_generator_capacity( &generator,
3305 &current_capacity ) ==
3306 PSA_SUCCESS );
3307 TEST_ASSERT( current_capacity == expected_capacity );
3308 }
3309
3310 /* Check that the generator refuses to go over capacity. */
3311 TEST_ASSERT( psa_generator_read( &generator,
3312 output_buffer,
3313 1 ) == PSA_ERROR_INSUFFICIENT_CAPACITY );
3314
3315 TEST_ASSERT( psa_generator_abort( &generator ) == PSA_SUCCESS );
3316
3317exit:
3318 psa_generator_abort( &generator );
3319 psa_destroy_key( slot );
3320 mbedtls_psa_crypto_free( );
3321}
3322/* END_CASE */
3323
3324/* BEGIN_CASE */
Gilles Peskine0386fba2018-07-12 17:29:22 +02003325void derive_key_exercise( int alg_arg,
3326 data_t *key_data,
3327 data_t *salt,
3328 data_t *label,
3329 int derived_type_arg,
3330 int derived_bits_arg,
3331 int derived_usage_arg,
3332 int derived_alg_arg )
3333{
3334 psa_key_slot_t base_key = 1;
3335 psa_key_slot_t derived_key = 2;
3336 psa_algorithm_t alg = alg_arg;
3337 psa_key_type_t derived_type = derived_type_arg;
3338 size_t derived_bits = derived_bits_arg;
3339 psa_key_usage_t derived_usage = derived_usage_arg;
3340 psa_algorithm_t derived_alg = derived_alg_arg;
3341 size_t capacity = PSA_BITS_TO_BYTES( derived_bits );
3342 psa_crypto_generator_t generator = PSA_CRYPTO_GENERATOR_INIT;
3343 psa_key_policy_t policy;
3344 psa_key_type_t got_type;
3345 size_t got_bits;
3346
3347 TEST_ASSERT( psa_crypto_init( ) == PSA_SUCCESS );
3348
3349 psa_key_policy_init( &policy );
3350 psa_key_policy_set_usage( &policy, PSA_KEY_USAGE_DERIVE, alg );
3351 TEST_ASSERT( psa_set_key_policy( base_key, &policy ) == PSA_SUCCESS );
3352 TEST_ASSERT( psa_import_key( base_key, PSA_KEY_TYPE_DERIVE,
3353 key_data->x,
3354 key_data->len ) == PSA_SUCCESS );
3355
3356 /* Derive a key. */
3357 TEST_ASSERT( psa_key_derivation( &generator, base_key, alg,
3358 salt->x, salt->len,
3359 label->x, label->len,
3360 capacity ) == PSA_SUCCESS );
3361 psa_key_policy_set_usage( &policy, derived_usage, derived_alg );
3362 TEST_ASSERT( psa_set_key_policy( derived_key, &policy ) == PSA_SUCCESS );
3363 TEST_ASSERT( psa_generator_import_key( derived_key,
3364 derived_type,
3365 derived_bits,
3366 &generator ) == PSA_SUCCESS );
3367
3368 /* Test the key information */
3369 TEST_ASSERT( psa_get_key_information( derived_key,
3370 &got_type,
3371 &got_bits ) == PSA_SUCCESS );
3372 TEST_ASSERT( got_type == derived_type );
3373 TEST_ASSERT( got_bits == derived_bits );
3374
3375 /* Exercise the derived key. */
3376 if( ! exercise_key( derived_key, derived_usage, derived_alg ) )
3377 goto exit;
3378
3379exit:
3380 psa_generator_abort( &generator );
3381 psa_destroy_key( base_key );
3382 psa_destroy_key( derived_key );
3383 mbedtls_psa_crypto_free( );
3384}
3385/* END_CASE */
3386
3387/* BEGIN_CASE */
3388void derive_key_export( int alg_arg,
3389 data_t *key_data,
3390 data_t *salt,
3391 data_t *label,
3392 int bytes1_arg,
3393 int bytes2_arg )
3394{
3395 psa_key_slot_t base_key = 1;
3396 psa_key_slot_t derived_key = 2;
3397 psa_algorithm_t alg = alg_arg;
3398 size_t bytes1 = bytes1_arg;
3399 size_t bytes2 = bytes2_arg;
3400 size_t capacity = bytes1 + bytes2;
3401 psa_crypto_generator_t generator = PSA_CRYPTO_GENERATOR_INIT;
Gilles Peskine8cebbba2018-09-27 13:54:18 +02003402 uint8_t *output_buffer = NULL;
3403 uint8_t *export_buffer = NULL;
Gilles Peskine0386fba2018-07-12 17:29:22 +02003404 psa_key_policy_t policy;
3405 size_t length;
3406
Gilles Peskine8cebbba2018-09-27 13:54:18 +02003407 ASSERT_ALLOC( output_buffer, capacity );
3408 ASSERT_ALLOC( export_buffer, capacity );
Gilles Peskine0386fba2018-07-12 17:29:22 +02003409 TEST_ASSERT( psa_crypto_init( ) == PSA_SUCCESS );
3410
3411 psa_key_policy_init( &policy );
3412 psa_key_policy_set_usage( &policy, PSA_KEY_USAGE_DERIVE, alg );
3413 TEST_ASSERT( psa_set_key_policy( base_key, &policy ) == PSA_SUCCESS );
3414 TEST_ASSERT( psa_import_key( base_key, PSA_KEY_TYPE_DERIVE,
3415 key_data->x,
3416 key_data->len ) == PSA_SUCCESS );
3417
3418 /* Derive some material and output it. */
3419 TEST_ASSERT( psa_key_derivation( &generator, base_key, alg,
3420 salt->x, salt->len,
3421 label->x, label->len,
3422 capacity ) == PSA_SUCCESS );
3423 TEST_ASSERT( psa_generator_read( &generator,
3424 output_buffer,
3425 capacity ) == PSA_SUCCESS );
3426 TEST_ASSERT( psa_generator_abort( &generator ) == PSA_SUCCESS );
3427
3428 /* Derive the same output again, but this time store it in key objects. */
3429 TEST_ASSERT( psa_key_derivation( &generator, base_key, alg,
3430 salt->x, salt->len,
3431 label->x, label->len,
3432 capacity ) == PSA_SUCCESS );
3433 psa_key_policy_set_usage( &policy, PSA_KEY_USAGE_EXPORT, 0 );
3434 TEST_ASSERT( psa_set_key_policy( derived_key, &policy ) == PSA_SUCCESS );
3435 TEST_ASSERT( psa_generator_import_key( derived_key,
3436 PSA_KEY_TYPE_RAW_DATA,
3437 PSA_BYTES_TO_BITS( bytes1 ),
3438 &generator ) == PSA_SUCCESS );
3439 TEST_ASSERT( psa_export_key( derived_key,
3440 export_buffer, bytes1,
3441 &length ) == PSA_SUCCESS );
3442 TEST_ASSERT( length == bytes1 );
3443 TEST_ASSERT( psa_destroy_key( derived_key ) == PSA_SUCCESS );
3444 TEST_ASSERT( psa_set_key_policy( derived_key, &policy ) == PSA_SUCCESS );
3445 TEST_ASSERT( psa_generator_import_key( derived_key,
3446 PSA_KEY_TYPE_RAW_DATA,
3447 PSA_BYTES_TO_BITS( bytes2 ),
3448 &generator ) == PSA_SUCCESS );
3449 TEST_ASSERT( psa_export_key( derived_key,
3450 export_buffer + bytes1, bytes2,
3451 &length ) == PSA_SUCCESS );
3452 TEST_ASSERT( length == bytes2 );
3453
3454 /* Compare the outputs from the two runs. */
3455 TEST_ASSERT( memcmp( output_buffer, export_buffer, capacity ) == 0 );
3456
3457exit:
3458 mbedtls_free( output_buffer );
3459 mbedtls_free( export_buffer );
3460 psa_generator_abort( &generator );
3461 psa_destroy_key( base_key );
3462 psa_destroy_key( derived_key );
3463 mbedtls_psa_crypto_free( );
3464}
3465/* END_CASE */
3466
3467/* BEGIN_CASE */
Gilles Peskinea50d7392018-06-21 10:22:13 +02003468void generate_random( int bytes_arg )
Gilles Peskine05d69892018-06-19 22:00:52 +02003469{
Gilles Peskinea50d7392018-06-21 10:22:13 +02003470 size_t bytes = bytes_arg;
3471 const unsigned char trail[] = "don't overwrite me";
Gilles Peskine8cebbba2018-09-27 13:54:18 +02003472 unsigned char *output = NULL;
3473 unsigned char *changed = NULL;
Gilles Peskinea50d7392018-06-21 10:22:13 +02003474 size_t i;
3475 unsigned run;
Gilles Peskine05d69892018-06-19 22:00:52 +02003476
Gilles Peskine8cebbba2018-09-27 13:54:18 +02003477 ASSERT_ALLOC( output, bytes + sizeof( trail ) );
3478 ASSERT_ALLOC( changed, bytes );
Gilles Peskinea50d7392018-06-21 10:22:13 +02003479 memcpy( output + bytes, trail, sizeof( trail ) );
Gilles Peskine05d69892018-06-19 22:00:52 +02003480
3481 TEST_ASSERT( psa_crypto_init( ) == PSA_SUCCESS );
3482
Gilles Peskinea50d7392018-06-21 10:22:13 +02003483 /* Run several times, to ensure that every output byte will be
3484 * nonzero at least once with overwhelming probability
3485 * (2^(-8*number_of_runs)). */
3486 for( run = 0; run < 10; run++ )
Gilles Peskine05d69892018-06-19 22:00:52 +02003487 {
Gilles Peskinef7ab5ad2018-09-26 18:19:24 +02003488 if( bytes != 0 )
3489 memset( output, 0, bytes );
Gilles Peskinea50d7392018-06-21 10:22:13 +02003490 TEST_ASSERT( psa_generate_random( output, bytes ) == PSA_SUCCESS );
3491
3492 /* Check that no more than bytes have been overwritten */
3493 TEST_ASSERT( memcmp( output + bytes, trail, sizeof( trail ) ) == 0 );
3494
3495 for( i = 0; i < bytes; i++ )
3496 {
3497 if( output[i] != 0 )
3498 ++changed[i];
3499 }
Gilles Peskine05d69892018-06-19 22:00:52 +02003500 }
Gilles Peskinea50d7392018-06-21 10:22:13 +02003501
3502 /* Check that every byte was changed to nonzero at least once. This
3503 * validates that psa_generate_random is overwriting every byte of
3504 * the output buffer. */
3505 for( i = 0; i < bytes; i++ )
3506 {
3507 TEST_ASSERT( changed[i] != 0 );
3508 }
Gilles Peskine05d69892018-06-19 22:00:52 +02003509
3510exit:
3511 mbedtls_psa_crypto_free( );
Gilles Peskinea50d7392018-06-21 10:22:13 +02003512 mbedtls_free( output );
3513 mbedtls_free( changed );
Gilles Peskine05d69892018-06-19 22:00:52 +02003514}
3515/* END_CASE */
Gilles Peskine12313cd2018-06-20 00:20:32 +02003516
3517/* BEGIN_CASE */
3518void generate_key( int type_arg,
3519 int bits_arg,
3520 int usage_arg,
3521 int alg_arg,
3522 int expected_status_arg )
3523{
3524 int slot = 1;
3525 psa_key_type_t type = type_arg;
3526 psa_key_usage_t usage = usage_arg;
3527 size_t bits = bits_arg;
3528 psa_algorithm_t alg = alg_arg;
3529 psa_status_t expected_status = expected_status_arg;
3530 psa_key_type_t got_type;
3531 size_t got_bits;
Gilles Peskine12313cd2018-06-20 00:20:32 +02003532 psa_status_t expected_info_status =
3533 expected_status == PSA_SUCCESS ? PSA_SUCCESS : PSA_ERROR_EMPTY_SLOT;
3534 psa_key_policy_t policy;
3535
3536 TEST_ASSERT( psa_crypto_init( ) == PSA_SUCCESS );
3537
3538 psa_key_policy_init( &policy );
3539 psa_key_policy_set_usage( &policy, usage, alg );
3540 TEST_ASSERT( psa_set_key_policy( slot, &policy ) == PSA_SUCCESS );
3541
3542 /* Generate a key */
3543 TEST_ASSERT( psa_generate_key( slot, type, bits,
3544 NULL, 0 ) == expected_status );
3545
3546 /* Test the key information */
3547 TEST_ASSERT( psa_get_key_information( slot,
3548 &got_type,
3549 &got_bits ) == expected_info_status );
3550 if( expected_info_status != PSA_SUCCESS )
3551 goto exit;
3552 TEST_ASSERT( got_type == type );
3553 TEST_ASSERT( got_bits == bits );
3554
Gilles Peskine818ca122018-06-20 18:16:48 +02003555 /* Do something with the key according to its type and permitted usage. */
Gilles Peskine02b75072018-07-01 22:31:34 +02003556 if( ! exercise_key( slot, usage, alg ) )
3557 goto exit;
Gilles Peskine12313cd2018-06-20 00:20:32 +02003558
3559exit:
3560 psa_destroy_key( slot );
3561 mbedtls_psa_crypto_free( );
3562}
3563/* END_CASE */
itayzafrir0adf0fc2018-09-06 16:24:41 +03003564
3565/* BEGIN_CASE */
3566void validate_module_init_generate_random( )
3567{
3568 psa_status_t status;
3569 uint8_t random[10] = { 0 };
3570 status = psa_generate_random( random, sizeof( random ) );
3571 TEST_ASSERT( status == PSA_ERROR_BAD_STATE );
3572}
3573/* END_CASE */
itayzafrir90d8c7a2018-09-12 11:44:52 +03003574
3575/* BEGIN_CASE */
3576void validate_module_init_key_based( )
3577{
3578 psa_status_t status;
3579 uint8_t data[10] = { 0 };
3580 status = psa_import_key( 1, PSA_KEY_TYPE_RAW_DATA, data, sizeof( data ) );
3581 TEST_ASSERT( status == PSA_ERROR_BAD_STATE );
3582}
3583/* END_CASE */