blob: 0f9093c7aeab6cc0f9ba7e1645fc321e2a34ee0d [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
Gilles Peskinedd2f95b2018-08-11 01:22:42 +02004#include "mbedtls/asn1.h"
Gilles Peskine0b352bc2018-06-28 00:16:11 +02005#include "mbedtls/asn1write.h"
Gilles Peskinedd2f95b2018-08-11 01:22:42 +02006#include "mbedtls/oid.h"
7
Gilles Peskinebdc96fd2019-08-07 12:08:04 +02008/* For MBEDTLS_CTR_DRBG_MAX_REQUEST, knowing that psa_generate_random()
9 * uses mbedtls_ctr_drbg internally. */
10#include "mbedtls/ctr_drbg.h"
11
Gilles Peskinebdc96fd2019-08-07 12:08:04 +020012#include "psa/crypto.h"
Ronald Cron41841072020-09-17 15:28:26 +020013#include "psa_crypto_slot_management.h"
Gilles Peskinebdc96fd2019-08-07 12:08:04 +020014
Gilles Peskine8e94efe2021-02-13 00:25:53 +010015#include "test/asn1_helpers.h"
Ronald Cron28a45ed2021-02-09 20:35:42 +010016#include "test/psa_crypto_helpers.h"
Gilles Peskinee78b0022021-02-13 00:41:11 +010017#include "test/psa_exercise_key.h"
Ronald Cron28a45ed2021-02-09 20:35:42 +010018
Jaeden Amerof24c7f82018-06-27 17:20:43 +010019/** An invalid export length that will never be set by psa_export_key(). */
20static const size_t INVALID_EXPORT_LENGTH = ~0U;
21
Gilles Peskinea7aa4422018-08-14 15:17:54 +020022/** Test if a buffer contains a constant byte value.
23 *
24 * `mem_is_char(buffer, c, size)` is true after `memset(buffer, c, size)`.
Gilles Peskinee66ca3b2018-06-20 00:11:45 +020025 *
26 * \param buffer Pointer to the beginning of the buffer.
Gilles Peskinea7aa4422018-08-14 15:17:54 +020027 * \param c Expected value of every byte.
Gilles Peskinee66ca3b2018-06-20 00:11:45 +020028 * \param size Size of the buffer in bytes.
29 *
Gilles Peskine3f669c32018-06-21 09:21:51 +020030 * \return 1 if the buffer is all-bits-zero.
31 * \return 0 if there is at least one nonzero byte.
Gilles Peskinee66ca3b2018-06-20 00:11:45 +020032 */
Gilles Peskinea7aa4422018-08-14 15:17:54 +020033static int mem_is_char( void *buffer, unsigned char c, size_t size )
Gilles Peskinee66ca3b2018-06-20 00:11:45 +020034{
35 size_t i;
36 for( i = 0; i < size; i++ )
37 {
Gilles Peskinea7aa4422018-08-14 15:17:54 +020038 if( ( (unsigned char *) buffer )[i] != c )
Gilles Peskine3f669c32018-06-21 09:21:51 +020039 return( 0 );
Gilles Peskinee66ca3b2018-06-20 00:11:45 +020040 }
Gilles Peskine3f669c32018-06-21 09:21:51 +020041 return( 1 );
Gilles Peskinee66ca3b2018-06-20 00:11:45 +020042}
Gilles Peskine818ca122018-06-20 18:16:48 +020043
Gilles Peskine0b352bc2018-06-28 00:16:11 +020044/* Write the ASN.1 INTEGER with the value 2^(bits-1)+x backwards from *p. */
45static int asn1_write_10x( unsigned char **p,
46 unsigned char *start,
47 size_t bits,
48 unsigned char x )
49{
50 int ret;
51 int len = bits / 8 + 1;
Gilles Peskine480416a2018-06-28 19:04:07 +020052 if( bits == 0 )
53 return( MBEDTLS_ERR_ASN1_INVALID_DATA );
54 if( bits <= 8 && x >= 1 << ( bits - 1 ) )
Gilles Peskine0b352bc2018-06-28 00:16:11 +020055 return( MBEDTLS_ERR_ASN1_INVALID_DATA );
Moran Pekercb088e72018-07-17 17:36:59 +030056 if( *p < start || *p - start < (ptrdiff_t) len )
Gilles Peskine0b352bc2018-06-28 00:16:11 +020057 return( MBEDTLS_ERR_ASN1_BUF_TOO_SMALL );
58 *p -= len;
59 ( *p )[len-1] = x;
60 if( bits % 8 == 0 )
61 ( *p )[1] |= 1;
62 else
63 ( *p )[0] |= 1 << ( bits % 8 );
64 MBEDTLS_ASN1_CHK_ADD( len, mbedtls_asn1_write_len( p, start, len ) );
65 MBEDTLS_ASN1_CHK_ADD( len, mbedtls_asn1_write_tag( p, start,
66 MBEDTLS_ASN1_INTEGER ) );
67 return( len );
68}
69
70static int construct_fake_rsa_key( unsigned char *buffer,
71 size_t buffer_size,
72 unsigned char **p,
73 size_t bits,
74 int keypair )
75{
76 size_t half_bits = ( bits + 1 ) / 2;
77 int ret;
78 int len = 0;
79 /* Construct something that looks like a DER encoding of
80 * as defined by PKCS#1 v2.2 (RFC 8017) section A.1.2:
81 * RSAPrivateKey ::= SEQUENCE {
82 * version Version,
83 * modulus INTEGER, -- n
84 * publicExponent INTEGER, -- e
85 * privateExponent INTEGER, -- d
86 * prime1 INTEGER, -- p
87 * prime2 INTEGER, -- q
88 * exponent1 INTEGER, -- d mod (p-1)
89 * exponent2 INTEGER, -- d mod (q-1)
90 * coefficient INTEGER, -- (inverse of q) mod p
91 * otherPrimeInfos OtherPrimeInfos OPTIONAL
92 * }
93 * Or, for a public key, the same structure with only
94 * version, modulus and publicExponent.
95 */
96 *p = buffer + buffer_size;
97 if( keypair )
98 {
99 MBEDTLS_ASN1_CHK_ADD( len, /* pq */
100 asn1_write_10x( p, buffer, half_bits, 1 ) );
101 MBEDTLS_ASN1_CHK_ADD( len, /* dq */
102 asn1_write_10x( p, buffer, half_bits, 1 ) );
103 MBEDTLS_ASN1_CHK_ADD( len, /* dp */
104 asn1_write_10x( p, buffer, half_bits, 1 ) );
105 MBEDTLS_ASN1_CHK_ADD( len, /* q */
106 asn1_write_10x( p, buffer, half_bits, 1 ) );
107 MBEDTLS_ASN1_CHK_ADD( len, /* p != q to pass mbedtls sanity checks */
108 asn1_write_10x( p, buffer, half_bits, 3 ) );
109 MBEDTLS_ASN1_CHK_ADD( len, /* d */
110 asn1_write_10x( p, buffer, bits, 1 ) );
111 }
112 MBEDTLS_ASN1_CHK_ADD( len, /* e = 65537 */
113 asn1_write_10x( p, buffer, 17, 1 ) );
114 MBEDTLS_ASN1_CHK_ADD( len, /* n */
115 asn1_write_10x( p, buffer, bits, 1 ) );
116 if( keypair )
117 MBEDTLS_ASN1_CHK_ADD( len, /* version = 0 */
118 mbedtls_asn1_write_int( p, buffer, 0 ) );
119 MBEDTLS_ASN1_CHK_ADD( len, mbedtls_asn1_write_len( p, buffer, len ) );
120 {
121 const unsigned char tag =
122 MBEDTLS_ASN1_CONSTRUCTED | MBEDTLS_ASN1_SEQUENCE;
123 MBEDTLS_ASN1_CHK_ADD( len, mbedtls_asn1_write_tag( p, buffer, tag ) );
124 }
125 return( len );
126}
127
Gilles Peskinef426e0f2019-02-25 17:42:03 +0100128int exercise_mac_setup( psa_key_type_t key_type,
129 const unsigned char *key_bytes,
130 size_t key_length,
131 psa_algorithm_t alg,
132 psa_mac_operation_t *operation,
133 psa_status_t *status )
134{
Ronald Cron5425a212020-08-04 14:58:35 +0200135 mbedtls_svc_key_id_t key = MBEDTLS_SVC_KEY_ID_INIT;
Gilles Peskine2c2cf0e2019-04-19 19:58:20 +0200136 psa_key_attributes_t attributes = PSA_KEY_ATTRIBUTES_INIT;
Gilles Peskinef426e0f2019-02-25 17:42:03 +0100137
Gilles Peskine89d8c5c2019-11-26 17:01:59 +0100138 psa_set_key_usage_flags( &attributes, PSA_KEY_USAGE_SIGN_HASH );
Gilles Peskine2c2cf0e2019-04-19 19:58:20 +0200139 psa_set_key_algorithm( &attributes, alg );
140 psa_set_key_type( &attributes, key_type );
Ronald Cron5425a212020-08-04 14:58:35 +0200141 PSA_ASSERT( psa_import_key( &attributes, key_bytes, key_length, &key ) );
Gilles Peskinef426e0f2019-02-25 17:42:03 +0100142
Ronald Cron5425a212020-08-04 14:58:35 +0200143 *status = psa_mac_sign_setup( operation, key, alg );
Gilles Peskine9e0a4a52019-02-25 22:11:18 +0100144 /* Whether setup succeeded or failed, abort must succeed. */
145 PSA_ASSERT( psa_mac_abort( operation ) );
146 /* If setup failed, reproduce the failure, so that the caller can
147 * test the resulting state of the operation object. */
148 if( *status != PSA_SUCCESS )
Gilles Peskinef426e0f2019-02-25 17:42:03 +0100149 {
Ronald Cron5425a212020-08-04 14:58:35 +0200150 TEST_EQUAL( psa_mac_sign_setup( operation, key, alg ), *status );
Gilles Peskinef426e0f2019-02-25 17:42:03 +0100151 }
152
Ronald Cron5425a212020-08-04 14:58:35 +0200153 psa_destroy_key( key );
Gilles Peskinef426e0f2019-02-25 17:42:03 +0100154 return( 1 );
155
156exit:
Ronald Cron5425a212020-08-04 14:58:35 +0200157 psa_destroy_key( key );
Gilles Peskinef426e0f2019-02-25 17:42:03 +0100158 return( 0 );
159}
160
161int exercise_cipher_setup( psa_key_type_t key_type,
162 const unsigned char *key_bytes,
163 size_t key_length,
164 psa_algorithm_t alg,
165 psa_cipher_operation_t *operation,
166 psa_status_t *status )
167{
Ronald Cron5425a212020-08-04 14:58:35 +0200168 mbedtls_svc_key_id_t key = MBEDTLS_SVC_KEY_ID_INIT;
Gilles Peskine2c2cf0e2019-04-19 19:58:20 +0200169 psa_key_attributes_t attributes = PSA_KEY_ATTRIBUTES_INIT;
Gilles Peskinef426e0f2019-02-25 17:42:03 +0100170
Gilles Peskine2c2cf0e2019-04-19 19:58:20 +0200171 psa_set_key_usage_flags( &attributes, PSA_KEY_USAGE_ENCRYPT );
172 psa_set_key_algorithm( &attributes, alg );
173 psa_set_key_type( &attributes, key_type );
Ronald Cron5425a212020-08-04 14:58:35 +0200174 PSA_ASSERT( psa_import_key( &attributes, key_bytes, key_length, &key ) );
Gilles Peskinef426e0f2019-02-25 17:42:03 +0100175
Ronald Cron5425a212020-08-04 14:58:35 +0200176 *status = psa_cipher_encrypt_setup( operation, key, alg );
Gilles Peskine9e0a4a52019-02-25 22:11:18 +0100177 /* Whether setup succeeded or failed, abort must succeed. */
178 PSA_ASSERT( psa_cipher_abort( operation ) );
179 /* If setup failed, reproduce the failure, so that the caller can
180 * test the resulting state of the operation object. */
181 if( *status != PSA_SUCCESS )
Gilles Peskinef426e0f2019-02-25 17:42:03 +0100182 {
Ronald Cron5425a212020-08-04 14:58:35 +0200183 TEST_EQUAL( psa_cipher_encrypt_setup( operation, key, alg ),
Gilles Peskine9e0a4a52019-02-25 22:11:18 +0100184 *status );
Gilles Peskinef426e0f2019-02-25 17:42:03 +0100185 }
186
Ronald Cron5425a212020-08-04 14:58:35 +0200187 psa_destroy_key( key );
Gilles Peskinef426e0f2019-02-25 17:42:03 +0100188 return( 1 );
189
190exit:
Ronald Cron5425a212020-08-04 14:58:35 +0200191 psa_destroy_key( key );
Gilles Peskinef426e0f2019-02-25 17:42:03 +0100192 return( 0 );
193}
194
Ronald Cron5425a212020-08-04 14:58:35 +0200195static int test_operations_on_invalid_key( mbedtls_svc_key_id_t key )
Gilles Peskine4cf3a432019-04-18 22:28:52 +0200196{
197 psa_key_attributes_t attributes = PSA_KEY_ATTRIBUTES_INIT;
Ronald Cronecfb2372020-07-23 17:13:42 +0200198 mbedtls_svc_key_id_t key_id = mbedtls_svc_key_id_make( 1, 0x6964 );
Gilles Peskine4cf3a432019-04-18 22:28:52 +0200199 uint8_t buffer[1];
200 size_t length;
201 int ok = 0;
202
Ronald Cronecfb2372020-07-23 17:13:42 +0200203 psa_set_key_id( &attributes, key_id );
Gilles Peskine4cf3a432019-04-18 22:28:52 +0200204 psa_set_key_usage_flags( &attributes, PSA_KEY_USAGE_ENCRYPT );
205 psa_set_key_algorithm( &attributes, PSA_ALG_CTR );
206 psa_set_key_type( &attributes, PSA_KEY_TYPE_AES );
Ronald Cron5425a212020-08-04 14:58:35 +0200207 TEST_EQUAL( psa_get_key_attributes( key, &attributes ),
Maulik Patel3240c9d2021-03-17 16:11:05 +0000208 PSA_ERROR_INVALID_HANDLE );
Ronald Cronecfb2372020-07-23 17:13:42 +0200209 TEST_EQUAL(
210 MBEDTLS_SVC_KEY_ID_GET_KEY_ID( psa_get_key_id( &attributes ) ), 0 );
211 TEST_EQUAL(
212 MBEDTLS_SVC_KEY_ID_GET_OWNER_ID( psa_get_key_id( &attributes ) ), 0 );
Gilles Peskine5c648ab2019-04-19 14:06:53 +0200213 TEST_EQUAL( psa_get_key_lifetime( &attributes ), 0 );
Gilles Peskine4cf3a432019-04-18 22:28:52 +0200214 TEST_EQUAL( psa_get_key_usage_flags( &attributes ), 0 );
215 TEST_EQUAL( psa_get_key_algorithm( &attributes ), 0 );
216 TEST_EQUAL( psa_get_key_type( &attributes ), 0 );
217 TEST_EQUAL( psa_get_key_bits( &attributes ), 0 );
218
Ronald Cron5425a212020-08-04 14:58:35 +0200219 TEST_EQUAL( psa_export_key( key, buffer, sizeof( buffer ), &length ),
Maulik Patel3240c9d2021-03-17 16:11:05 +0000220 PSA_ERROR_INVALID_HANDLE );
Ronald Cron5425a212020-08-04 14:58:35 +0200221 TEST_EQUAL( psa_export_public_key( key,
Gilles Peskine4cf3a432019-04-18 22:28:52 +0200222 buffer, sizeof( buffer ), &length ),
Maulik Patel3240c9d2021-03-17 16:11:05 +0000223 PSA_ERROR_INVALID_HANDLE );
Gilles Peskine4cf3a432019-04-18 22:28:52 +0200224
Gilles Peskine4cf3a432019-04-18 22:28:52 +0200225 ok = 1;
226
227exit:
Ronald Cron3a4f0e32020-11-19 17:55:23 +0100228 /*
229 * Key attributes may have been returned by psa_get_key_attributes()
230 * thus reset them as required.
231 */
Gilles Peskine4cf3a432019-04-18 22:28:52 +0200232 psa_reset_key_attributes( &attributes );
Ronald Cron3a4f0e32020-11-19 17:55:23 +0100233
Gilles Peskine4cf3a432019-04-18 22:28:52 +0200234 return( ok );
235}
236
Gilles Peskine5fe5e272019-08-02 20:30:01 +0200237/* Assert that a key isn't reported as having a slot number. */
238#if defined(MBEDTLS_PSA_CRYPTO_SE_C)
239#define ASSERT_NO_SLOT_NUMBER( attributes ) \
240 do \
241 { \
242 psa_key_slot_number_t ASSERT_NO_SLOT_NUMBER_slot_number; \
243 TEST_EQUAL( psa_get_key_slot_number( \
244 attributes, \
245 &ASSERT_NO_SLOT_NUMBER_slot_number ), \
246 PSA_ERROR_INVALID_ARGUMENT ); \
247 } \
248 while( 0 )
249#else /* MBEDTLS_PSA_CRYPTO_SE_C */
250#define ASSERT_NO_SLOT_NUMBER( attributes ) \
251 ( (void) 0 )
252#endif /* MBEDTLS_PSA_CRYPTO_SE_C */
253
Gilles Peskinebdf309c2018-12-03 15:36:32 +0100254/* An overapproximation of the amount of storage needed for a key of the
255 * given type and with the given content. The API doesn't make it easy
256 * to find a good value for the size. The current implementation doesn't
257 * care about the value anyway. */
258#define KEY_BITS_FROM_DATA( type, data ) \
259 ( data )->len
260
Darryl Green0c6575a2018-11-07 16:05:30 +0000261typedef enum {
262 IMPORT_KEY = 0,
263 GENERATE_KEY = 1,
264 DERIVE_KEY = 2
265} generate_method;
266
Gilles Peskinee59236f2018-01-27 23:32:46 +0100267/* END_HEADER */
268
269/* BEGIN_DEPENDENCIES
270 * depends_on:MBEDTLS_PSA_CRYPTO_C
271 * END_DEPENDENCIES
272 */
273
274/* BEGIN_CASE */
Gilles Peskinee1f2d7d2018-08-21 14:54:54 +0200275void static_checks( )
276{
277 size_t max_truncated_mac_size =
278 PSA_ALG_MAC_TRUNCATION_MASK >> PSA_MAC_TRUNCATION_OFFSET;
279
280 /* Check that the length for a truncated MAC always fits in the algorithm
281 * encoding. The shifted mask is the maximum truncated value. The
282 * untruncated algorithm may be one byte larger. */
283 TEST_ASSERT( PSA_MAC_MAX_SIZE <= 1 + max_truncated_mac_size );
284}
285/* END_CASE */
286
287/* BEGIN_CASE */
Gilles Peskine6edfa292019-07-31 15:53:45 +0200288void import_with_policy( int type_arg,
289 int usage_arg, int alg_arg,
290 int expected_status_arg )
291{
292 psa_key_attributes_t attributes = PSA_KEY_ATTRIBUTES_INIT;
293 psa_key_attributes_t got_attributes = PSA_KEY_ATTRIBUTES_INIT;
Ronald Cron5425a212020-08-04 14:58:35 +0200294 mbedtls_svc_key_id_t key = MBEDTLS_SVC_KEY_ID_INIT;
Gilles Peskine6edfa292019-07-31 15:53:45 +0200295 psa_key_type_t type = type_arg;
296 psa_key_usage_t usage = usage_arg;
297 psa_algorithm_t alg = alg_arg;
298 psa_status_t expected_status = expected_status_arg;
299 const uint8_t key_material[16] = {0};
300 psa_status_t status;
301
302 PSA_ASSERT( psa_crypto_init( ) );
303
304 psa_set_key_type( &attributes, type );
305 psa_set_key_usage_flags( &attributes, usage );
306 psa_set_key_algorithm( &attributes, alg );
307
308 status = psa_import_key( &attributes,
309 key_material, sizeof( key_material ),
Ronald Cron5425a212020-08-04 14:58:35 +0200310 &key );
Gilles Peskine6edfa292019-07-31 15:53:45 +0200311 TEST_EQUAL( status, expected_status );
312 if( status != PSA_SUCCESS )
313 goto exit;
314
Ronald Cron5425a212020-08-04 14:58:35 +0200315 PSA_ASSERT( psa_get_key_attributes( key, &got_attributes ) );
Gilles Peskine6edfa292019-07-31 15:53:45 +0200316 TEST_EQUAL( psa_get_key_type( &got_attributes ), type );
317 TEST_EQUAL( psa_get_key_usage_flags( &got_attributes ), usage );
318 TEST_EQUAL( psa_get_key_algorithm( &got_attributes ), alg );
Gilles Peskine5fe5e272019-08-02 20:30:01 +0200319 ASSERT_NO_SLOT_NUMBER( &got_attributes );
Gilles Peskine6edfa292019-07-31 15:53:45 +0200320
Ronald Cron5425a212020-08-04 14:58:35 +0200321 PSA_ASSERT( psa_destroy_key( key ) );
322 test_operations_on_invalid_key( key );
Gilles Peskine6edfa292019-07-31 15:53:45 +0200323
324exit:
Ronald Cron3a4f0e32020-11-19 17:55:23 +0100325 /*
326 * Key attributes may have been returned by psa_get_key_attributes()
327 * thus reset them as required.
328 */
Gilles Peskine6edfa292019-07-31 15:53:45 +0200329 psa_reset_key_attributes( &got_attributes );
Ronald Cron3a4f0e32020-11-19 17:55:23 +0100330
331 psa_destroy_key( key );
Gilles Peskine6edfa292019-07-31 15:53:45 +0200332 PSA_DONE( );
333}
334/* END_CASE */
335
336/* BEGIN_CASE */
337void import_with_data( data_t *data, int type_arg,
338 int attr_bits_arg,
339 int expected_status_arg )
Gilles Peskine8c8f2ab2019-04-18 21:44:46 +0200340{
341 psa_key_attributes_t attributes = PSA_KEY_ATTRIBUTES_INIT;
342 psa_key_attributes_t got_attributes = PSA_KEY_ATTRIBUTES_INIT;
Ronald Cron5425a212020-08-04 14:58:35 +0200343 mbedtls_svc_key_id_t key = MBEDTLS_SVC_KEY_ID_INIT;
Gilles Peskine8c8f2ab2019-04-18 21:44:46 +0200344 psa_key_type_t type = type_arg;
Gilles Peskine8fb3a9e2019-05-03 16:59:21 +0200345 size_t attr_bits = attr_bits_arg;
Gilles Peskineb866e2b2018-06-21 09:25:10 +0200346 psa_status_t expected_status = expected_status_arg;
Gilles Peskine2f9c4dc2018-01-28 13:16:24 +0100347 psa_status_t status;
Gilles Peskine2f9c4dc2018-01-28 13:16:24 +0100348
Gilles Peskine8817f612018-12-18 00:18:46 +0100349 PSA_ASSERT( psa_crypto_init( ) );
Gilles Peskine2f9c4dc2018-01-28 13:16:24 +0100350
Gilles Peskine4747d192019-04-17 15:05:45 +0200351 psa_set_key_type( &attributes, type );
Gilles Peskine8fb3a9e2019-05-03 16:59:21 +0200352 psa_set_key_bits( &attributes, attr_bits );
Gilles Peskine6edfa292019-07-31 15:53:45 +0200353
Ronald Cron5425a212020-08-04 14:58:35 +0200354 status = psa_import_key( &attributes, data->x, data->len, &key );
Gilles Peskinefe11b722018-12-18 00:24:04 +0100355 TEST_EQUAL( status, expected_status );
Gilles Peskine8c8f2ab2019-04-18 21:44:46 +0200356 if( status != PSA_SUCCESS )
357 goto exit;
358
Ronald Cron5425a212020-08-04 14:58:35 +0200359 PSA_ASSERT( psa_get_key_attributes( key, &got_attributes ) );
Gilles Peskine8c8f2ab2019-04-18 21:44:46 +0200360 TEST_EQUAL( psa_get_key_type( &got_attributes ), type );
Gilles Peskine8fb3a9e2019-05-03 16:59:21 +0200361 if( attr_bits != 0 )
Gilles Peskine7e0cff92019-07-30 13:48:52 +0200362 TEST_EQUAL( attr_bits, psa_get_key_bits( &got_attributes ) );
Gilles Peskine5fe5e272019-08-02 20:30:01 +0200363 ASSERT_NO_SLOT_NUMBER( &got_attributes );
Gilles Peskine8c8f2ab2019-04-18 21:44:46 +0200364
Ronald Cron5425a212020-08-04 14:58:35 +0200365 PSA_ASSERT( psa_destroy_key( key ) );
366 test_operations_on_invalid_key( key );
Gilles Peskine2f9c4dc2018-01-28 13:16:24 +0100367
368exit:
Ronald Cron3a4f0e32020-11-19 17:55:23 +0100369 /*
370 * Key attributes may have been returned by psa_get_key_attributes()
371 * thus reset them as required.
372 */
Gilles Peskinea1ace9c2019-04-26 16:03:33 +0200373 psa_reset_key_attributes( &got_attributes );
Ronald Cron3a4f0e32020-11-19 17:55:23 +0100374
375 psa_destroy_key( key );
Gilles Peskine1153e7b2019-05-28 15:10:21 +0200376 PSA_DONE( );
Gilles Peskine2f9c4dc2018-01-28 13:16:24 +0100377}
378/* END_CASE */
379
380/* BEGIN_CASE */
Gilles Peskinec744d992019-07-30 17:26:54 +0200381void import_large_key( int type_arg, int byte_size_arg,
382 int expected_status_arg )
383{
384 psa_key_type_t type = type_arg;
385 size_t byte_size = byte_size_arg;
386 psa_key_attributes_t attributes = PSA_KEY_ATTRIBUTES_INIT;
387 psa_status_t expected_status = expected_status_arg;
Ronald Cron5425a212020-08-04 14:58:35 +0200388 mbedtls_svc_key_id_t key = MBEDTLS_SVC_KEY_ID_INIT;
Gilles Peskinec744d992019-07-30 17:26:54 +0200389 psa_status_t status;
390 uint8_t *buffer = NULL;
391 size_t buffer_size = byte_size + 1;
392 size_t n;
393
Steven Cooreman69967ce2021-01-18 18:01:08 +0100394 /* Skip the test case if the target running the test cannot
395 * accomodate large keys due to heap size constraints */
396 ASSERT_ALLOC_WEAK( buffer, buffer_size );
Gilles Peskinec744d992019-07-30 17:26:54 +0200397 memset( buffer, 'K', byte_size );
398
399 PSA_ASSERT( psa_crypto_init( ) );
400
401 /* Try importing the key */
402 psa_set_key_usage_flags( &attributes, PSA_KEY_USAGE_EXPORT );
403 psa_set_key_type( &attributes, type );
Ronald Cron5425a212020-08-04 14:58:35 +0200404 status = psa_import_key( &attributes, buffer, byte_size, &key );
Steven Cooreman83fdb702021-01-21 14:24:39 +0100405 TEST_ASSUME( status != PSA_ERROR_INSUFFICIENT_MEMORY );
Gilles Peskinec744d992019-07-30 17:26:54 +0200406 TEST_EQUAL( status, expected_status );
407
408 if( status == PSA_SUCCESS )
409 {
Ronald Cron5425a212020-08-04 14:58:35 +0200410 PSA_ASSERT( psa_get_key_attributes( key, &attributes ) );
Gilles Peskinec744d992019-07-30 17:26:54 +0200411 TEST_EQUAL( psa_get_key_type( &attributes ), type );
412 TEST_EQUAL( psa_get_key_bits( &attributes ),
413 PSA_BYTES_TO_BITS( byte_size ) );
Gilles Peskine5fe5e272019-08-02 20:30:01 +0200414 ASSERT_NO_SLOT_NUMBER( &attributes );
Gilles Peskinec744d992019-07-30 17:26:54 +0200415 memset( buffer, 0, byte_size + 1 );
Ronald Cron5425a212020-08-04 14:58:35 +0200416 PSA_ASSERT( psa_export_key( key, buffer, byte_size, &n ) );
Gilles Peskinec744d992019-07-30 17:26:54 +0200417 for( n = 0; n < byte_size; n++ )
418 TEST_EQUAL( buffer[n], 'K' );
419 for( n = byte_size; n < buffer_size; n++ )
420 TEST_EQUAL( buffer[n], 0 );
421 }
422
423exit:
Ronald Cron3a4f0e32020-11-19 17:55:23 +0100424 /*
425 * Key attributes may have been returned by psa_get_key_attributes()
426 * thus reset them as required.
427 */
428 psa_reset_key_attributes( &attributes );
429
Ronald Cron5425a212020-08-04 14:58:35 +0200430 psa_destroy_key( key );
Gilles Peskinec744d992019-07-30 17:26:54 +0200431 PSA_DONE( );
432 mbedtls_free( buffer );
433}
434/* END_CASE */
435
436/* BEGIN_CASE */
Gilles Peskine0b352bc2018-06-28 00:16:11 +0200437void import_rsa_made_up( int bits_arg, int keypair, int expected_status_arg )
438{
Ronald Cron5425a212020-08-04 14:58:35 +0200439 mbedtls_svc_key_id_t key = MBEDTLS_SVC_KEY_ID_INIT;
Gilles Peskine0b352bc2018-06-28 00:16:11 +0200440 size_t bits = bits_arg;
441 psa_status_t expected_status = expected_status_arg;
442 psa_status_t status;
443 psa_key_type_t type =
Gilles Peskinec93b80c2019-05-16 19:39:54 +0200444 keypair ? PSA_KEY_TYPE_RSA_KEY_PAIR : PSA_KEY_TYPE_RSA_PUBLIC_KEY;
Gilles Peskine0b352bc2018-06-28 00:16:11 +0200445 size_t buffer_size = /* Slight overapproximations */
446 keypair ? bits * 9 / 16 + 80 : bits / 8 + 20;
Gilles Peskine8cebbba2018-09-27 13:54:18 +0200447 unsigned char *buffer = NULL;
Gilles Peskine0b352bc2018-06-28 00:16:11 +0200448 unsigned char *p;
449 int ret;
450 size_t length;
Gilles Peskine2c2cf0e2019-04-19 19:58:20 +0200451 psa_key_attributes_t attributes = PSA_KEY_ATTRIBUTES_INIT;
Gilles Peskine0b352bc2018-06-28 00:16:11 +0200452
Gilles Peskine8817f612018-12-18 00:18:46 +0100453 PSA_ASSERT( psa_crypto_init( ) );
Gilles Peskine8cebbba2018-09-27 13:54:18 +0200454 ASSERT_ALLOC( buffer, buffer_size );
Gilles Peskine0b352bc2018-06-28 00:16:11 +0200455
456 TEST_ASSERT( ( ret = construct_fake_rsa_key( buffer, buffer_size, &p,
457 bits, keypair ) ) >= 0 );
458 length = ret;
459
460 /* Try importing the key */
Gilles Peskine2c2cf0e2019-04-19 19:58:20 +0200461 psa_set_key_type( &attributes, type );
Ronald Cron5425a212020-08-04 14:58:35 +0200462 status = psa_import_key( &attributes, p, length, &key );
Gilles Peskinefe11b722018-12-18 00:24:04 +0100463 TEST_EQUAL( status, expected_status );
Gilles Peskine76b29a72019-05-28 14:08:50 +0200464
Gilles Peskine0b352bc2018-06-28 00:16:11 +0200465 if( status == PSA_SUCCESS )
Ronald Cron5425a212020-08-04 14:58:35 +0200466 PSA_ASSERT( psa_destroy_key( key ) );
Gilles Peskine0b352bc2018-06-28 00:16:11 +0200467
468exit:
469 mbedtls_free( buffer );
Gilles Peskine1153e7b2019-05-28 15:10:21 +0200470 PSA_DONE( );
Gilles Peskine0b352bc2018-06-28 00:16:11 +0200471}
472/* END_CASE */
473
474/* BEGIN_CASE */
itayzafrir3e02b3b2018-06-12 17:06:52 +0300475void import_export( data_t *data,
Moran Pekera964a8f2018-06-04 18:42:36 +0300476 int type_arg,
Gilles Peskine1ecf92c22019-05-24 15:00:06 +0200477 int usage_arg, int alg_arg,
Gilles Peskine2f9c4dc2018-01-28 13:16:24 +0100478 int expected_bits,
479 int export_size_delta,
Gilles Peskineb866e2b2018-06-21 09:25:10 +0200480 int expected_export_status_arg,
Gilles Peskine2f9c4dc2018-01-28 13:16:24 +0100481 int canonical_input )
482{
Ronald Cron5425a212020-08-04 14:58:35 +0200483 mbedtls_svc_key_id_t key = MBEDTLS_SVC_KEY_ID_INIT;
Gilles Peskine2f9c4dc2018-01-28 13:16:24 +0100484 psa_key_type_t type = type_arg;
Gilles Peskine4abf7412018-06-18 16:35:34 +0200485 psa_algorithm_t alg = alg_arg;
Gilles Peskineb866e2b2018-06-21 09:25:10 +0200486 psa_status_t expected_export_status = expected_export_status_arg;
Gilles Peskine2f9c4dc2018-01-28 13:16:24 +0100487 psa_status_t status;
Gilles Peskine2f9c4dc2018-01-28 13:16:24 +0100488 unsigned char *exported = NULL;
489 unsigned char *reexported = NULL;
Gilles Peskine2f9c4dc2018-01-28 13:16:24 +0100490 size_t export_size;
Jaeden Amerof24c7f82018-06-27 17:20:43 +0100491 size_t exported_length = INVALID_EXPORT_LENGTH;
Gilles Peskine2f9c4dc2018-01-28 13:16:24 +0100492 size_t reexported_length;
Gilles Peskine4747d192019-04-17 15:05:45 +0200493 psa_key_attributes_t attributes = PSA_KEY_ATTRIBUTES_INIT;
Gilles Peskine8c8f2ab2019-04-18 21:44:46 +0200494 psa_key_attributes_t got_attributes = PSA_KEY_ATTRIBUTES_INIT;
Gilles Peskine2f9c4dc2018-01-28 13:16:24 +0100495
Moran Pekercb088e72018-07-17 17:36:59 +0300496 export_size = (ptrdiff_t) data->len + export_size_delta;
Gilles Peskine8cebbba2018-09-27 13:54:18 +0200497 ASSERT_ALLOC( exported, export_size );
Gilles Peskine2f9c4dc2018-01-28 13:16:24 +0100498 if( ! canonical_input )
Gilles Peskine8cebbba2018-09-27 13:54:18 +0200499 ASSERT_ALLOC( reexported, export_size );
Gilles Peskine8817f612018-12-18 00:18:46 +0100500 PSA_ASSERT( psa_crypto_init( ) );
Gilles Peskine2f9c4dc2018-01-28 13:16:24 +0100501
Gilles Peskine4747d192019-04-17 15:05:45 +0200502 psa_set_key_usage_flags( &attributes, usage_arg );
503 psa_set_key_algorithm( &attributes, alg );
504 psa_set_key_type( &attributes, type );
mohammad1603a97cb8c2018-03-28 03:46:26 -0700505
Gilles Peskine2f9c4dc2018-01-28 13:16:24 +0100506 /* Import the key */
Ronald Cron5425a212020-08-04 14:58:35 +0200507 PSA_ASSERT( psa_import_key( &attributes, data->x, data->len, &key ) );
Gilles Peskine2f9c4dc2018-01-28 13:16:24 +0100508
509 /* Test the key information */
Ronald Cron5425a212020-08-04 14:58:35 +0200510 PSA_ASSERT( psa_get_key_attributes( key, &got_attributes ) );
Gilles Peskine8c8f2ab2019-04-18 21:44:46 +0200511 TEST_EQUAL( psa_get_key_type( &got_attributes ), type );
512 TEST_EQUAL( psa_get_key_bits( &got_attributes ), (size_t) expected_bits );
Gilles Peskine5fe5e272019-08-02 20:30:01 +0200513 ASSERT_NO_SLOT_NUMBER( &got_attributes );
Gilles Peskine2f9c4dc2018-01-28 13:16:24 +0100514
515 /* Export the key */
Ronald Cron5425a212020-08-04 14:58:35 +0200516 status = psa_export_key( key, exported, export_size, &exported_length );
Gilles Peskinefe11b722018-12-18 00:24:04 +0100517 TEST_EQUAL( status, expected_export_status );
Jaeden Amerof24c7f82018-06-27 17:20:43 +0100518
519 /* The exported length must be set by psa_export_key() to a value between 0
520 * and export_size. On errors, the exported length must be 0. */
521 TEST_ASSERT( exported_length != INVALID_EXPORT_LENGTH );
522 TEST_ASSERT( status == PSA_SUCCESS || exported_length == 0 );
523 TEST_ASSERT( exported_length <= export_size );
524
Gilles Peskinea7aa4422018-08-14 15:17:54 +0200525 TEST_ASSERT( mem_is_char( exported + exported_length, 0,
Gilles Peskine3f669c32018-06-21 09:21:51 +0200526 export_size - exported_length ) );
Gilles Peskine2f9c4dc2018-01-28 13:16:24 +0100527 if( status != PSA_SUCCESS )
Gilles Peskinee66ca3b2018-06-20 00:11:45 +0200528 {
Gilles Peskinefe11b722018-12-18 00:24:04 +0100529 TEST_EQUAL( exported_length, 0 );
Gilles Peskine2f9c4dc2018-01-28 13:16:24 +0100530 goto destroy;
Gilles Peskinee66ca3b2018-06-20 00:11:45 +0200531 }
Gilles Peskine2f9c4dc2018-01-28 13:16:24 +0100532
Gilles Peskineea38a922021-02-13 00:05:16 +0100533 /* Run sanity checks on the exported key. For non-canonical inputs,
534 * this validates the canonical representations. For canonical inputs,
535 * this doesn't directly validate the implementation, but it still helps
536 * by cross-validating the test data with the sanity check code. */
537 if( ! mbedtls_test_psa_exercise_key( key, usage_arg, 0 ) )
Gilles Peskine8f609232018-08-11 01:24:55 +0200538 goto exit;
539
Gilles Peskine2f9c4dc2018-01-28 13:16:24 +0100540 if( canonical_input )
Gilles Peskinebd7dea92018-09-27 13:57:19 +0200541 ASSERT_COMPARE( data->x, data->len, exported, exported_length );
Gilles Peskine2f9c4dc2018-01-28 13:16:24 +0100542 else
543 {
Ronald Cron5425a212020-08-04 14:58:35 +0200544 mbedtls_svc_key_id_t key2 = MBEDTLS_SVC_KEY_ID_INIT;
Gilles Peskine049c7532019-05-15 20:22:09 +0200545 PSA_ASSERT( psa_import_key( &attributes, exported, exported_length,
Ronald Cron5425a212020-08-04 14:58:35 +0200546 &key2 ) );
547 PSA_ASSERT( psa_export_key( key2,
Gilles Peskine8817f612018-12-18 00:18:46 +0100548 reexported,
549 export_size,
550 &reexported_length ) );
Gilles Peskinebd7dea92018-09-27 13:57:19 +0200551 ASSERT_COMPARE( exported, exported_length,
552 reexported, reexported_length );
Ronald Cron5425a212020-08-04 14:58:35 +0200553 PSA_ASSERT( psa_destroy_key( key2 ) );
Gilles Peskine2f9c4dc2018-01-28 13:16:24 +0100554 }
gabor-mezei-armceface22021-01-21 12:26:17 +0100555 TEST_ASSERT( exported_length <=
556 PSA_EXPORT_KEY_OUTPUT_SIZE( type,
557 psa_get_key_bits( &got_attributes ) ) );
558 TEST_ASSERT( exported_length <= PSA_EXPORT_KEY_PAIR_MAX_SIZE );
Gilles Peskine2f9c4dc2018-01-28 13:16:24 +0100559
560destroy:
561 /* Destroy the key */
Ronald Cron5425a212020-08-04 14:58:35 +0200562 PSA_ASSERT( psa_destroy_key( key ) );
563 test_operations_on_invalid_key( key );
Gilles Peskine2f9c4dc2018-01-28 13:16:24 +0100564
565exit:
Ronald Cron3a4f0e32020-11-19 17:55:23 +0100566 /*
567 * Key attributes may have been returned by psa_get_key_attributes()
568 * thus reset them as required.
569 */
570 psa_reset_key_attributes( &got_attributes );
571
itayzafrir3e02b3b2018-06-12 17:06:52 +0300572 mbedtls_free( exported );
573 mbedtls_free( reexported );
Gilles Peskine1153e7b2019-05-28 15:10:21 +0200574 PSA_DONE( );
Gilles Peskine2f9c4dc2018-01-28 13:16:24 +0100575}
576/* END_CASE */
Gilles Peskine20035e32018-02-03 22:44:14 +0100577
Moran Pekerf709f4a2018-06-06 17:26:04 +0300578/* BEGIN_CASE */
itayzafrir3e02b3b2018-06-12 17:06:52 +0300579void import_export_public_key( data_t *data,
Gilles Peskine2d277862018-06-18 15:41:12 +0200580 int type_arg,
581 int alg_arg,
Gilles Peskine49c25912018-10-29 15:15:31 +0100582 int export_size_delta,
583 int expected_export_status_arg,
584 data_t *expected_public_key )
Moran Pekerf709f4a2018-06-06 17:26:04 +0300585{
Ronald Cron5425a212020-08-04 14:58:35 +0200586 mbedtls_svc_key_id_t key = MBEDTLS_SVC_KEY_ID_INIT;
Moran Pekerf709f4a2018-06-06 17:26:04 +0300587 psa_key_type_t type = type_arg;
Gilles Peskine4abf7412018-06-18 16:35:34 +0200588 psa_algorithm_t alg = alg_arg;
Gilles Peskineb866e2b2018-06-21 09:25:10 +0200589 psa_status_t expected_export_status = expected_export_status_arg;
Moran Pekerf709f4a2018-06-06 17:26:04 +0300590 psa_status_t status;
Moran Pekerf709f4a2018-06-06 17:26:04 +0300591 unsigned char *exported = NULL;
Gilles Peskine49c25912018-10-29 15:15:31 +0100592 size_t export_size = expected_public_key->len + export_size_delta;
Jaeden Amero2a671e92018-06-27 17:47:40 +0100593 size_t exported_length = INVALID_EXPORT_LENGTH;
Gilles Peskine4747d192019-04-17 15:05:45 +0200594 psa_key_attributes_t attributes = PSA_KEY_ATTRIBUTES_INIT;
Moran Pekerf709f4a2018-06-06 17:26:04 +0300595
Gilles Peskine8817f612018-12-18 00:18:46 +0100596 PSA_ASSERT( psa_crypto_init( ) );
Moran Pekerf709f4a2018-06-06 17:26:04 +0300597
Gilles Peskine4747d192019-04-17 15:05:45 +0200598 psa_set_key_usage_flags( &attributes, PSA_KEY_USAGE_EXPORT );
599 psa_set_key_algorithm( &attributes, alg );
600 psa_set_key_type( &attributes, type );
Moran Pekerf709f4a2018-06-06 17:26:04 +0300601
602 /* Import the key */
Ronald Cron5425a212020-08-04 14:58:35 +0200603 PSA_ASSERT( psa_import_key( &attributes, data->x, data->len, &key ) );
Moran Pekerf709f4a2018-06-06 17:26:04 +0300604
Gilles Peskine49c25912018-10-29 15:15:31 +0100605 /* Export the public key */
606 ASSERT_ALLOC( exported, export_size );
Ronald Cron5425a212020-08-04 14:58:35 +0200607 status = psa_export_public_key( key,
Gilles Peskine2d277862018-06-18 15:41:12 +0200608 exported, export_size,
609 &exported_length );
Gilles Peskinefe11b722018-12-18 00:24:04 +0100610 TEST_EQUAL( status, expected_export_status );
Gilles Peskine49c25912018-10-29 15:15:31 +0100611 if( status == PSA_SUCCESS )
Gilles Peskined8b7d4f2018-10-29 15:18:41 +0100612 {
Gilles Peskinec93b80c2019-05-16 19:39:54 +0200613 psa_key_type_t public_type = PSA_KEY_TYPE_PUBLIC_KEY_OF_KEY_PAIR( type );
Gilles Peskined8b7d4f2018-10-29 15:18:41 +0100614 size_t bits;
Ronald Cron5425a212020-08-04 14:58:35 +0200615 PSA_ASSERT( psa_get_key_attributes( key, &attributes ) );
Gilles Peskine8c8f2ab2019-04-18 21:44:46 +0200616 bits = psa_get_key_bits( &attributes );
Gilles Peskined8b7d4f2018-10-29 15:18:41 +0100617 TEST_ASSERT( expected_public_key->len <=
gabor-mezei-armcbcec212020-12-18 14:23:51 +0100618 PSA_EXPORT_KEY_OUTPUT_SIZE( public_type, bits ) );
gabor-mezei-armceface22021-01-21 12:26:17 +0100619 TEST_ASSERT( expected_public_key->len <=
620 PSA_EXPORT_PUBLIC_KEY_OUTPUT_SIZE( public_type, bits ) );
621 TEST_ASSERT( expected_public_key->len <=
622 PSA_EXPORT_PUBLIC_KEY_MAX_SIZE );
Gilles Peskine49c25912018-10-29 15:15:31 +0100623 ASSERT_COMPARE( expected_public_key->x, expected_public_key->len,
624 exported, exported_length );
Gilles Peskined8b7d4f2018-10-29 15:18:41 +0100625 }
Moran Pekerf709f4a2018-06-06 17:26:04 +0300626
627exit:
Ronald Cron3a4f0e32020-11-19 17:55:23 +0100628 /*
629 * Key attributes may have been returned by psa_get_key_attributes()
630 * thus reset them as required.
631 */
632 psa_reset_key_attributes( &attributes );
633
itayzafrir3e02b3b2018-06-12 17:06:52 +0300634 mbedtls_free( exported );
Ronald Cron5425a212020-08-04 14:58:35 +0200635 psa_destroy_key( key );
Gilles Peskine1153e7b2019-05-28 15:10:21 +0200636 PSA_DONE( );
Moran Pekerf709f4a2018-06-06 17:26:04 +0300637}
638/* END_CASE */
639
Gilles Peskine20035e32018-02-03 22:44:14 +0100640/* BEGIN_CASE */
Gilles Peskinea680c7a2018-06-26 16:12:43 +0200641void import_and_exercise_key( data_t *data,
642 int type_arg,
643 int bits_arg,
644 int alg_arg )
645{
Ronald Cron5425a212020-08-04 14:58:35 +0200646 mbedtls_svc_key_id_t key = MBEDTLS_SVC_KEY_ID_INIT;
Gilles Peskinea680c7a2018-06-26 16:12:43 +0200647 psa_key_type_t type = type_arg;
648 size_t bits = bits_arg;
649 psa_algorithm_t alg = alg_arg;
Gilles Peskinec18e25f2021-02-12 23:48:20 +0100650 psa_key_usage_t usage = mbedtls_test_psa_usage_to_exercise( type, alg );
Gilles Peskine4747d192019-04-17 15:05:45 +0200651 psa_key_attributes_t attributes = PSA_KEY_ATTRIBUTES_INIT;
Gilles Peskine8c8f2ab2019-04-18 21:44:46 +0200652 psa_key_attributes_t got_attributes = PSA_KEY_ATTRIBUTES_INIT;
Gilles Peskinea680c7a2018-06-26 16:12:43 +0200653
Gilles Peskine8817f612018-12-18 00:18:46 +0100654 PSA_ASSERT( psa_crypto_init( ) );
Gilles Peskinea680c7a2018-06-26 16:12:43 +0200655
Gilles Peskine4747d192019-04-17 15:05:45 +0200656 psa_set_key_usage_flags( &attributes, usage );
657 psa_set_key_algorithm( &attributes, alg );
658 psa_set_key_type( &attributes, type );
Gilles Peskinea680c7a2018-06-26 16:12:43 +0200659
660 /* Import the key */
Ronald Cron5425a212020-08-04 14:58:35 +0200661 PSA_ASSERT( psa_import_key( &attributes, data->x, data->len, &key ) );
Gilles Peskinea680c7a2018-06-26 16:12:43 +0200662
663 /* Test the key information */
Ronald Cron5425a212020-08-04 14:58:35 +0200664 PSA_ASSERT( psa_get_key_attributes( key, &got_attributes ) );
Gilles Peskine8c8f2ab2019-04-18 21:44:46 +0200665 TEST_EQUAL( psa_get_key_type( &got_attributes ), type );
666 TEST_EQUAL( psa_get_key_bits( &got_attributes ), bits );
Gilles Peskinea680c7a2018-06-26 16:12:43 +0200667
668 /* Do something with the key according to its type and permitted usage. */
Gilles Peskinec18e25f2021-02-12 23:48:20 +0100669 if( ! mbedtls_test_psa_exercise_key( key, usage, alg ) )
Gilles Peskine02b75072018-07-01 22:31:34 +0200670 goto exit;
Gilles Peskinea680c7a2018-06-26 16:12:43 +0200671
Ronald Cron5425a212020-08-04 14:58:35 +0200672 PSA_ASSERT( psa_destroy_key( key ) );
673 test_operations_on_invalid_key( key );
Gilles Peskine4cf3a432019-04-18 22:28:52 +0200674
Gilles Peskinea680c7a2018-06-26 16:12:43 +0200675exit:
Ronald Cron3a4f0e32020-11-19 17:55:23 +0100676 /*
677 * Key attributes may have been returned by psa_get_key_attributes()
678 * thus reset them as required.
679 */
Gilles Peskinea1ace9c2019-04-26 16:03:33 +0200680 psa_reset_key_attributes( &got_attributes );
Ronald Cron3a4f0e32020-11-19 17:55:23 +0100681
682 psa_reset_key_attributes( &attributes );
683 psa_destroy_key( key );
Gilles Peskine1153e7b2019-05-28 15:10:21 +0200684 PSA_DONE( );
Gilles Peskinea680c7a2018-06-26 16:12:43 +0200685}
686/* END_CASE */
687
688/* BEGIN_CASE */
Gilles Peskine06c28892019-11-26 18:07:46 +0100689void effective_key_attributes( int type_arg, int expected_type_arg,
690 int bits_arg, int expected_bits_arg,
691 int usage_arg, int expected_usage_arg,
692 int alg_arg, int expected_alg_arg )
Gilles Peskined5b33222018-06-18 22:20:03 +0200693{
Ronald Cron5425a212020-08-04 14:58:35 +0200694 mbedtls_svc_key_id_t key = MBEDTLS_SVC_KEY_ID_INIT;
Gilles Peskine1a960492019-11-26 17:12:21 +0100695 psa_key_type_t key_type = type_arg;
Gilles Peskine06c28892019-11-26 18:07:46 +0100696 psa_key_type_t expected_key_type = expected_type_arg;
Gilles Peskine1a960492019-11-26 17:12:21 +0100697 size_t bits = bits_arg;
Gilles Peskine06c28892019-11-26 18:07:46 +0100698 size_t expected_bits = expected_bits_arg;
Gilles Peskined5b33222018-06-18 22:20:03 +0200699 psa_algorithm_t alg = alg_arg;
Gilles Peskine06c28892019-11-26 18:07:46 +0100700 psa_algorithm_t expected_alg = expected_alg_arg;
Gilles Peskined5b33222018-06-18 22:20:03 +0200701 psa_key_usage_t usage = usage_arg;
Gilles Peskine06c28892019-11-26 18:07:46 +0100702 psa_key_usage_t expected_usage = expected_usage_arg;
Gilles Peskine8c8f2ab2019-04-18 21:44:46 +0200703 psa_key_attributes_t attributes = PSA_KEY_ATTRIBUTES_INIT;
Gilles Peskined5b33222018-06-18 22:20:03 +0200704
Gilles Peskine8817f612018-12-18 00:18:46 +0100705 PSA_ASSERT( psa_crypto_init( ) );
Gilles Peskined5b33222018-06-18 22:20:03 +0200706
Gilles Peskine8c8f2ab2019-04-18 21:44:46 +0200707 psa_set_key_usage_flags( &attributes, usage );
708 psa_set_key_algorithm( &attributes, alg );
709 psa_set_key_type( &attributes, key_type );
Gilles Peskine1a960492019-11-26 17:12:21 +0100710 psa_set_key_bits( &attributes, bits );
Gilles Peskined5b33222018-06-18 22:20:03 +0200711
Ronald Cron5425a212020-08-04 14:58:35 +0200712 PSA_ASSERT( psa_generate_key( &attributes, &key ) );
Gilles Peskine1a960492019-11-26 17:12:21 +0100713 psa_reset_key_attributes( &attributes );
Gilles Peskined5b33222018-06-18 22:20:03 +0200714
Ronald Cron5425a212020-08-04 14:58:35 +0200715 PSA_ASSERT( psa_get_key_attributes( key, &attributes ) );
Gilles Peskine06c28892019-11-26 18:07:46 +0100716 TEST_EQUAL( psa_get_key_type( &attributes ), expected_key_type );
717 TEST_EQUAL( psa_get_key_bits( &attributes ), expected_bits );
718 TEST_EQUAL( psa_get_key_usage_flags( &attributes ), expected_usage );
719 TEST_EQUAL( psa_get_key_algorithm( &attributes ), expected_alg );
Gilles Peskined5b33222018-06-18 22:20:03 +0200720
721exit:
Ronald Cron3a4f0e32020-11-19 17:55:23 +0100722 /*
723 * Key attributes may have been returned by psa_get_key_attributes()
724 * thus reset them as required.
725 */
Gilles Peskinea1ace9c2019-04-26 16:03:33 +0200726 psa_reset_key_attributes( &attributes );
Ronald Cron3a4f0e32020-11-19 17:55:23 +0100727
728 psa_destroy_key( key );
Gilles Peskine1153e7b2019-05-28 15:10:21 +0200729 PSA_DONE( );
Gilles Peskined5b33222018-06-18 22:20:03 +0200730}
731/* END_CASE */
732
733/* BEGIN_CASE */
Gilles Peskine06c28892019-11-26 18:07:46 +0100734void check_key_policy( int type_arg, int bits_arg,
735 int usage_arg, int alg_arg )
736{
737 test_effective_key_attributes( type_arg, type_arg, bits_arg, bits_arg,
738 usage_arg, usage_arg, alg_arg, alg_arg );
739 goto exit;
740}
741/* END_CASE */
742
743/* BEGIN_CASE */
Gilles Peskine2c2cf0e2019-04-19 19:58:20 +0200744void key_attributes_init( )
Jaeden Amero70261c52019-01-04 11:47:20 +0000745{
746 /* Test each valid way of initializing the object, except for `= {0}`, as
747 * Clang 5 complains when `-Wmissing-field-initializers` is used, even
748 * though it's OK by the C standard. We could test for this, but we'd need
749 * to supress the Clang warning for the test. */
Gilles Peskine2c2cf0e2019-04-19 19:58:20 +0200750 psa_key_attributes_t func = psa_key_attributes_init( );
751 psa_key_attributes_t init = PSA_KEY_ATTRIBUTES_INIT;
752 psa_key_attributes_t zero;
Jaeden Amero70261c52019-01-04 11:47:20 +0000753
754 memset( &zero, 0, sizeof( zero ) );
755
Gilles Peskine2c2cf0e2019-04-19 19:58:20 +0200756 TEST_EQUAL( psa_get_key_lifetime( &func ), PSA_KEY_LIFETIME_VOLATILE );
757 TEST_EQUAL( psa_get_key_lifetime( &init ), PSA_KEY_LIFETIME_VOLATILE );
758 TEST_EQUAL( psa_get_key_lifetime( &zero ), PSA_KEY_LIFETIME_VOLATILE );
Jaeden Amero5229bbb2019-02-07 16:33:37 +0000759
Gilles Peskine2c2cf0e2019-04-19 19:58:20 +0200760 TEST_EQUAL( psa_get_key_type( &func ), 0 );
761 TEST_EQUAL( psa_get_key_type( &init ), 0 );
762 TEST_EQUAL( psa_get_key_type( &zero ), 0 );
763
764 TEST_EQUAL( psa_get_key_bits( &func ), 0 );
765 TEST_EQUAL( psa_get_key_bits( &init ), 0 );
766 TEST_EQUAL( psa_get_key_bits( &zero ), 0 );
767
768 TEST_EQUAL( psa_get_key_usage_flags( &func ), 0 );
769 TEST_EQUAL( psa_get_key_usage_flags( &init ), 0 );
770 TEST_EQUAL( psa_get_key_usage_flags( &zero ), 0 );
771
772 TEST_EQUAL( psa_get_key_algorithm( &func ), 0 );
773 TEST_EQUAL( psa_get_key_algorithm( &init ), 0 );
774 TEST_EQUAL( psa_get_key_algorithm( &zero ), 0 );
Jaeden Amero70261c52019-01-04 11:47:20 +0000775}
776/* END_CASE */
777
778/* BEGIN_CASE */
Gilles Peskine76f5c7b2018-07-06 16:53:09 +0200779void mac_key_policy( int policy_usage,
780 int policy_alg,
781 int key_type,
782 data_t *key_data,
Steven Cooremanb3ce8152021-02-18 12:03:50 +0100783 int exercise_alg,
784 int expected_status_arg )
Gilles Peskined5b33222018-06-18 22:20:03 +0200785{
Ronald Cron5425a212020-08-04 14:58:35 +0200786 mbedtls_svc_key_id_t key = MBEDTLS_SVC_KEY_ID_INIT;
Gilles Peskine2c2cf0e2019-04-19 19:58:20 +0200787 psa_key_attributes_t attributes = PSA_KEY_ATTRIBUTES_INIT;
Jaeden Amero769ce272019-01-04 11:48:03 +0000788 psa_mac_operation_t operation = PSA_MAC_OPERATION_INIT;
Gilles Peskine76f5c7b2018-07-06 16:53:09 +0200789 psa_status_t status;
Steven Cooremanb3ce8152021-02-18 12:03:50 +0100790 psa_status_t expected_status = expected_status_arg;
Gilles Peskine76f5c7b2018-07-06 16:53:09 +0200791 unsigned char mac[PSA_MAC_MAX_SIZE];
Gilles Peskined5b33222018-06-18 22:20:03 +0200792
Gilles Peskine8817f612018-12-18 00:18:46 +0100793 PSA_ASSERT( psa_crypto_init( ) );
Gilles Peskined5b33222018-06-18 22:20:03 +0200794
Gilles Peskine2c2cf0e2019-04-19 19:58:20 +0200795 psa_set_key_usage_flags( &attributes, policy_usage );
796 psa_set_key_algorithm( &attributes, policy_alg );
797 psa_set_key_type( &attributes, key_type );
Gilles Peskined5b33222018-06-18 22:20:03 +0200798
Gilles Peskine049c7532019-05-15 20:22:09 +0200799 PSA_ASSERT( psa_import_key( &attributes, key_data->x, key_data->len,
Ronald Cron5425a212020-08-04 14:58:35 +0200800 &key ) );
Gilles Peskined5b33222018-06-18 22:20:03 +0200801
Ronald Cron5425a212020-08-04 14:58:35 +0200802 status = psa_mac_sign_setup( &operation, key, exercise_alg );
Steven Cooremanb3ce8152021-02-18 12:03:50 +0100803 if( ( policy_usage & PSA_KEY_USAGE_SIGN_HASH ) == 0 )
Gilles Peskinefe11b722018-12-18 00:24:04 +0100804 TEST_EQUAL( status, PSA_ERROR_NOT_PERMITTED );
Steven Cooremanb3ce8152021-02-18 12:03:50 +0100805 else
806 TEST_EQUAL( status, expected_status );
807
Gilles Peskine76f5c7b2018-07-06 16:53:09 +0200808 psa_mac_abort( &operation );
Gilles Peskined5b33222018-06-18 22:20:03 +0200809
Gilles Peskine76f5c7b2018-07-06 16:53:09 +0200810 memset( mac, 0, sizeof( mac ) );
Ronald Cron5425a212020-08-04 14:58:35 +0200811 status = psa_mac_verify_setup( &operation, key, exercise_alg );
Steven Cooremanb3ce8152021-02-18 12:03:50 +0100812 if( ( policy_usage & PSA_KEY_USAGE_VERIFY_HASH ) == 0 )
Gilles Peskinefe11b722018-12-18 00:24:04 +0100813 TEST_EQUAL( status, PSA_ERROR_NOT_PERMITTED );
Steven Cooremanb3ce8152021-02-18 12:03:50 +0100814 else
815 TEST_EQUAL( status, expected_status );
Gilles Peskine76f5c7b2018-07-06 16:53:09 +0200816
817exit:
818 psa_mac_abort( &operation );
Ronald Cron5425a212020-08-04 14:58:35 +0200819 psa_destroy_key( key );
Gilles Peskine1153e7b2019-05-28 15:10:21 +0200820 PSA_DONE( );
Gilles Peskine76f5c7b2018-07-06 16:53:09 +0200821}
822/* END_CASE */
823
824/* BEGIN_CASE */
825void cipher_key_policy( int policy_usage,
826 int policy_alg,
827 int key_type,
828 data_t *key_data,
829 int exercise_alg )
830{
Ronald Cron5425a212020-08-04 14:58:35 +0200831 mbedtls_svc_key_id_t key = MBEDTLS_SVC_KEY_ID_INIT;
Gilles Peskine2c2cf0e2019-04-19 19:58:20 +0200832 psa_key_attributes_t attributes = PSA_KEY_ATTRIBUTES_INIT;
Jaeden Amero5bae2272019-01-04 11:48:27 +0000833 psa_cipher_operation_t operation = PSA_CIPHER_OPERATION_INIT;
Gilles Peskine76f5c7b2018-07-06 16:53:09 +0200834 psa_status_t status;
835
Gilles Peskine8817f612018-12-18 00:18:46 +0100836 PSA_ASSERT( psa_crypto_init( ) );
Gilles Peskine76f5c7b2018-07-06 16:53:09 +0200837
Gilles Peskine2c2cf0e2019-04-19 19:58:20 +0200838 psa_set_key_usage_flags( &attributes, policy_usage );
839 psa_set_key_algorithm( &attributes, policy_alg );
840 psa_set_key_type( &attributes, key_type );
Gilles Peskine76f5c7b2018-07-06 16:53:09 +0200841
Gilles Peskine049c7532019-05-15 20:22:09 +0200842 PSA_ASSERT( psa_import_key( &attributes, key_data->x, key_data->len,
Ronald Cron5425a212020-08-04 14:58:35 +0200843 &key ) );
Gilles Peskine76f5c7b2018-07-06 16:53:09 +0200844
Ronald Cron5425a212020-08-04 14:58:35 +0200845 status = psa_cipher_encrypt_setup( &operation, key, exercise_alg );
Gilles Peskine76f5c7b2018-07-06 16:53:09 +0200846 if( policy_alg == exercise_alg &&
847 ( policy_usage & PSA_KEY_USAGE_ENCRYPT ) != 0 )
Gilles Peskine8817f612018-12-18 00:18:46 +0100848 PSA_ASSERT( status );
Gilles Peskine76f5c7b2018-07-06 16:53:09 +0200849 else
Gilles Peskinefe11b722018-12-18 00:24:04 +0100850 TEST_EQUAL( status, PSA_ERROR_NOT_PERMITTED );
Gilles Peskine76f5c7b2018-07-06 16:53:09 +0200851 psa_cipher_abort( &operation );
852
Ronald Cron5425a212020-08-04 14:58:35 +0200853 status = psa_cipher_decrypt_setup( &operation, key, exercise_alg );
Gilles Peskine76f5c7b2018-07-06 16:53:09 +0200854 if( policy_alg == exercise_alg &&
855 ( policy_usage & PSA_KEY_USAGE_DECRYPT ) != 0 )
Gilles Peskine8817f612018-12-18 00:18:46 +0100856 PSA_ASSERT( status );
Gilles Peskine76f5c7b2018-07-06 16:53:09 +0200857 else
Gilles Peskinefe11b722018-12-18 00:24:04 +0100858 TEST_EQUAL( status, PSA_ERROR_NOT_PERMITTED );
Gilles Peskine76f5c7b2018-07-06 16:53:09 +0200859
860exit:
861 psa_cipher_abort( &operation );
Ronald Cron5425a212020-08-04 14:58:35 +0200862 psa_destroy_key( key );
Gilles Peskine1153e7b2019-05-28 15:10:21 +0200863 PSA_DONE( );
Gilles Peskine76f5c7b2018-07-06 16:53:09 +0200864}
865/* END_CASE */
866
867/* BEGIN_CASE */
868void aead_key_policy( int policy_usage,
869 int policy_alg,
870 int key_type,
871 data_t *key_data,
872 int nonce_length_arg,
873 int tag_length_arg,
Steven Cooremanb3ce8152021-02-18 12:03:50 +0100874 int exercise_alg,
875 int expected_status_arg )
Gilles Peskine76f5c7b2018-07-06 16:53:09 +0200876{
Ronald Cron5425a212020-08-04 14:58:35 +0200877 mbedtls_svc_key_id_t key = MBEDTLS_SVC_KEY_ID_INIT;
Gilles Peskine2c2cf0e2019-04-19 19:58:20 +0200878 psa_key_attributes_t attributes = PSA_KEY_ATTRIBUTES_INIT;
Gilles Peskine76f5c7b2018-07-06 16:53:09 +0200879 psa_status_t status;
Steven Cooremanb3ce8152021-02-18 12:03:50 +0100880 psa_status_t expected_status = expected_status_arg;
Gilles Peskine76f5c7b2018-07-06 16:53:09 +0200881 unsigned char nonce[16] = {0};
882 size_t nonce_length = nonce_length_arg;
883 unsigned char tag[16];
884 size_t tag_length = tag_length_arg;
885 size_t output_length;
886
887 TEST_ASSERT( nonce_length <= sizeof( nonce ) );
888 TEST_ASSERT( tag_length <= sizeof( tag ) );
889
Gilles Peskine8817f612018-12-18 00:18:46 +0100890 PSA_ASSERT( psa_crypto_init( ) );
Gilles Peskine76f5c7b2018-07-06 16:53:09 +0200891
Gilles Peskine2c2cf0e2019-04-19 19:58:20 +0200892 psa_set_key_usage_flags( &attributes, policy_usage );
893 psa_set_key_algorithm( &attributes, policy_alg );
894 psa_set_key_type( &attributes, key_type );
Gilles Peskine76f5c7b2018-07-06 16:53:09 +0200895
Gilles Peskine049c7532019-05-15 20:22:09 +0200896 PSA_ASSERT( psa_import_key( &attributes, key_data->x, key_data->len,
Ronald Cron5425a212020-08-04 14:58:35 +0200897 &key ) );
Gilles Peskine76f5c7b2018-07-06 16:53:09 +0200898
Ronald Cron5425a212020-08-04 14:58:35 +0200899 status = psa_aead_encrypt( key, exercise_alg,
Gilles Peskine76f5c7b2018-07-06 16:53:09 +0200900 nonce, nonce_length,
901 NULL, 0,
902 NULL, 0,
903 tag, tag_length,
904 &output_length );
Steven Cooremanb3ce8152021-02-18 12:03:50 +0100905 if( ( policy_usage & PSA_KEY_USAGE_ENCRYPT ) != 0 )
906 TEST_EQUAL( status, expected_status );
Gilles Peskine76f5c7b2018-07-06 16:53:09 +0200907 else
Gilles Peskinefe11b722018-12-18 00:24:04 +0100908 TEST_EQUAL( status, PSA_ERROR_NOT_PERMITTED );
Gilles Peskine76f5c7b2018-07-06 16:53:09 +0200909
910 memset( tag, 0, sizeof( tag ) );
Ronald Cron5425a212020-08-04 14:58:35 +0200911 status = psa_aead_decrypt( key, exercise_alg,
Gilles Peskine76f5c7b2018-07-06 16:53:09 +0200912 nonce, nonce_length,
913 NULL, 0,
914 tag, tag_length,
915 NULL, 0,
916 &output_length );
Steven Cooremanb3ce8152021-02-18 12:03:50 +0100917 if( ( policy_usage & PSA_KEY_USAGE_DECRYPT ) == 0 )
918 TEST_EQUAL( status, PSA_ERROR_NOT_PERMITTED );
919 else if( expected_status == PSA_SUCCESS )
Gilles Peskinefe11b722018-12-18 00:24:04 +0100920 TEST_EQUAL( status, PSA_ERROR_INVALID_SIGNATURE );
Gilles Peskine76f5c7b2018-07-06 16:53:09 +0200921 else
Steven Cooremanb3ce8152021-02-18 12:03:50 +0100922 TEST_EQUAL( status, expected_status );
Gilles Peskine76f5c7b2018-07-06 16:53:09 +0200923
924exit:
Ronald Cron5425a212020-08-04 14:58:35 +0200925 psa_destroy_key( key );
Gilles Peskine1153e7b2019-05-28 15:10:21 +0200926 PSA_DONE( );
Gilles Peskine76f5c7b2018-07-06 16:53:09 +0200927}
928/* END_CASE */
929
930/* BEGIN_CASE */
931void asymmetric_encryption_key_policy( int policy_usage,
932 int policy_alg,
933 int key_type,
934 data_t *key_data,
935 int exercise_alg )
936{
Ronald Cron5425a212020-08-04 14:58:35 +0200937 mbedtls_svc_key_id_t key = MBEDTLS_SVC_KEY_ID_INIT;
Gilles Peskine2c2cf0e2019-04-19 19:58:20 +0200938 psa_key_attributes_t attributes = PSA_KEY_ATTRIBUTES_INIT;
Gilles Peskine76f5c7b2018-07-06 16:53:09 +0200939 psa_status_t status;
940 size_t key_bits;
941 size_t buffer_length;
942 unsigned char *buffer = NULL;
943 size_t output_length;
944
Gilles Peskine8817f612018-12-18 00:18:46 +0100945 PSA_ASSERT( psa_crypto_init( ) );
Gilles Peskine76f5c7b2018-07-06 16:53:09 +0200946
Gilles Peskine2c2cf0e2019-04-19 19:58:20 +0200947 psa_set_key_usage_flags( &attributes, policy_usage );
948 psa_set_key_algorithm( &attributes, policy_alg );
949 psa_set_key_type( &attributes, key_type );
Gilles Peskine76f5c7b2018-07-06 16:53:09 +0200950
Gilles Peskine049c7532019-05-15 20:22:09 +0200951 PSA_ASSERT( psa_import_key( &attributes, key_data->x, key_data->len,
Ronald Cron5425a212020-08-04 14:58:35 +0200952 &key ) );
Gilles Peskine76f5c7b2018-07-06 16:53:09 +0200953
Ronald Cron5425a212020-08-04 14:58:35 +0200954 PSA_ASSERT( psa_get_key_attributes( key, &attributes ) );
Gilles Peskine8c8f2ab2019-04-18 21:44:46 +0200955 key_bits = psa_get_key_bits( &attributes );
Gilles Peskine76f5c7b2018-07-06 16:53:09 +0200956 buffer_length = PSA_ASYMMETRIC_ENCRYPT_OUTPUT_SIZE( key_type, key_bits,
957 exercise_alg );
Gilles Peskine8cebbba2018-09-27 13:54:18 +0200958 ASSERT_ALLOC( buffer, buffer_length );
Gilles Peskine76f5c7b2018-07-06 16:53:09 +0200959
Ronald Cron5425a212020-08-04 14:58:35 +0200960 status = psa_asymmetric_encrypt( key, exercise_alg,
Gilles Peskine76f5c7b2018-07-06 16:53:09 +0200961 NULL, 0,
962 NULL, 0,
963 buffer, buffer_length,
964 &output_length );
965 if( policy_alg == exercise_alg &&
966 ( policy_usage & PSA_KEY_USAGE_ENCRYPT ) != 0 )
Gilles Peskine8817f612018-12-18 00:18:46 +0100967 PSA_ASSERT( status );
Gilles Peskine76f5c7b2018-07-06 16:53:09 +0200968 else
Gilles Peskinefe11b722018-12-18 00:24:04 +0100969 TEST_EQUAL( status, PSA_ERROR_NOT_PERMITTED );
Gilles Peskine76f5c7b2018-07-06 16:53:09 +0200970
Gilles Peskinef7ab5ad2018-09-26 18:19:24 +0200971 if( buffer_length != 0 )
972 memset( buffer, 0, buffer_length );
Ronald Cron5425a212020-08-04 14:58:35 +0200973 status = psa_asymmetric_decrypt( key, exercise_alg,
Gilles Peskine76f5c7b2018-07-06 16:53:09 +0200974 buffer, buffer_length,
975 NULL, 0,
976 buffer, buffer_length,
977 &output_length );
978 if( policy_alg == exercise_alg &&
979 ( policy_usage & PSA_KEY_USAGE_DECRYPT ) != 0 )
Gilles Peskinefe11b722018-12-18 00:24:04 +0100980 TEST_EQUAL( status, PSA_ERROR_INVALID_PADDING );
Gilles Peskine76f5c7b2018-07-06 16:53:09 +0200981 else
Gilles Peskinefe11b722018-12-18 00:24:04 +0100982 TEST_EQUAL( status, PSA_ERROR_NOT_PERMITTED );
Gilles Peskine76f5c7b2018-07-06 16:53:09 +0200983
984exit:
Ronald Cron3a4f0e32020-11-19 17:55:23 +0100985 /*
986 * Key attributes may have been returned by psa_get_key_attributes()
987 * thus reset them as required.
988 */
Gilles Peskinea1ace9c2019-04-26 16:03:33 +0200989 psa_reset_key_attributes( &attributes );
Ronald Cron3a4f0e32020-11-19 17:55:23 +0100990
991 psa_destroy_key( key );
Gilles Peskine1153e7b2019-05-28 15:10:21 +0200992 PSA_DONE( );
Gilles Peskine76f5c7b2018-07-06 16:53:09 +0200993 mbedtls_free( buffer );
994}
995/* END_CASE */
996
997/* BEGIN_CASE */
998void asymmetric_signature_key_policy( int policy_usage,
999 int policy_alg,
1000 int key_type,
1001 data_t *key_data,
Gilles Peskine30f77cd2019-01-14 16:06:39 +01001002 int exercise_alg,
1003 int payload_length_arg )
Gilles Peskine76f5c7b2018-07-06 16:53:09 +02001004{
Ronald Cron5425a212020-08-04 14:58:35 +02001005 mbedtls_svc_key_id_t key = MBEDTLS_SVC_KEY_ID_INIT;
Gilles Peskine2c2cf0e2019-04-19 19:58:20 +02001006 psa_key_attributes_t attributes = PSA_KEY_ATTRIBUTES_INIT;
Gilles Peskine76f5c7b2018-07-06 16:53:09 +02001007 psa_status_t status;
Gilles Peskine30f77cd2019-01-14 16:06:39 +01001008 unsigned char payload[PSA_HASH_MAX_SIZE] = {1};
1009 /* If `payload_length_arg > 0`, `exercise_alg` is supposed to be
1010 * compatible with the policy and `payload_length_arg` is supposed to be
1011 * a valid input length to sign. If `payload_length_arg <= 0`,
1012 * `exercise_alg` is supposed to be forbidden by the policy. */
1013 int compatible_alg = payload_length_arg > 0;
1014 size_t payload_length = compatible_alg ? payload_length_arg : 0;
Gilles Peskine89d8c5c2019-11-26 17:01:59 +01001015 unsigned char signature[PSA_SIGNATURE_MAX_SIZE] = {0};
Gilles Peskine76f5c7b2018-07-06 16:53:09 +02001016 size_t signature_length;
1017
Gilles Peskine8817f612018-12-18 00:18:46 +01001018 PSA_ASSERT( psa_crypto_init( ) );
Gilles Peskine76f5c7b2018-07-06 16:53:09 +02001019
Gilles Peskine2c2cf0e2019-04-19 19:58:20 +02001020 psa_set_key_usage_flags( &attributes, policy_usage );
1021 psa_set_key_algorithm( &attributes, policy_alg );
1022 psa_set_key_type( &attributes, key_type );
Gilles Peskine76f5c7b2018-07-06 16:53:09 +02001023
Gilles Peskine049c7532019-05-15 20:22:09 +02001024 PSA_ASSERT( psa_import_key( &attributes, key_data->x, key_data->len,
Ronald Cron5425a212020-08-04 14:58:35 +02001025 &key ) );
Gilles Peskine76f5c7b2018-07-06 16:53:09 +02001026
Ronald Cron5425a212020-08-04 14:58:35 +02001027 status = psa_sign_hash( key, exercise_alg,
Gilles Peskine89d8c5c2019-11-26 17:01:59 +01001028 payload, payload_length,
1029 signature, sizeof( signature ),
1030 &signature_length );
1031 if( compatible_alg && ( policy_usage & PSA_KEY_USAGE_SIGN_HASH ) != 0 )
Gilles Peskine8817f612018-12-18 00:18:46 +01001032 PSA_ASSERT( status );
Gilles Peskine76f5c7b2018-07-06 16:53:09 +02001033 else
Gilles Peskinefe11b722018-12-18 00:24:04 +01001034 TEST_EQUAL( status, PSA_ERROR_NOT_PERMITTED );
Gilles Peskine76f5c7b2018-07-06 16:53:09 +02001035
1036 memset( signature, 0, sizeof( signature ) );
Ronald Cron5425a212020-08-04 14:58:35 +02001037 status = psa_verify_hash( key, exercise_alg,
Gilles Peskine89d8c5c2019-11-26 17:01:59 +01001038 payload, payload_length,
1039 signature, sizeof( signature ) );
1040 if( compatible_alg && ( policy_usage & PSA_KEY_USAGE_VERIFY_HASH ) != 0 )
Gilles Peskinefe11b722018-12-18 00:24:04 +01001041 TEST_EQUAL( status, PSA_ERROR_INVALID_SIGNATURE );
Gilles Peskine76f5c7b2018-07-06 16:53:09 +02001042 else
Gilles Peskinefe11b722018-12-18 00:24:04 +01001043 TEST_EQUAL( status, PSA_ERROR_NOT_PERMITTED );
Gilles Peskined5b33222018-06-18 22:20:03 +02001044
1045exit:
Ronald Cron5425a212020-08-04 14:58:35 +02001046 psa_destroy_key( key );
Gilles Peskine1153e7b2019-05-28 15:10:21 +02001047 PSA_DONE( );
Gilles Peskined5b33222018-06-18 22:20:03 +02001048}
1049/* END_CASE */
1050
Janos Follathba3fab92019-06-11 14:50:16 +01001051/* BEGIN_CASE */
Gilles Peskineea0fb492018-07-12 17:17:20 +02001052void derive_key_policy( int policy_usage,
1053 int policy_alg,
1054 int key_type,
1055 data_t *key_data,
1056 int exercise_alg )
1057{
Ronald Cron5425a212020-08-04 14:58:35 +02001058 mbedtls_svc_key_id_t key = MBEDTLS_SVC_KEY_ID_INIT;
Gilles Peskine2c2cf0e2019-04-19 19:58:20 +02001059 psa_key_attributes_t attributes = PSA_KEY_ATTRIBUTES_INIT;
Gilles Peskine51ae0e42019-05-16 17:31:03 +02001060 psa_key_derivation_operation_t operation = PSA_KEY_DERIVATION_OPERATION_INIT;
Gilles Peskineea0fb492018-07-12 17:17:20 +02001061 psa_status_t status;
1062
Gilles Peskine8817f612018-12-18 00:18:46 +01001063 PSA_ASSERT( psa_crypto_init( ) );
Gilles Peskineea0fb492018-07-12 17:17:20 +02001064
Gilles Peskine2c2cf0e2019-04-19 19:58:20 +02001065 psa_set_key_usage_flags( &attributes, policy_usage );
1066 psa_set_key_algorithm( &attributes, policy_alg );
1067 psa_set_key_type( &attributes, key_type );
Gilles Peskineea0fb492018-07-12 17:17:20 +02001068
Gilles Peskine049c7532019-05-15 20:22:09 +02001069 PSA_ASSERT( psa_import_key( &attributes, key_data->x, key_data->len,
Ronald Cron5425a212020-08-04 14:58:35 +02001070 &key ) );
Gilles Peskineea0fb492018-07-12 17:17:20 +02001071
Janos Follathba3fab92019-06-11 14:50:16 +01001072 PSA_ASSERT( psa_key_derivation_setup( &operation, exercise_alg ) );
1073
1074 if( PSA_ALG_IS_TLS12_PRF( exercise_alg ) ||
1075 PSA_ALG_IS_TLS12_PSK_TO_MS( exercise_alg ) )
Janos Follath0c1ed842019-06-28 13:35:36 +01001076 {
Janos Follathba3fab92019-06-11 14:50:16 +01001077 PSA_ASSERT( psa_key_derivation_input_bytes(
1078 &operation,
1079 PSA_KEY_DERIVATION_INPUT_SEED,
1080 (const uint8_t*) "", 0) );
Janos Follath0c1ed842019-06-28 13:35:36 +01001081 }
Janos Follathba3fab92019-06-11 14:50:16 +01001082
1083 status = psa_key_derivation_input_key( &operation,
1084 PSA_KEY_DERIVATION_INPUT_SECRET,
Ronald Cron5425a212020-08-04 14:58:35 +02001085 key );
Janos Follathba3fab92019-06-11 14:50:16 +01001086
Gilles Peskineea0fb492018-07-12 17:17:20 +02001087 if( policy_alg == exercise_alg &&
1088 ( policy_usage & PSA_KEY_USAGE_DERIVE ) != 0 )
Gilles Peskine8817f612018-12-18 00:18:46 +01001089 PSA_ASSERT( status );
Gilles Peskineea0fb492018-07-12 17:17:20 +02001090 else
Gilles Peskinefe11b722018-12-18 00:24:04 +01001091 TEST_EQUAL( status, PSA_ERROR_NOT_PERMITTED );
Gilles Peskineea0fb492018-07-12 17:17:20 +02001092
1093exit:
Gilles Peskine51ae0e42019-05-16 17:31:03 +02001094 psa_key_derivation_abort( &operation );
Ronald Cron5425a212020-08-04 14:58:35 +02001095 psa_destroy_key( key );
Gilles Peskine1153e7b2019-05-28 15:10:21 +02001096 PSA_DONE( );
Gilles Peskineea0fb492018-07-12 17:17:20 +02001097}
1098/* END_CASE */
1099
1100/* BEGIN_CASE */
Gilles Peskine01d718c2018-09-18 12:01:02 +02001101void agreement_key_policy( int policy_usage,
1102 int policy_alg,
1103 int key_type_arg,
1104 data_t *key_data,
Steven Cooremance48e852020-10-05 16:02:45 +02001105 int exercise_alg,
1106 int expected_status_arg )
Gilles Peskine01d718c2018-09-18 12:01:02 +02001107{
Ronald Cron5425a212020-08-04 14:58:35 +02001108 mbedtls_svc_key_id_t key = MBEDTLS_SVC_KEY_ID_INIT;
Gilles Peskine2c2cf0e2019-04-19 19:58:20 +02001109 psa_key_attributes_t attributes = PSA_KEY_ATTRIBUTES_INIT;
Gilles Peskine01d718c2018-09-18 12:01:02 +02001110 psa_key_type_t key_type = key_type_arg;
Gilles Peskine51ae0e42019-05-16 17:31:03 +02001111 psa_key_derivation_operation_t operation = PSA_KEY_DERIVATION_OPERATION_INIT;
Gilles Peskine01d718c2018-09-18 12:01:02 +02001112 psa_status_t status;
Steven Cooremance48e852020-10-05 16:02:45 +02001113 psa_status_t expected_status = expected_status_arg;
Gilles Peskine01d718c2018-09-18 12:01:02 +02001114
Gilles Peskine8817f612018-12-18 00:18:46 +01001115 PSA_ASSERT( psa_crypto_init( ) );
Gilles Peskine01d718c2018-09-18 12:01:02 +02001116
Gilles Peskine2c2cf0e2019-04-19 19:58:20 +02001117 psa_set_key_usage_flags( &attributes, policy_usage );
1118 psa_set_key_algorithm( &attributes, policy_alg );
1119 psa_set_key_type( &attributes, key_type );
Gilles Peskine01d718c2018-09-18 12:01:02 +02001120
Gilles Peskine049c7532019-05-15 20:22:09 +02001121 PSA_ASSERT( psa_import_key( &attributes, key_data->x, key_data->len,
Ronald Cron5425a212020-08-04 14:58:35 +02001122 &key ) );
Gilles Peskine01d718c2018-09-18 12:01:02 +02001123
Gilles Peskine51ae0e42019-05-16 17:31:03 +02001124 PSA_ASSERT( psa_key_derivation_setup( &operation, exercise_alg ) );
Gilles Peskinec18e25f2021-02-12 23:48:20 +01001125 status = mbedtls_test_psa_key_agreement_with_self( &operation, key );
Gilles Peskine01d718c2018-09-18 12:01:02 +02001126
Steven Cooremance48e852020-10-05 16:02:45 +02001127 TEST_EQUAL( status, expected_status );
Gilles Peskine01d718c2018-09-18 12:01:02 +02001128
1129exit:
Gilles Peskine51ae0e42019-05-16 17:31:03 +02001130 psa_key_derivation_abort( &operation );
Ronald Cron5425a212020-08-04 14:58:35 +02001131 psa_destroy_key( key );
Gilles Peskine1153e7b2019-05-28 15:10:21 +02001132 PSA_DONE( );
Gilles Peskine01d718c2018-09-18 12:01:02 +02001133}
1134/* END_CASE */
1135
1136/* BEGIN_CASE */
Gilles Peskine96f0b3b2019-05-10 19:33:38 +02001137void key_policy_alg2( int key_type_arg, data_t *key_data,
1138 int usage_arg, int alg_arg, int alg2_arg )
1139{
Ronald Cron5425a212020-08-04 14:58:35 +02001140 mbedtls_svc_key_id_t key = MBEDTLS_SVC_KEY_ID_INIT;
Gilles Peskine96f0b3b2019-05-10 19:33:38 +02001141 psa_key_type_t key_type = key_type_arg;
1142 psa_key_attributes_t attributes = PSA_KEY_ATTRIBUTES_INIT;
1143 psa_key_attributes_t got_attributes = PSA_KEY_ATTRIBUTES_INIT;
1144 psa_key_usage_t usage = usage_arg;
1145 psa_algorithm_t alg = alg_arg;
1146 psa_algorithm_t alg2 = alg2_arg;
1147
1148 PSA_ASSERT( psa_crypto_init( ) );
1149
1150 psa_set_key_usage_flags( &attributes, usage );
1151 psa_set_key_algorithm( &attributes, alg );
1152 psa_set_key_enrollment_algorithm( &attributes, alg2 );
1153 psa_set_key_type( &attributes, key_type );
1154 PSA_ASSERT( psa_import_key( &attributes, key_data->x, key_data->len,
Ronald Cron5425a212020-08-04 14:58:35 +02001155 &key ) );
Gilles Peskine96f0b3b2019-05-10 19:33:38 +02001156
Ronald Cron5425a212020-08-04 14:58:35 +02001157 PSA_ASSERT( psa_get_key_attributes( key, &got_attributes ) );
Gilles Peskine96f0b3b2019-05-10 19:33:38 +02001158 TEST_EQUAL( psa_get_key_usage_flags( &got_attributes ), usage );
1159 TEST_EQUAL( psa_get_key_algorithm( &got_attributes ), alg );
1160 TEST_EQUAL( psa_get_key_enrollment_algorithm( &got_attributes ), alg2 );
1161
Gilles Peskinec18e25f2021-02-12 23:48:20 +01001162 if( ! mbedtls_test_psa_exercise_key( key, usage, alg ) )
Gilles Peskine96f0b3b2019-05-10 19:33:38 +02001163 goto exit;
Gilles Peskinec18e25f2021-02-12 23:48:20 +01001164 if( ! mbedtls_test_psa_exercise_key( key, usage, alg2 ) )
Gilles Peskine96f0b3b2019-05-10 19:33:38 +02001165 goto exit;
1166
1167exit:
Ronald Cron3a4f0e32020-11-19 17:55:23 +01001168 /*
1169 * Key attributes may have been returned by psa_get_key_attributes()
1170 * thus reset them as required.
1171 */
1172 psa_reset_key_attributes( &got_attributes );
1173
Ronald Cron5425a212020-08-04 14:58:35 +02001174 psa_destroy_key( key );
Gilles Peskine1153e7b2019-05-28 15:10:21 +02001175 PSA_DONE( );
Gilles Peskine96f0b3b2019-05-10 19:33:38 +02001176}
1177/* END_CASE */
1178
1179/* BEGIN_CASE */
Gilles Peskine04ee2d22019-04-11 21:25:46 +02001180void raw_agreement_key_policy( int policy_usage,
1181 int policy_alg,
1182 int key_type_arg,
1183 data_t *key_data,
Steven Cooremance48e852020-10-05 16:02:45 +02001184 int exercise_alg,
1185 int expected_status_arg )
Gilles Peskine04ee2d22019-04-11 21:25:46 +02001186{
Ronald Cron5425a212020-08-04 14:58:35 +02001187 mbedtls_svc_key_id_t key = MBEDTLS_SVC_KEY_ID_INIT;
Gilles Peskine2c2cf0e2019-04-19 19:58:20 +02001188 psa_key_attributes_t attributes = PSA_KEY_ATTRIBUTES_INIT;
Gilles Peskine04ee2d22019-04-11 21:25:46 +02001189 psa_key_type_t key_type = key_type_arg;
Gilles Peskine51ae0e42019-05-16 17:31:03 +02001190 psa_key_derivation_operation_t operation = PSA_KEY_DERIVATION_OPERATION_INIT;
Gilles Peskine04ee2d22019-04-11 21:25:46 +02001191 psa_status_t status;
Steven Cooremance48e852020-10-05 16:02:45 +02001192 psa_status_t expected_status = expected_status_arg;
Gilles Peskine04ee2d22019-04-11 21:25:46 +02001193
1194 PSA_ASSERT( psa_crypto_init( ) );
1195
Gilles Peskine2c2cf0e2019-04-19 19:58:20 +02001196 psa_set_key_usage_flags( &attributes, policy_usage );
1197 psa_set_key_algorithm( &attributes, policy_alg );
1198 psa_set_key_type( &attributes, key_type );
Gilles Peskine04ee2d22019-04-11 21:25:46 +02001199
Gilles Peskine049c7532019-05-15 20:22:09 +02001200 PSA_ASSERT( psa_import_key( &attributes, key_data->x, key_data->len,
Ronald Cron5425a212020-08-04 14:58:35 +02001201 &key ) );
Gilles Peskine04ee2d22019-04-11 21:25:46 +02001202
Gilles Peskinec18e25f2021-02-12 23:48:20 +01001203 status = mbedtls_test_psa_raw_key_agreement_with_self( exercise_alg, key );
Gilles Peskine04ee2d22019-04-11 21:25:46 +02001204
Steven Cooremance48e852020-10-05 16:02:45 +02001205 TEST_EQUAL( status, expected_status );
Gilles Peskine04ee2d22019-04-11 21:25:46 +02001206
1207exit:
Gilles Peskine51ae0e42019-05-16 17:31:03 +02001208 psa_key_derivation_abort( &operation );
Ronald Cron5425a212020-08-04 14:58:35 +02001209 psa_destroy_key( key );
Gilles Peskine1153e7b2019-05-28 15:10:21 +02001210 PSA_DONE( );
Gilles Peskine04ee2d22019-04-11 21:25:46 +02001211}
1212/* END_CASE */
1213
1214/* BEGIN_CASE */
Gilles Peskinebcdd44b2019-05-20 17:28:11 +02001215void copy_success( int source_usage_arg,
1216 int source_alg_arg, int source_alg2_arg,
Gilles Peskine4a644642019-05-03 17:14:08 +02001217 int type_arg, data_t *material,
1218 int copy_attributes,
Gilles Peskinebcdd44b2019-05-20 17:28:11 +02001219 int target_usage_arg,
1220 int target_alg_arg, int target_alg2_arg,
1221 int expected_usage_arg,
1222 int expected_alg_arg, int expected_alg2_arg )
Gilles Peskine57ab7212019-01-28 13:03:09 +01001223{
Gilles Peskineca25db92019-04-19 11:43:08 +02001224 psa_key_attributes_t source_attributes = PSA_KEY_ATTRIBUTES_INIT;
1225 psa_key_attributes_t target_attributes = PSA_KEY_ATTRIBUTES_INIT;
Gilles Peskine57ab7212019-01-28 13:03:09 +01001226 psa_key_usage_t expected_usage = expected_usage_arg;
1227 psa_algorithm_t expected_alg = expected_alg_arg;
Gilles Peskinebcdd44b2019-05-20 17:28:11 +02001228 psa_algorithm_t expected_alg2 = expected_alg2_arg;
Ronald Cron5425a212020-08-04 14:58:35 +02001229 mbedtls_svc_key_id_t source_key = MBEDTLS_SVC_KEY_ID_INIT;
1230 mbedtls_svc_key_id_t target_key = MBEDTLS_SVC_KEY_ID_INIT;
Gilles Peskine57ab7212019-01-28 13:03:09 +01001231 uint8_t *export_buffer = NULL;
1232
Gilles Peskine57ab7212019-01-28 13:03:09 +01001233 PSA_ASSERT( psa_crypto_init( ) );
1234
Gilles Peskineca25db92019-04-19 11:43:08 +02001235 /* Prepare the source key. */
1236 psa_set_key_usage_flags( &source_attributes, source_usage_arg );
1237 psa_set_key_algorithm( &source_attributes, source_alg_arg );
Gilles Peskinebcdd44b2019-05-20 17:28:11 +02001238 psa_set_key_enrollment_algorithm( &source_attributes, source_alg2_arg );
Gilles Peskineca25db92019-04-19 11:43:08 +02001239 psa_set_key_type( &source_attributes, type_arg );
Gilles Peskine049c7532019-05-15 20:22:09 +02001240 PSA_ASSERT( psa_import_key( &source_attributes,
1241 material->x, material->len,
Ronald Cron5425a212020-08-04 14:58:35 +02001242 &source_key ) );
1243 PSA_ASSERT( psa_get_key_attributes( source_key, &source_attributes ) );
Gilles Peskine57ab7212019-01-28 13:03:09 +01001244
Gilles Peskineca25db92019-04-19 11:43:08 +02001245 /* Prepare the target attributes. */
1246 if( copy_attributes )
Ronald Cron65f38a32020-10-23 17:11:13 +02001247 {
Gilles Peskineca25db92019-04-19 11:43:08 +02001248 target_attributes = source_attributes;
Ronald Cron65f38a32020-10-23 17:11:13 +02001249 /* Set volatile lifetime to reset the key identifier to 0. */
1250 psa_set_key_lifetime( &target_attributes, PSA_KEY_LIFETIME_VOLATILE );
1251 }
1252
Gilles Peskineca25db92019-04-19 11:43:08 +02001253 if( target_usage_arg != -1 )
1254 psa_set_key_usage_flags( &target_attributes, target_usage_arg );
1255 if( target_alg_arg != -1 )
1256 psa_set_key_algorithm( &target_attributes, target_alg_arg );
Gilles Peskinebcdd44b2019-05-20 17:28:11 +02001257 if( target_alg2_arg != -1 )
1258 psa_set_key_enrollment_algorithm( &target_attributes, target_alg2_arg );
Gilles Peskine57ab7212019-01-28 13:03:09 +01001259
1260 /* Copy the key. */
Ronald Cron5425a212020-08-04 14:58:35 +02001261 PSA_ASSERT( psa_copy_key( source_key,
1262 &target_attributes, &target_key ) );
Gilles Peskine57ab7212019-01-28 13:03:09 +01001263
1264 /* Destroy the source to ensure that this doesn't affect the target. */
Ronald Cron5425a212020-08-04 14:58:35 +02001265 PSA_ASSERT( psa_destroy_key( source_key ) );
Gilles Peskine57ab7212019-01-28 13:03:09 +01001266
1267 /* Test that the target slot has the expected content and policy. */
Ronald Cron5425a212020-08-04 14:58:35 +02001268 PSA_ASSERT( psa_get_key_attributes( target_key, &target_attributes ) );
Gilles Peskineca25db92019-04-19 11:43:08 +02001269 TEST_EQUAL( psa_get_key_type( &source_attributes ),
1270 psa_get_key_type( &target_attributes ) );
1271 TEST_EQUAL( psa_get_key_bits( &source_attributes ),
1272 psa_get_key_bits( &target_attributes ) );
1273 TEST_EQUAL( expected_usage, psa_get_key_usage_flags( &target_attributes ) );
1274 TEST_EQUAL( expected_alg, psa_get_key_algorithm( &target_attributes ) );
Gilles Peskinebcdd44b2019-05-20 17:28:11 +02001275 TEST_EQUAL( expected_alg2,
1276 psa_get_key_enrollment_algorithm( &target_attributes ) );
Gilles Peskine57ab7212019-01-28 13:03:09 +01001277 if( expected_usage & PSA_KEY_USAGE_EXPORT )
1278 {
1279 size_t length;
1280 ASSERT_ALLOC( export_buffer, material->len );
Ronald Cron5425a212020-08-04 14:58:35 +02001281 PSA_ASSERT( psa_export_key( target_key, export_buffer,
Gilles Peskine57ab7212019-01-28 13:03:09 +01001282 material->len, &length ) );
1283 ASSERT_COMPARE( material->x, material->len,
1284 export_buffer, length );
1285 }
Steven Cooremanb3ce8152021-02-18 12:03:50 +01001286
Gilles Peskinec18e25f2021-02-12 23:48:20 +01001287 if( ! mbedtls_test_psa_exercise_key( target_key, expected_usage, expected_alg ) )
Gilles Peskine57ab7212019-01-28 13:03:09 +01001288 goto exit;
Gilles Peskinec18e25f2021-02-12 23:48:20 +01001289 if( ! mbedtls_test_psa_exercise_key( target_key, expected_usage, expected_alg2 ) )
Gilles Peskinebcdd44b2019-05-20 17:28:11 +02001290 goto exit;
Gilles Peskine57ab7212019-01-28 13:03:09 +01001291
Ronald Cron5425a212020-08-04 14:58:35 +02001292 PSA_ASSERT( psa_destroy_key( target_key ) );
Gilles Peskine57ab7212019-01-28 13:03:09 +01001293
1294exit:
Ronald Cron3a4f0e32020-11-19 17:55:23 +01001295 /*
1296 * Source and target key attributes may have been returned by
1297 * psa_get_key_attributes() thus reset them as required.
1298 */
Gilles Peskinea1ace9c2019-04-26 16:03:33 +02001299 psa_reset_key_attributes( &source_attributes );
1300 psa_reset_key_attributes( &target_attributes );
Ronald Cron3a4f0e32020-11-19 17:55:23 +01001301
Gilles Peskine1153e7b2019-05-28 15:10:21 +02001302 PSA_DONE( );
Gilles Peskine57ab7212019-01-28 13:03:09 +01001303 mbedtls_free( export_buffer );
1304}
1305/* END_CASE */
1306
1307/* BEGIN_CASE */
Gilles Peskinebcdd44b2019-05-20 17:28:11 +02001308void copy_fail( int source_usage_arg,
1309 int source_alg_arg, int source_alg2_arg,
Gilles Peskine4a644642019-05-03 17:14:08 +02001310 int type_arg, data_t *material,
1311 int target_type_arg, int target_bits_arg,
Gilles Peskinebcdd44b2019-05-20 17:28:11 +02001312 int target_usage_arg,
1313 int target_alg_arg, int target_alg2_arg,
Ronald Cron88a55462021-03-31 09:39:07 +02001314 int target_id_arg, int target_lifetime_arg,
Gilles Peskine4a644642019-05-03 17:14:08 +02001315 int expected_status_arg )
1316{
1317 psa_key_attributes_t source_attributes = PSA_KEY_ATTRIBUTES_INIT;
1318 psa_key_attributes_t target_attributes = PSA_KEY_ATTRIBUTES_INIT;
Ronald Cron5425a212020-08-04 14:58:35 +02001319 mbedtls_svc_key_id_t source_key = MBEDTLS_SVC_KEY_ID_INIT;
1320 mbedtls_svc_key_id_t target_key = MBEDTLS_SVC_KEY_ID_INIT;
Ronald Cron88a55462021-03-31 09:39:07 +02001321 mbedtls_svc_key_id_t key_id = mbedtls_svc_key_id_make( 1, target_id_arg );
Gilles Peskine4a644642019-05-03 17:14:08 +02001322
1323 PSA_ASSERT( psa_crypto_init( ) );
1324
1325 /* Prepare the source key. */
1326 psa_set_key_usage_flags( &source_attributes, source_usage_arg );
1327 psa_set_key_algorithm( &source_attributes, source_alg_arg );
Gilles Peskinebcdd44b2019-05-20 17:28:11 +02001328 psa_set_key_enrollment_algorithm( &source_attributes, source_alg2_arg );
Gilles Peskine4a644642019-05-03 17:14:08 +02001329 psa_set_key_type( &source_attributes, type_arg );
Gilles Peskine049c7532019-05-15 20:22:09 +02001330 PSA_ASSERT( psa_import_key( &source_attributes,
1331 material->x, material->len,
Ronald Cron5425a212020-08-04 14:58:35 +02001332 &source_key ) );
Gilles Peskine4a644642019-05-03 17:14:08 +02001333
1334 /* Prepare the target attributes. */
Ronald Cron88a55462021-03-31 09:39:07 +02001335 psa_set_key_id( &target_attributes, key_id );
1336 psa_set_key_lifetime( &target_attributes, target_lifetime_arg );
Gilles Peskine4a644642019-05-03 17:14:08 +02001337 psa_set_key_type( &target_attributes, target_type_arg );
1338 psa_set_key_bits( &target_attributes, target_bits_arg );
1339 psa_set_key_usage_flags( &target_attributes, target_usage_arg );
1340 psa_set_key_algorithm( &target_attributes, target_alg_arg );
Gilles Peskinebcdd44b2019-05-20 17:28:11 +02001341 psa_set_key_enrollment_algorithm( &target_attributes, target_alg2_arg );
Gilles Peskine4a644642019-05-03 17:14:08 +02001342
1343 /* Try to copy the key. */
Ronald Cron5425a212020-08-04 14:58:35 +02001344 TEST_EQUAL( psa_copy_key( source_key,
1345 &target_attributes, &target_key ),
Gilles Peskine4a644642019-05-03 17:14:08 +02001346 expected_status_arg );
Gilles Peskine76b29a72019-05-28 14:08:50 +02001347
Ronald Cron5425a212020-08-04 14:58:35 +02001348 PSA_ASSERT( psa_destroy_key( source_key ) );
Gilles Peskine76b29a72019-05-28 14:08:50 +02001349
Gilles Peskine4a644642019-05-03 17:14:08 +02001350exit:
1351 psa_reset_key_attributes( &source_attributes );
1352 psa_reset_key_attributes( &target_attributes );
Gilles Peskine1153e7b2019-05-28 15:10:21 +02001353 PSA_DONE( );
Gilles Peskine4a644642019-05-03 17:14:08 +02001354}
1355/* END_CASE */
1356
1357/* BEGIN_CASE */
Jaeden Amero6a25b412019-01-04 11:47:44 +00001358void hash_operation_init( )
1359{
Jaeden Ameroa0f625a2019-02-15 13:52:25 +00001360 const uint8_t input[1] = { 0 };
Jaeden Amero6a25b412019-01-04 11:47:44 +00001361 /* Test each valid way of initializing the object, except for `= {0}`, as
1362 * Clang 5 complains when `-Wmissing-field-initializers` is used, even
1363 * though it's OK by the C standard. We could test for this, but we'd need
1364 * to supress the Clang warning for the test. */
1365 psa_hash_operation_t func = psa_hash_operation_init( );
1366 psa_hash_operation_t init = PSA_HASH_OPERATION_INIT;
1367 psa_hash_operation_t zero;
1368
1369 memset( &zero, 0, sizeof( zero ) );
1370
Jaeden Amero11aa7ee2019-02-19 11:44:55 +00001371 /* A freshly-initialized hash operation should not be usable. */
Jaeden Ameroa0f625a2019-02-15 13:52:25 +00001372 TEST_EQUAL( psa_hash_update( &func, input, sizeof( input ) ),
1373 PSA_ERROR_BAD_STATE );
1374 TEST_EQUAL( psa_hash_update( &init, input, sizeof( input ) ),
1375 PSA_ERROR_BAD_STATE );
1376 TEST_EQUAL( psa_hash_update( &zero, input, sizeof( input ) ),
1377 PSA_ERROR_BAD_STATE );
1378
Jaeden Amero5229bbb2019-02-07 16:33:37 +00001379 /* A default hash operation should be abortable without error. */
1380 PSA_ASSERT( psa_hash_abort( &func ) );
1381 PSA_ASSERT( psa_hash_abort( &init ) );
1382 PSA_ASSERT( psa_hash_abort( &zero ) );
Jaeden Amero6a25b412019-01-04 11:47:44 +00001383}
1384/* END_CASE */
1385
1386/* BEGIN_CASE */
Gilles Peskine16c0f4f2018-06-20 16:05:20 +02001387void hash_setup( int alg_arg,
1388 int expected_status_arg )
1389{
1390 psa_algorithm_t alg = alg_arg;
Gilles Peskineb866e2b2018-06-21 09:25:10 +02001391 psa_status_t expected_status = expected_status_arg;
Jaeden Amero6a25b412019-01-04 11:47:44 +00001392 psa_hash_operation_t operation = PSA_HASH_OPERATION_INIT;
Gilles Peskine16c0f4f2018-06-20 16:05:20 +02001393 psa_status_t status;
1394
Gilles Peskine8817f612018-12-18 00:18:46 +01001395 PSA_ASSERT( psa_crypto_init( ) );
Gilles Peskine16c0f4f2018-06-20 16:05:20 +02001396
Gilles Peskineda8191d1c2018-07-08 19:46:38 +02001397 status = psa_hash_setup( &operation, alg );
Gilles Peskinefe11b722018-12-18 00:24:04 +01001398 TEST_EQUAL( status, expected_status );
Gilles Peskine16c0f4f2018-06-20 16:05:20 +02001399
Gilles Peskine9e0a4a52019-02-25 22:11:18 +01001400 /* Whether setup succeeded or failed, abort must succeed. */
1401 PSA_ASSERT( psa_hash_abort( &operation ) );
1402
1403 /* If setup failed, reproduce the failure, so as to
1404 * test the resulting state of the operation object. */
1405 if( status != PSA_SUCCESS )
1406 TEST_EQUAL( psa_hash_setup( &operation, alg ), status );
1407
Gilles Peskinef426e0f2019-02-25 17:42:03 +01001408 /* Now the operation object should be reusable. */
1409#if defined(KNOWN_SUPPORTED_HASH_ALG)
1410 PSA_ASSERT( psa_hash_setup( &operation, KNOWN_SUPPORTED_HASH_ALG ) );
1411 PSA_ASSERT( psa_hash_abort( &operation ) );
1412#endif
1413
Gilles Peskine16c0f4f2018-06-20 16:05:20 +02001414exit:
Gilles Peskine1153e7b2019-05-28 15:10:21 +02001415 PSA_DONE( );
Gilles Peskine16c0f4f2018-06-20 16:05:20 +02001416}
1417/* END_CASE */
1418
1419/* BEGIN_CASE */
Gilles Peskine0a749c82019-11-28 19:33:58 +01001420void hash_compute_fail( int alg_arg, data_t *input,
1421 int output_size_arg, int expected_status_arg )
1422{
1423 psa_algorithm_t alg = alg_arg;
1424 uint8_t *output = NULL;
1425 size_t output_size = output_size_arg;
1426 size_t output_length = INVALID_EXPORT_LENGTH;
1427 psa_status_t expected_status = expected_status_arg;
1428 psa_status_t status;
1429
1430 ASSERT_ALLOC( output, output_size );
1431
1432 PSA_ASSERT( psa_crypto_init( ) );
1433
1434 status = psa_hash_compute( alg, input->x, input->len,
1435 output, output_size, &output_length );
1436 TEST_EQUAL( status, expected_status );
1437 TEST_ASSERT( output_length <= output_size );
1438
1439exit:
1440 mbedtls_free( output );
1441 PSA_DONE( );
1442}
1443/* END_CASE */
1444
1445/* BEGIN_CASE */
Gilles Peskine88e08462020-01-28 20:43:00 +01001446void hash_compare_fail( int alg_arg, data_t *input,
1447 data_t *reference_hash,
1448 int expected_status_arg )
1449{
1450 psa_algorithm_t alg = alg_arg;
1451 psa_status_t expected_status = expected_status_arg;
1452 psa_status_t status;
1453
1454 PSA_ASSERT( psa_crypto_init( ) );
1455
1456 status = psa_hash_compare( alg, input->x, input->len,
1457 reference_hash->x, reference_hash->len );
1458 TEST_EQUAL( status, expected_status );
1459
1460exit:
1461 PSA_DONE( );
1462}
1463/* END_CASE */
1464
1465/* BEGIN_CASE */
Gilles Peskine0a749c82019-11-28 19:33:58 +01001466void hash_compute_compare( int alg_arg, data_t *input,
1467 data_t *expected_output )
1468{
1469 psa_algorithm_t alg = alg_arg;
1470 uint8_t output[PSA_HASH_MAX_SIZE + 1];
1471 size_t output_length = INVALID_EXPORT_LENGTH;
1472 size_t i;
1473
1474 PSA_ASSERT( psa_crypto_init( ) );
1475
1476 /* Compute with tight buffer */
1477 PSA_ASSERT( psa_hash_compute( alg, input->x, input->len,
gabor-mezei-armcbcec212020-12-18 14:23:51 +01001478 output, PSA_HASH_LENGTH( alg ),
Gilles Peskine0a749c82019-11-28 19:33:58 +01001479 &output_length ) );
gabor-mezei-armcbcec212020-12-18 14:23:51 +01001480 TEST_EQUAL( output_length, PSA_HASH_LENGTH( alg ) );
Gilles Peskine0a749c82019-11-28 19:33:58 +01001481 ASSERT_COMPARE( output, output_length,
1482 expected_output->x, expected_output->len );
1483
1484 /* Compute with larger buffer */
1485 PSA_ASSERT( psa_hash_compute( alg, input->x, input->len,
1486 output, sizeof( output ),
1487 &output_length ) );
gabor-mezei-armcbcec212020-12-18 14:23:51 +01001488 TEST_EQUAL( output_length, PSA_HASH_LENGTH( alg ) );
Gilles Peskine0a749c82019-11-28 19:33:58 +01001489 ASSERT_COMPARE( output, output_length,
1490 expected_output->x, expected_output->len );
1491
1492 /* Compare with correct hash */
1493 PSA_ASSERT( psa_hash_compare( alg, input->x, input->len,
1494 output, output_length ) );
1495
1496 /* Compare with trailing garbage */
1497 TEST_EQUAL( psa_hash_compare( alg, input->x, input->len,
1498 output, output_length + 1 ),
1499 PSA_ERROR_INVALID_SIGNATURE );
1500
1501 /* Compare with truncated hash */
1502 TEST_EQUAL( psa_hash_compare( alg, input->x, input->len,
1503 output, output_length - 1 ),
1504 PSA_ERROR_INVALID_SIGNATURE );
1505
1506 /* Compare with corrupted value */
1507 for( i = 0; i < output_length; i++ )
1508 {
Chris Jones9634bb12021-01-20 15:56:42 +00001509 mbedtls_test_set_step( i );
Gilles Peskine0a749c82019-11-28 19:33:58 +01001510 output[i] ^= 1;
1511 TEST_EQUAL( psa_hash_compare( alg, input->x, input->len,
1512 output, output_length ),
1513 PSA_ERROR_INVALID_SIGNATURE );
1514 output[i] ^= 1;
1515 }
1516
1517exit:
1518 PSA_DONE( );
1519}
1520/* END_CASE */
1521
Gilles Peskined6dc40c2021-01-12 12:55:31 +01001522/* BEGIN_CASE depends_on:PSA_WANT_ALG_SHA_256 */
itayzafrirf86548d2018-11-01 10:44:32 +02001523void hash_bad_order( )
1524{
Jaeden Amero11aa7ee2019-02-19 11:44:55 +00001525 psa_algorithm_t alg = PSA_ALG_SHA_256;
itayzafrirf86548d2018-11-01 10:44:32 +02001526 unsigned char input[] = "";
1527 /* SHA-256 hash of an empty string */
Jaeden Amero11aa7ee2019-02-19 11:44:55 +00001528 const unsigned char valid_hash[] = {
itayzafrirf86548d2018-11-01 10:44:32 +02001529 0xe3, 0xb0, 0xc4, 0x42, 0x98, 0xfc, 0x1c, 0x14, 0x9a, 0xfb, 0xf4, 0xc8,
1530 0x99, 0x6f, 0xb9, 0x24, 0x27, 0xae, 0x41, 0xe4, 0x64, 0x9b, 0x93, 0x4c,
1531 0xa4, 0x95, 0x99, 0x1b, 0x78, 0x52, 0xb8, 0x55 };
Jaeden Amero11aa7ee2019-02-19 11:44:55 +00001532 unsigned char hash[sizeof(valid_hash)] = { 0 };
itayzafrirf86548d2018-11-01 10:44:32 +02001533 size_t hash_len;
Jaeden Amero6a25b412019-01-04 11:47:44 +00001534 psa_hash_operation_t operation = PSA_HASH_OPERATION_INIT;
itayzafrirf86548d2018-11-01 10:44:32 +02001535
Gilles Peskine8817f612018-12-18 00:18:46 +01001536 PSA_ASSERT( psa_crypto_init( ) );
itayzafrirf86548d2018-11-01 10:44:32 +02001537
Jaeden Amero36ee5d02019-02-19 09:25:10 +00001538 /* Call setup twice in a row. */
1539 PSA_ASSERT( psa_hash_setup( &operation, alg ) );
1540 TEST_EQUAL( psa_hash_setup( &operation, alg ),
1541 PSA_ERROR_BAD_STATE );
1542 PSA_ASSERT( psa_hash_abort( &operation ) );
1543
Jaeden Amero11aa7ee2019-02-19 11:44:55 +00001544 /* Call update without calling setup beforehand. */
Gilles Peskinef812dcf2018-12-18 00:33:25 +01001545 TEST_EQUAL( psa_hash_update( &operation, input, sizeof( input ) ),
Jaeden Ameroa0f625a2019-02-15 13:52:25 +00001546 PSA_ERROR_BAD_STATE );
Jaeden Amero11aa7ee2019-02-19 11:44:55 +00001547 PSA_ASSERT( psa_hash_abort( &operation ) );
itayzafrirf86548d2018-11-01 10:44:32 +02001548
Jaeden Amero11aa7ee2019-02-19 11:44:55 +00001549 /* Call update after finish. */
1550 PSA_ASSERT( psa_hash_setup( &operation, alg ) );
1551 PSA_ASSERT( psa_hash_finish( &operation,
1552 hash, sizeof( hash ), &hash_len ) );
1553 TEST_EQUAL( psa_hash_update( &operation, input, sizeof( input ) ),
Jaeden Ameroa0f625a2019-02-15 13:52:25 +00001554 PSA_ERROR_BAD_STATE );
Jaeden Amero11aa7ee2019-02-19 11:44:55 +00001555 PSA_ASSERT( psa_hash_abort( &operation ) );
itayzafrirf86548d2018-11-01 10:44:32 +02001556
Jaeden Amero11aa7ee2019-02-19 11:44:55 +00001557 /* Call verify without calling setup beforehand. */
1558 TEST_EQUAL( psa_hash_verify( &operation,
1559 valid_hash, sizeof( valid_hash ) ),
1560 PSA_ERROR_BAD_STATE );
1561 PSA_ASSERT( psa_hash_abort( &operation ) );
1562
1563 /* Call verify after finish. */
1564 PSA_ASSERT( psa_hash_setup( &operation, alg ) );
1565 PSA_ASSERT( psa_hash_finish( &operation,
1566 hash, sizeof( hash ), &hash_len ) );
1567 TEST_EQUAL( psa_hash_verify( &operation,
1568 valid_hash, sizeof( valid_hash ) ),
1569 PSA_ERROR_BAD_STATE );
1570 PSA_ASSERT( psa_hash_abort( &operation ) );
1571
1572 /* Call verify twice in a row. */
1573 PSA_ASSERT( psa_hash_setup( &operation, alg ) );
1574 PSA_ASSERT( psa_hash_verify( &operation,
1575 valid_hash, sizeof( valid_hash ) ) );
1576 TEST_EQUAL( psa_hash_verify( &operation,
1577 valid_hash, sizeof( valid_hash ) ),
1578 PSA_ERROR_BAD_STATE );
1579 PSA_ASSERT( psa_hash_abort( &operation ) );
1580
1581 /* Call finish without calling setup beforehand. */
Gilles Peskinefe11b722018-12-18 00:24:04 +01001582 TEST_EQUAL( psa_hash_finish( &operation,
1583 hash, sizeof( hash ), &hash_len ),
Jaeden Ameroa0f625a2019-02-15 13:52:25 +00001584 PSA_ERROR_BAD_STATE );
Jaeden Amero11aa7ee2019-02-19 11:44:55 +00001585 PSA_ASSERT( psa_hash_abort( &operation ) );
1586
1587 /* Call finish twice in a row. */
1588 PSA_ASSERT( psa_hash_setup( &operation, alg ) );
1589 PSA_ASSERT( psa_hash_finish( &operation,
1590 hash, sizeof( hash ), &hash_len ) );
1591 TEST_EQUAL( psa_hash_finish( &operation,
1592 hash, sizeof( hash ), &hash_len ),
1593 PSA_ERROR_BAD_STATE );
1594 PSA_ASSERT( psa_hash_abort( &operation ) );
1595
1596 /* Call finish after calling verify. */
1597 PSA_ASSERT( psa_hash_setup( &operation, alg ) );
1598 PSA_ASSERT( psa_hash_verify( &operation,
1599 valid_hash, sizeof( valid_hash ) ) );
1600 TEST_EQUAL( psa_hash_finish( &operation,
1601 hash, sizeof( hash ), &hash_len ),
1602 PSA_ERROR_BAD_STATE );
1603 PSA_ASSERT( psa_hash_abort( &operation ) );
itayzafrirf86548d2018-11-01 10:44:32 +02001604
1605exit:
Gilles Peskine1153e7b2019-05-28 15:10:21 +02001606 PSA_DONE( );
itayzafrirf86548d2018-11-01 10:44:32 +02001607}
1608/* END_CASE */
1609
Gilles Peskined6dc40c2021-01-12 12:55:31 +01001610/* BEGIN_CASE depends_on:PSA_WANT_ALG_SHA_256 */
itayzafrir27e69452018-11-01 14:26:34 +02001611void hash_verify_bad_args( )
itayzafrirec93d302018-10-18 18:01:10 +03001612{
1613 psa_algorithm_t alg = PSA_ALG_SHA_256;
itayzafrir27e69452018-11-01 14:26:34 +02001614 /* SHA-256 hash of an empty string with 2 extra bytes (0xaa and 0xbb)
1615 * appended to it */
1616 unsigned char hash[] = {
1617 0xe3, 0xb0, 0xc4, 0x42, 0x98, 0xfc, 0x1c, 0x14, 0x9a, 0xfb, 0xf4, 0xc8,
1618 0x99, 0x6f, 0xb9, 0x24, 0x27, 0xae, 0x41, 0xe4, 0x64, 0x9b, 0x93, 0x4c,
1619 0xa4, 0x95, 0x99, 0x1b, 0x78, 0x52, 0xb8, 0x55, 0xaa, 0xbb };
gabor-mezei-armcbcec212020-12-18 14:23:51 +01001620 size_t expected_size = PSA_HASH_LENGTH( alg );
Jaeden Amero6a25b412019-01-04 11:47:44 +00001621 psa_hash_operation_t operation = PSA_HASH_OPERATION_INIT;
itayzafrirec93d302018-10-18 18:01:10 +03001622
Gilles Peskine8817f612018-12-18 00:18:46 +01001623 PSA_ASSERT( psa_crypto_init( ) );
itayzafrirec93d302018-10-18 18:01:10 +03001624
itayzafrir27e69452018-11-01 14:26:34 +02001625 /* psa_hash_verify with a smaller hash than expected */
Gilles Peskine8817f612018-12-18 00:18:46 +01001626 PSA_ASSERT( psa_hash_setup( &operation, alg ) );
Gilles Peskinef812dcf2018-12-18 00:33:25 +01001627 TEST_EQUAL( psa_hash_verify( &operation, hash, expected_size - 1 ),
Gilles Peskinefe11b722018-12-18 00:24:04 +01001628 PSA_ERROR_INVALID_SIGNATURE );
itayzafrirec93d302018-10-18 18:01:10 +03001629
itayzafrir27e69452018-11-01 14:26:34 +02001630 /* psa_hash_verify with a non-matching hash */
Gilles Peskine8817f612018-12-18 00:18:46 +01001631 PSA_ASSERT( psa_hash_setup( &operation, alg ) );
Gilles Peskinef812dcf2018-12-18 00:33:25 +01001632 TEST_EQUAL( psa_hash_verify( &operation, hash + 1, expected_size ),
Gilles Peskinefe11b722018-12-18 00:24:04 +01001633 PSA_ERROR_INVALID_SIGNATURE );
itayzafrirec93d302018-10-18 18:01:10 +03001634
itayzafrir27e69452018-11-01 14:26:34 +02001635 /* psa_hash_verify with a hash longer than expected */
Gilles Peskine8817f612018-12-18 00:18:46 +01001636 PSA_ASSERT( psa_hash_setup( &operation, alg ) );
Gilles Peskinef812dcf2018-12-18 00:33:25 +01001637 TEST_EQUAL( psa_hash_verify( &operation, hash, sizeof( hash ) ),
Gilles Peskinefe11b722018-12-18 00:24:04 +01001638 PSA_ERROR_INVALID_SIGNATURE );
itayzafrir4271df92018-10-24 18:16:19 +03001639
itayzafrirec93d302018-10-18 18:01:10 +03001640exit:
Gilles Peskine1153e7b2019-05-28 15:10:21 +02001641 PSA_DONE( );
itayzafrirec93d302018-10-18 18:01:10 +03001642}
1643/* END_CASE */
1644
Ronald Cronee414c72021-03-18 18:50:08 +01001645/* BEGIN_CASE depends_on:PSA_WANT_ALG_SHA_256 */
itayzafrirb2dd5ed2018-11-01 11:58:59 +02001646void hash_finish_bad_args( )
itayzafrir58028322018-10-25 10:22:01 +03001647{
1648 psa_algorithm_t alg = PSA_ALG_SHA_256;
itayzafrirb2dd5ed2018-11-01 11:58:59 +02001649 unsigned char hash[PSA_HASH_MAX_SIZE];
gabor-mezei-armcbcec212020-12-18 14:23:51 +01001650 size_t expected_size = PSA_HASH_LENGTH( alg );
Jaeden Amero6a25b412019-01-04 11:47:44 +00001651 psa_hash_operation_t operation = PSA_HASH_OPERATION_INIT;
itayzafrir58028322018-10-25 10:22:01 +03001652 size_t hash_len;
1653
Gilles Peskine8817f612018-12-18 00:18:46 +01001654 PSA_ASSERT( psa_crypto_init( ) );
itayzafrir58028322018-10-25 10:22:01 +03001655
itayzafrir58028322018-10-25 10:22:01 +03001656 /* psa_hash_finish with a smaller hash buffer than expected */
Gilles Peskine8817f612018-12-18 00:18:46 +01001657 PSA_ASSERT( psa_hash_setup( &operation, alg ) );
Gilles Peskinefe11b722018-12-18 00:24:04 +01001658 TEST_EQUAL( psa_hash_finish( &operation,
Gilles Peskinef812dcf2018-12-18 00:33:25 +01001659 hash, expected_size - 1, &hash_len ),
1660 PSA_ERROR_BUFFER_TOO_SMALL );
itayzafrir58028322018-10-25 10:22:01 +03001661
1662exit:
Gilles Peskine1153e7b2019-05-28 15:10:21 +02001663 PSA_DONE( );
itayzafrir58028322018-10-25 10:22:01 +03001664}
1665/* END_CASE */
1666
Ronald Cronee414c72021-03-18 18:50:08 +01001667/* BEGIN_CASE depends_on:PSA_WANT_ALG_SHA_256 */
Gilles Peskineebb2c3e2019-01-19 12:03:41 +01001668void hash_clone_source_state( )
1669{
1670 psa_algorithm_t alg = PSA_ALG_SHA_256;
1671 unsigned char hash[PSA_HASH_MAX_SIZE];
1672 psa_hash_operation_t op_source = PSA_HASH_OPERATION_INIT;
1673 psa_hash_operation_t op_init = PSA_HASH_OPERATION_INIT;
1674 psa_hash_operation_t op_setup = PSA_HASH_OPERATION_INIT;
1675 psa_hash_operation_t op_finished = PSA_HASH_OPERATION_INIT;
1676 psa_hash_operation_t op_aborted = PSA_HASH_OPERATION_INIT;
1677 size_t hash_len;
1678
1679 PSA_ASSERT( psa_crypto_init( ) );
1680 PSA_ASSERT( psa_hash_setup( &op_source, alg ) );
1681
1682 PSA_ASSERT( psa_hash_setup( &op_setup, alg ) );
1683 PSA_ASSERT( psa_hash_setup( &op_finished, alg ) );
1684 PSA_ASSERT( psa_hash_finish( &op_finished,
1685 hash, sizeof( hash ), &hash_len ) );
1686 PSA_ASSERT( psa_hash_setup( &op_aborted, alg ) );
1687 PSA_ASSERT( psa_hash_abort( &op_aborted ) );
1688
1689 TEST_EQUAL( psa_hash_clone( &op_source, &op_setup ),
1690 PSA_ERROR_BAD_STATE );
1691
1692 PSA_ASSERT( psa_hash_clone( &op_source, &op_init ) );
1693 PSA_ASSERT( psa_hash_finish( &op_init,
1694 hash, sizeof( hash ), &hash_len ) );
1695 PSA_ASSERT( psa_hash_clone( &op_source, &op_finished ) );
1696 PSA_ASSERT( psa_hash_finish( &op_finished,
1697 hash, sizeof( hash ), &hash_len ) );
1698 PSA_ASSERT( psa_hash_clone( &op_source, &op_aborted ) );
1699 PSA_ASSERT( psa_hash_finish( &op_aborted,
1700 hash, sizeof( hash ), &hash_len ) );
1701
1702exit:
1703 psa_hash_abort( &op_source );
1704 psa_hash_abort( &op_init );
1705 psa_hash_abort( &op_setup );
1706 psa_hash_abort( &op_finished );
1707 psa_hash_abort( &op_aborted );
Gilles Peskine1153e7b2019-05-28 15:10:21 +02001708 PSA_DONE( );
Gilles Peskineebb2c3e2019-01-19 12:03:41 +01001709}
1710/* END_CASE */
1711
Ronald Cronee414c72021-03-18 18:50:08 +01001712/* BEGIN_CASE depends_on:PSA_WANT_ALG_SHA_256 */
Gilles Peskineebb2c3e2019-01-19 12:03:41 +01001713void hash_clone_target_state( )
1714{
1715 psa_algorithm_t alg = PSA_ALG_SHA_256;
1716 unsigned char hash[PSA_HASH_MAX_SIZE];
1717 psa_hash_operation_t op_init = PSA_HASH_OPERATION_INIT;
1718 psa_hash_operation_t op_setup = PSA_HASH_OPERATION_INIT;
1719 psa_hash_operation_t op_finished = PSA_HASH_OPERATION_INIT;
1720 psa_hash_operation_t op_aborted = PSA_HASH_OPERATION_INIT;
1721 psa_hash_operation_t op_target = PSA_HASH_OPERATION_INIT;
1722 size_t hash_len;
1723
1724 PSA_ASSERT( psa_crypto_init( ) );
1725
1726 PSA_ASSERT( psa_hash_setup( &op_setup, alg ) );
1727 PSA_ASSERT( psa_hash_setup( &op_finished, alg ) );
1728 PSA_ASSERT( psa_hash_finish( &op_finished,
1729 hash, sizeof( hash ), &hash_len ) );
1730 PSA_ASSERT( psa_hash_setup( &op_aborted, alg ) );
1731 PSA_ASSERT( psa_hash_abort( &op_aborted ) );
1732
1733 PSA_ASSERT( psa_hash_clone( &op_setup, &op_target ) );
1734 PSA_ASSERT( psa_hash_finish( &op_target,
1735 hash, sizeof( hash ), &hash_len ) );
1736
1737 TEST_EQUAL( psa_hash_clone( &op_init, &op_target ), PSA_ERROR_BAD_STATE );
1738 TEST_EQUAL( psa_hash_clone( &op_finished, &op_target ),
1739 PSA_ERROR_BAD_STATE );
1740 TEST_EQUAL( psa_hash_clone( &op_aborted, &op_target ),
1741 PSA_ERROR_BAD_STATE );
1742
1743exit:
1744 psa_hash_abort( &op_target );
1745 psa_hash_abort( &op_init );
1746 psa_hash_abort( &op_setup );
1747 psa_hash_abort( &op_finished );
1748 psa_hash_abort( &op_aborted );
Gilles Peskine1153e7b2019-05-28 15:10:21 +02001749 PSA_DONE( );
Gilles Peskineebb2c3e2019-01-19 12:03:41 +01001750}
1751/* END_CASE */
1752
itayzafrir58028322018-10-25 10:22:01 +03001753/* BEGIN_CASE */
Jaeden Amero769ce272019-01-04 11:48:03 +00001754void mac_operation_init( )
1755{
Jaeden Amero252ef282019-02-15 14:05:35 +00001756 const uint8_t input[1] = { 0 };
1757
Jaeden Amero769ce272019-01-04 11:48:03 +00001758 /* Test each valid way of initializing the object, except for `= {0}`, as
1759 * Clang 5 complains when `-Wmissing-field-initializers` is used, even
1760 * though it's OK by the C standard. We could test for this, but we'd need
1761 * to supress the Clang warning for the test. */
1762 psa_mac_operation_t func = psa_mac_operation_init( );
1763 psa_mac_operation_t init = PSA_MAC_OPERATION_INIT;
1764 psa_mac_operation_t zero;
1765
1766 memset( &zero, 0, sizeof( zero ) );
1767
Jaeden Amero252ef282019-02-15 14:05:35 +00001768 /* A freshly-initialized MAC operation should not be usable. */
1769 TEST_EQUAL( psa_mac_update( &func,
1770 input, sizeof( input ) ),
1771 PSA_ERROR_BAD_STATE );
1772 TEST_EQUAL( psa_mac_update( &init,
1773 input, sizeof( input ) ),
1774 PSA_ERROR_BAD_STATE );
1775 TEST_EQUAL( psa_mac_update( &zero,
1776 input, sizeof( input ) ),
1777 PSA_ERROR_BAD_STATE );
1778
Jaeden Amero5229bbb2019-02-07 16:33:37 +00001779 /* A default MAC operation should be abortable without error. */
1780 PSA_ASSERT( psa_mac_abort( &func ) );
1781 PSA_ASSERT( psa_mac_abort( &init ) );
1782 PSA_ASSERT( psa_mac_abort( &zero ) );
Jaeden Amero769ce272019-01-04 11:48:03 +00001783}
1784/* END_CASE */
1785
1786/* BEGIN_CASE */
Gilles Peskine16c0f4f2018-06-20 16:05:20 +02001787void mac_setup( int key_type_arg,
1788 data_t *key,
1789 int alg_arg,
1790 int expected_status_arg )
1791{
Gilles Peskine16c0f4f2018-06-20 16:05:20 +02001792 psa_key_type_t key_type = key_type_arg;
1793 psa_algorithm_t alg = alg_arg;
Gilles Peskineb866e2b2018-06-21 09:25:10 +02001794 psa_status_t expected_status = expected_status_arg;
Jaeden Amero769ce272019-01-04 11:48:03 +00001795 psa_mac_operation_t operation = PSA_MAC_OPERATION_INIT;
Gilles Peskinef426e0f2019-02-25 17:42:03 +01001796 psa_status_t status = PSA_ERROR_GENERIC_ERROR;
1797#if defined(KNOWN_SUPPORTED_MAC_ALG)
1798 const uint8_t smoke_test_key_data[16] = "kkkkkkkkkkkkkkkk";
1799#endif
Gilles Peskine16c0f4f2018-06-20 16:05:20 +02001800
Gilles Peskine8817f612018-12-18 00:18:46 +01001801 PSA_ASSERT( psa_crypto_init( ) );
Gilles Peskine16c0f4f2018-06-20 16:05:20 +02001802
Gilles Peskinef426e0f2019-02-25 17:42:03 +01001803 if( ! exercise_mac_setup( key_type, key->x, key->len, alg,
1804 &operation, &status ) )
1805 goto exit;
Gilles Peskinefe11b722018-12-18 00:24:04 +01001806 TEST_EQUAL( status, expected_status );
Gilles Peskine16c0f4f2018-06-20 16:05:20 +02001807
Gilles Peskinef426e0f2019-02-25 17:42:03 +01001808 /* The operation object should be reusable. */
1809#if defined(KNOWN_SUPPORTED_MAC_ALG)
1810 if( ! exercise_mac_setup( KNOWN_SUPPORTED_MAC_KEY_TYPE,
1811 smoke_test_key_data,
1812 sizeof( smoke_test_key_data ),
1813 KNOWN_SUPPORTED_MAC_ALG,
1814 &operation, &status ) )
1815 goto exit;
1816 TEST_EQUAL( status, PSA_SUCCESS );
1817#endif
1818
Gilles Peskine16c0f4f2018-06-20 16:05:20 +02001819exit:
Gilles Peskine1153e7b2019-05-28 15:10:21 +02001820 PSA_DONE( );
Gilles Peskine16c0f4f2018-06-20 16:05:20 +02001821}
1822/* END_CASE */
1823
Gilles Peskined6dc40c2021-01-12 12:55:31 +01001824/* BEGIN_CASE depends_on:PSA_WANT_KEY_TYPE_HMAC:PSA_WANT_ALG_HMAC:PSA_WANT_ALG_SHA_256 */
Jaeden Amero252ef282019-02-15 14:05:35 +00001825void mac_bad_order( )
1826{
Ronald Cron5425a212020-08-04 14:58:35 +02001827 mbedtls_svc_key_id_t key = MBEDTLS_SVC_KEY_ID_INIT;
Jaeden Amero252ef282019-02-15 14:05:35 +00001828 psa_key_type_t key_type = PSA_KEY_TYPE_HMAC;
1829 psa_algorithm_t alg = PSA_ALG_HMAC(PSA_ALG_SHA_256);
Ronald Cron5425a212020-08-04 14:58:35 +02001830 const uint8_t key_data[] = {
Jaeden Amero252ef282019-02-15 14:05:35 +00001831 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
1832 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
1833 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa };
Gilles Peskine2c2cf0e2019-04-19 19:58:20 +02001834 psa_key_attributes_t attributes = PSA_KEY_ATTRIBUTES_INIT;
Jaeden Amero252ef282019-02-15 14:05:35 +00001835 psa_mac_operation_t operation = PSA_MAC_OPERATION_INIT;
1836 uint8_t sign_mac[PSA_MAC_MAX_SIZE + 10] = { 0 };
1837 size_t sign_mac_length = 0;
1838 const uint8_t input[] = { 0xbb, 0xbb, 0xbb, 0xbb };
1839 const uint8_t verify_mac[] = {
1840 0x74, 0x65, 0x93, 0x8c, 0xeb, 0x1d, 0xb3, 0x76, 0x5a, 0x38, 0xe7, 0xdd,
1841 0x85, 0xc5, 0xad, 0x4f, 0x07, 0xe7, 0xd5, 0xb2, 0x64, 0xf0, 0x1a, 0x1a,
1842 0x2c, 0xf9, 0x18, 0xca, 0x59, 0x7e, 0x5d, 0xf6 };
1843
1844 PSA_ASSERT( psa_crypto_init( ) );
Gilles Peskine89d8c5c2019-11-26 17:01:59 +01001845 psa_set_key_usage_flags( &attributes, PSA_KEY_USAGE_SIGN_HASH | PSA_KEY_USAGE_VERIFY_HASH );
Gilles Peskine2c2cf0e2019-04-19 19:58:20 +02001846 psa_set_key_algorithm( &attributes, alg );
1847 psa_set_key_type( &attributes, key_type );
Gilles Peskine16c0f4f2018-06-20 16:05:20 +02001848
Ronald Cron5425a212020-08-04 14:58:35 +02001849 PSA_ASSERT( psa_import_key( &attributes, key_data, sizeof( key_data ),
1850 &key ) );
Gilles Peskine16c0f4f2018-06-20 16:05:20 +02001851
Jaeden Amero252ef282019-02-15 14:05:35 +00001852 /* Call update without calling setup beforehand. */
1853 TEST_EQUAL( psa_mac_update( &operation, input, sizeof( input ) ),
1854 PSA_ERROR_BAD_STATE );
1855 PSA_ASSERT( psa_mac_abort( &operation ) );
1856
1857 /* Call sign finish without calling setup beforehand. */
1858 TEST_EQUAL( psa_mac_sign_finish( &operation, sign_mac, sizeof( sign_mac ),
1859 &sign_mac_length),
1860 PSA_ERROR_BAD_STATE );
1861 PSA_ASSERT( psa_mac_abort( &operation ) );
1862
1863 /* Call verify finish without calling setup beforehand. */
1864 TEST_EQUAL( psa_mac_verify_finish( &operation,
1865 verify_mac, sizeof( verify_mac ) ),
1866 PSA_ERROR_BAD_STATE );
1867 PSA_ASSERT( psa_mac_abort( &operation ) );
1868
Jaeden Amero36ee5d02019-02-19 09:25:10 +00001869 /* Call setup twice in a row. */
Ronald Cron5425a212020-08-04 14:58:35 +02001870 PSA_ASSERT( psa_mac_sign_setup( &operation, key, alg ) );
1871 TEST_EQUAL( psa_mac_sign_setup( &operation, key, alg ),
Jaeden Amero36ee5d02019-02-19 09:25:10 +00001872 PSA_ERROR_BAD_STATE );
1873 PSA_ASSERT( psa_mac_abort( &operation ) );
1874
Jaeden Amero252ef282019-02-15 14:05:35 +00001875 /* Call update after sign finish. */
Ronald Cron5425a212020-08-04 14:58:35 +02001876 PSA_ASSERT( psa_mac_sign_setup( &operation, key, alg ) );
Jaeden Amero252ef282019-02-15 14:05:35 +00001877 PSA_ASSERT( psa_mac_update( &operation, input, sizeof( input ) ) );
1878 PSA_ASSERT( psa_mac_sign_finish( &operation,
1879 sign_mac, sizeof( sign_mac ),
1880 &sign_mac_length ) );
1881 TEST_EQUAL( psa_mac_update( &operation, input, sizeof( input ) ),
1882 PSA_ERROR_BAD_STATE );
1883 PSA_ASSERT( psa_mac_abort( &operation ) );
1884
1885 /* Call update after verify finish. */
Ronald Cron5425a212020-08-04 14:58:35 +02001886 PSA_ASSERT( psa_mac_verify_setup( &operation, key, alg ) );
Jaeden Amero252ef282019-02-15 14:05:35 +00001887 PSA_ASSERT( psa_mac_update( &operation, input, sizeof( input ) ) );
1888 PSA_ASSERT( psa_mac_verify_finish( &operation,
1889 verify_mac, sizeof( verify_mac ) ) );
1890 TEST_EQUAL( psa_mac_update( &operation, input, sizeof( input ) ),
1891 PSA_ERROR_BAD_STATE );
1892 PSA_ASSERT( psa_mac_abort( &operation ) );
1893
1894 /* Call sign finish twice in a row. */
Ronald Cron5425a212020-08-04 14:58:35 +02001895 PSA_ASSERT( psa_mac_sign_setup( &operation, key, alg ) );
Jaeden Amero252ef282019-02-15 14:05:35 +00001896 PSA_ASSERT( psa_mac_update( &operation, input, sizeof( input ) ) );
1897 PSA_ASSERT( psa_mac_sign_finish( &operation,
1898 sign_mac, sizeof( sign_mac ),
1899 &sign_mac_length ) );
1900 TEST_EQUAL( psa_mac_sign_finish( &operation,
1901 sign_mac, sizeof( sign_mac ),
1902 &sign_mac_length ),
1903 PSA_ERROR_BAD_STATE );
1904 PSA_ASSERT( psa_mac_abort( &operation ) );
1905
1906 /* Call verify finish twice in a row. */
Ronald Cron5425a212020-08-04 14:58:35 +02001907 PSA_ASSERT( psa_mac_verify_setup( &operation, key, alg ) );
Jaeden Amero252ef282019-02-15 14:05:35 +00001908 PSA_ASSERT( psa_mac_update( &operation, input, sizeof( input ) ) );
1909 PSA_ASSERT( psa_mac_verify_finish( &operation,
1910 verify_mac, sizeof( verify_mac ) ) );
1911 TEST_EQUAL( psa_mac_verify_finish( &operation,
1912 verify_mac, sizeof( verify_mac ) ),
1913 PSA_ERROR_BAD_STATE );
1914 PSA_ASSERT( psa_mac_abort( &operation ) );
1915
1916 /* Setup sign but try verify. */
Ronald Cron5425a212020-08-04 14:58:35 +02001917 PSA_ASSERT( psa_mac_sign_setup( &operation, key, alg ) );
Jaeden Amero252ef282019-02-15 14:05:35 +00001918 PSA_ASSERT( psa_mac_update( &operation, input, sizeof( input ) ) );
1919 TEST_EQUAL( psa_mac_verify_finish( &operation,
1920 verify_mac, sizeof( verify_mac ) ),
1921 PSA_ERROR_BAD_STATE );
1922 PSA_ASSERT( psa_mac_abort( &operation ) );
1923
1924 /* Setup verify but try sign. */
Ronald Cron5425a212020-08-04 14:58:35 +02001925 PSA_ASSERT( psa_mac_verify_setup( &operation, key, alg ) );
Jaeden Amero252ef282019-02-15 14:05:35 +00001926 PSA_ASSERT( psa_mac_update( &operation, input, sizeof( input ) ) );
1927 TEST_EQUAL( psa_mac_sign_finish( &operation,
1928 sign_mac, sizeof( sign_mac ),
1929 &sign_mac_length ),
1930 PSA_ERROR_BAD_STATE );
1931 PSA_ASSERT( psa_mac_abort( &operation ) );
Gilles Peskine16c0f4f2018-06-20 16:05:20 +02001932
Ronald Cron5425a212020-08-04 14:58:35 +02001933 PSA_ASSERT( psa_destroy_key( key ) );
Gilles Peskine76b29a72019-05-28 14:08:50 +02001934
Gilles Peskine16c0f4f2018-06-20 16:05:20 +02001935exit:
Gilles Peskine1153e7b2019-05-28 15:10:21 +02001936 PSA_DONE( );
Gilles Peskine16c0f4f2018-06-20 16:05:20 +02001937}
1938/* END_CASE */
1939
1940/* BEGIN_CASE */
Gilles Peskinea7aa4422018-08-14 15:17:54 +02001941void mac_sign( int key_type_arg,
Ronald Cron5425a212020-08-04 14:58:35 +02001942 data_t *key_data,
Gilles Peskinea7aa4422018-08-14 15:17:54 +02001943 int alg_arg,
1944 data_t *input,
1945 data_t *expected_mac )
1946{
Ronald Cron5425a212020-08-04 14:58:35 +02001947 mbedtls_svc_key_id_t key = MBEDTLS_SVC_KEY_ID_INIT;
Gilles Peskinea7aa4422018-08-14 15:17:54 +02001948 psa_key_type_t key_type = key_type_arg;
1949 psa_algorithm_t alg = alg_arg;
Jaeden Amero769ce272019-01-04 11:48:03 +00001950 psa_mac_operation_t operation = PSA_MAC_OPERATION_INIT;
Gilles Peskine2c2cf0e2019-04-19 19:58:20 +02001951 psa_key_attributes_t attributes = PSA_KEY_ATTRIBUTES_INIT;
Gilles Peskine5e65cec2020-08-25 23:38:39 +02001952 uint8_t *actual_mac = NULL;
Gilles Peskinea7aa4422018-08-14 15:17:54 +02001953 size_t mac_buffer_size =
gabor-mezei-armcbcec212020-12-18 14:23:51 +01001954 PSA_MAC_LENGTH( key_type, PSA_BYTES_TO_BITS( key_data->len ), alg );
Gilles Peskinea7aa4422018-08-14 15:17:54 +02001955 size_t mac_length = 0;
Gilles Peskine8b356b52020-08-25 23:44:59 +02001956 const size_t output_sizes_to_test[] = {
1957 0,
1958 1,
1959 expected_mac->len - 1,
1960 expected_mac->len,
1961 expected_mac->len + 1,
1962 };
Gilles Peskinea7aa4422018-08-14 15:17:54 +02001963
Gilles Peskinea7aa4422018-08-14 15:17:54 +02001964 TEST_ASSERT( mac_buffer_size <= PSA_MAC_MAX_SIZE );
gabor-mezei-armcbcec212020-12-18 14:23:51 +01001965 /* We expect PSA_MAC_LENGTH to be exact. */
Gilles Peskine3d404d62020-08-25 23:47:36 +02001966 TEST_ASSERT( expected_mac->len == mac_buffer_size );
Gilles Peskinea7aa4422018-08-14 15:17:54 +02001967
Gilles Peskine8817f612018-12-18 00:18:46 +01001968 PSA_ASSERT( psa_crypto_init( ) );
Gilles Peskinea7aa4422018-08-14 15:17:54 +02001969
Gilles Peskine89d8c5c2019-11-26 17:01:59 +01001970 psa_set_key_usage_flags( &attributes, PSA_KEY_USAGE_SIGN_HASH );
Gilles Peskine2c2cf0e2019-04-19 19:58:20 +02001971 psa_set_key_algorithm( &attributes, alg );
1972 psa_set_key_type( &attributes, key_type );
Gilles Peskinea7aa4422018-08-14 15:17:54 +02001973
Ronald Cron5425a212020-08-04 14:58:35 +02001974 PSA_ASSERT( psa_import_key( &attributes, key_data->x, key_data->len,
1975 &key ) );
Gilles Peskinea7aa4422018-08-14 15:17:54 +02001976
Gilles Peskine8b356b52020-08-25 23:44:59 +02001977 for( size_t i = 0; i < ARRAY_LENGTH( output_sizes_to_test ); i++ )
1978 {
1979 const size_t output_size = output_sizes_to_test[i];
1980 psa_status_t expected_status =
1981 ( output_size >= expected_mac->len ? PSA_SUCCESS :
1982 PSA_ERROR_BUFFER_TOO_SMALL );
Gilles Peskine5e65cec2020-08-25 23:38:39 +02001983
Chris Jones9634bb12021-01-20 15:56:42 +00001984 mbedtls_test_set_step( output_size );
Gilles Peskine8b356b52020-08-25 23:44:59 +02001985 ASSERT_ALLOC( actual_mac, output_size );
Gilles Peskinea7aa4422018-08-14 15:17:54 +02001986
Gilles Peskine8b356b52020-08-25 23:44:59 +02001987 /* Calculate the MAC. */
Ronald Cron5425a212020-08-04 14:58:35 +02001988 PSA_ASSERT( psa_mac_sign_setup( &operation, key, alg ) );
Gilles Peskine8b356b52020-08-25 23:44:59 +02001989 PSA_ASSERT( psa_mac_update( &operation,
1990 input->x, input->len ) );
1991 TEST_EQUAL( psa_mac_sign_finish( &operation,
1992 actual_mac, output_size,
1993 &mac_length ),
1994 expected_status );
1995 PSA_ASSERT( psa_mac_abort( &operation ) );
1996
1997 if( expected_status == PSA_SUCCESS )
1998 {
1999 ASSERT_COMPARE( expected_mac->x, expected_mac->len,
2000 actual_mac, mac_length );
2001 }
2002 mbedtls_free( actual_mac );
2003 actual_mac = NULL;
2004 }
Gilles Peskinea7aa4422018-08-14 15:17:54 +02002005
Gilles Peskinea7aa4422018-08-14 15:17:54 +02002006exit:
Gilles Peskine64f13ef2020-08-25 23:15:20 +02002007 psa_mac_abort( &operation );
Ronald Cron5425a212020-08-04 14:58:35 +02002008 psa_destroy_key( key );
Gilles Peskine1153e7b2019-05-28 15:10:21 +02002009 PSA_DONE( );
Gilles Peskine5e65cec2020-08-25 23:38:39 +02002010 mbedtls_free( actual_mac );
Gilles Peskinea7aa4422018-08-14 15:17:54 +02002011}
2012/* END_CASE */
2013
2014/* BEGIN_CASE */
Gilles Peskinec0ec9722018-06-18 17:03:37 +02002015void mac_verify( int key_type_arg,
Ronald Cron5425a212020-08-04 14:58:35 +02002016 data_t *key_data,
Gilles Peskinec0ec9722018-06-18 17:03:37 +02002017 int alg_arg,
2018 data_t *input,
2019 data_t *expected_mac )
Gilles Peskine8c9def32018-02-08 10:02:12 +01002020{
Ronald Cron5425a212020-08-04 14:58:35 +02002021 mbedtls_svc_key_id_t key = MBEDTLS_SVC_KEY_ID_INIT;
Gilles Peskine8c9def32018-02-08 10:02:12 +01002022 psa_key_type_t key_type = key_type_arg;
2023 psa_algorithm_t alg = alg_arg;
Jaeden Amero769ce272019-01-04 11:48:03 +00002024 psa_mac_operation_t operation = PSA_MAC_OPERATION_INIT;
Gilles Peskine2c2cf0e2019-04-19 19:58:20 +02002025 psa_key_attributes_t attributes = PSA_KEY_ATTRIBUTES_INIT;
Gilles Peskine29c4a6c2020-08-26 00:01:39 +02002026 uint8_t *perturbed_mac = NULL;
Gilles Peskine8c9def32018-02-08 10:02:12 +01002027
Gilles Peskine69c12672018-06-28 00:07:19 +02002028 TEST_ASSERT( expected_mac->len <= PSA_MAC_MAX_SIZE );
2029
Gilles Peskine8817f612018-12-18 00:18:46 +01002030 PSA_ASSERT( psa_crypto_init( ) );
Gilles Peskine8c9def32018-02-08 10:02:12 +01002031
Gilles Peskine89d8c5c2019-11-26 17:01:59 +01002032 psa_set_key_usage_flags( &attributes, PSA_KEY_USAGE_VERIFY_HASH );
Gilles Peskine2c2cf0e2019-04-19 19:58:20 +02002033 psa_set_key_algorithm( &attributes, alg );
2034 psa_set_key_type( &attributes, key_type );
mohammad16036df908f2018-04-02 08:34:15 -07002035
Ronald Cron5425a212020-08-04 14:58:35 +02002036 PSA_ASSERT( psa_import_key( &attributes, key_data->x, key_data->len,
2037 &key ) );
Gilles Peskinec0ec9722018-06-18 17:03:37 +02002038
Gilles Peskine29c4a6c2020-08-26 00:01:39 +02002039 /* Test the correct MAC. */
Ronald Cron5425a212020-08-04 14:58:35 +02002040 PSA_ASSERT( psa_mac_verify_setup( &operation, key, alg ) );
Gilles Peskine8817f612018-12-18 00:18:46 +01002041 PSA_ASSERT( psa_mac_update( &operation,
2042 input->x, input->len ) );
2043 PSA_ASSERT( psa_mac_verify_finish( &operation,
2044 expected_mac->x,
2045 expected_mac->len ) );
Gilles Peskine8c9def32018-02-08 10:02:12 +01002046
Gilles Peskine29c4a6c2020-08-26 00:01:39 +02002047 /* Test a MAC that's too short. */
Ronald Cron5425a212020-08-04 14:58:35 +02002048 PSA_ASSERT( psa_mac_verify_setup( &operation, key, alg ) );
Gilles Peskine29c4a6c2020-08-26 00:01:39 +02002049 PSA_ASSERT( psa_mac_update( &operation,
2050 input->x, input->len ) );
2051 TEST_EQUAL( psa_mac_verify_finish( &operation,
2052 expected_mac->x,
2053 expected_mac->len - 1 ),
2054 PSA_ERROR_INVALID_SIGNATURE );
2055
2056 /* Test a MAC that's too long. */
2057 ASSERT_ALLOC( perturbed_mac, expected_mac->len + 1 );
2058 memcpy( perturbed_mac, expected_mac->x, expected_mac->len );
Ronald Cron5425a212020-08-04 14:58:35 +02002059 PSA_ASSERT( psa_mac_verify_setup( &operation, key, alg ) );
Gilles Peskine29c4a6c2020-08-26 00:01:39 +02002060 PSA_ASSERT( psa_mac_update( &operation,
2061 input->x, input->len ) );
2062 TEST_EQUAL( psa_mac_verify_finish( &operation,
2063 perturbed_mac,
2064 expected_mac->len + 1 ),
2065 PSA_ERROR_INVALID_SIGNATURE );
2066
2067 /* Test changing one byte. */
2068 for( size_t i = 0; i < expected_mac->len; i++ )
2069 {
Chris Jones9634bb12021-01-20 15:56:42 +00002070 mbedtls_test_set_step( i );
Gilles Peskine29c4a6c2020-08-26 00:01:39 +02002071 perturbed_mac[i] ^= 1;
Ronald Cron5425a212020-08-04 14:58:35 +02002072 PSA_ASSERT( psa_mac_verify_setup( &operation, key, alg ) );
Gilles Peskine29c4a6c2020-08-26 00:01:39 +02002073 PSA_ASSERT( psa_mac_update( &operation,
2074 input->x, input->len ) );
2075 TEST_EQUAL( psa_mac_verify_finish( &operation,
2076 perturbed_mac,
2077 expected_mac->len ),
2078 PSA_ERROR_INVALID_SIGNATURE );
2079 perturbed_mac[i] ^= 1;
2080 }
2081
Gilles Peskine8c9def32018-02-08 10:02:12 +01002082exit:
Gilles Peskine64f13ef2020-08-25 23:15:20 +02002083 psa_mac_abort( &operation );
Ronald Cron5425a212020-08-04 14:58:35 +02002084 psa_destroy_key( key );
Gilles Peskine1153e7b2019-05-28 15:10:21 +02002085 PSA_DONE( );
Gilles Peskine29c4a6c2020-08-26 00:01:39 +02002086 mbedtls_free( perturbed_mac );
Gilles Peskine8c9def32018-02-08 10:02:12 +01002087}
2088/* END_CASE */
2089
2090/* BEGIN_CASE */
Jaeden Amero5bae2272019-01-04 11:48:27 +00002091void cipher_operation_init( )
2092{
Jaeden Ameroab439972019-02-15 14:12:05 +00002093 const uint8_t input[1] = { 0 };
2094 unsigned char output[1] = { 0 };
2095 size_t output_length;
Jaeden Amero5bae2272019-01-04 11:48:27 +00002096 /* Test each valid way of initializing the object, except for `= {0}`, as
2097 * Clang 5 complains when `-Wmissing-field-initializers` is used, even
2098 * though it's OK by the C standard. We could test for this, but we'd need
2099 * to supress the Clang warning for the test. */
2100 psa_cipher_operation_t func = psa_cipher_operation_init( );
2101 psa_cipher_operation_t init = PSA_CIPHER_OPERATION_INIT;
2102 psa_cipher_operation_t zero;
2103
2104 memset( &zero, 0, sizeof( zero ) );
2105
Jaeden Ameroab439972019-02-15 14:12:05 +00002106 /* A freshly-initialized cipher operation should not be usable. */
2107 TEST_EQUAL( psa_cipher_update( &func,
2108 input, sizeof( input ),
2109 output, sizeof( output ),
2110 &output_length ),
2111 PSA_ERROR_BAD_STATE );
2112 TEST_EQUAL( psa_cipher_update( &init,
2113 input, sizeof( input ),
2114 output, sizeof( output ),
2115 &output_length ),
2116 PSA_ERROR_BAD_STATE );
2117 TEST_EQUAL( psa_cipher_update( &zero,
2118 input, sizeof( input ),
2119 output, sizeof( output ),
2120 &output_length ),
2121 PSA_ERROR_BAD_STATE );
2122
Jaeden Amero5229bbb2019-02-07 16:33:37 +00002123 /* A default cipher operation should be abortable without error. */
2124 PSA_ASSERT( psa_cipher_abort( &func ) );
2125 PSA_ASSERT( psa_cipher_abort( &init ) );
2126 PSA_ASSERT( psa_cipher_abort( &zero ) );
Jaeden Amero5bae2272019-01-04 11:48:27 +00002127}
2128/* END_CASE */
2129
2130/* BEGIN_CASE */
Gilles Peskine16c0f4f2018-06-20 16:05:20 +02002131void cipher_setup( int key_type_arg,
2132 data_t *key,
2133 int alg_arg,
2134 int expected_status_arg )
2135{
Gilles Peskine16c0f4f2018-06-20 16:05:20 +02002136 psa_key_type_t key_type = key_type_arg;
2137 psa_algorithm_t alg = alg_arg;
Gilles Peskineb866e2b2018-06-21 09:25:10 +02002138 psa_status_t expected_status = expected_status_arg;
Jaeden Amero5bae2272019-01-04 11:48:27 +00002139 psa_cipher_operation_t operation = PSA_CIPHER_OPERATION_INIT;
Gilles Peskine16c0f4f2018-06-20 16:05:20 +02002140 psa_status_t status;
Gilles Peskine612ffd22021-01-20 18:51:00 +01002141#if defined(KNOWN_SUPPORTED_CIPHER_ALG)
Gilles Peskinef426e0f2019-02-25 17:42:03 +01002142 const uint8_t smoke_test_key_data[16] = "kkkkkkkkkkkkkkkk";
2143#endif
Gilles Peskine16c0f4f2018-06-20 16:05:20 +02002144
Gilles Peskine8817f612018-12-18 00:18:46 +01002145 PSA_ASSERT( psa_crypto_init( ) );
Gilles Peskine16c0f4f2018-06-20 16:05:20 +02002146
Gilles Peskinef426e0f2019-02-25 17:42:03 +01002147 if( ! exercise_cipher_setup( key_type, key->x, key->len, alg,
2148 &operation, &status ) )
2149 goto exit;
Gilles Peskinefe11b722018-12-18 00:24:04 +01002150 TEST_EQUAL( status, expected_status );
Gilles Peskine16c0f4f2018-06-20 16:05:20 +02002151
Gilles Peskinef426e0f2019-02-25 17:42:03 +01002152 /* The operation object should be reusable. */
2153#if defined(KNOWN_SUPPORTED_CIPHER_ALG)
2154 if( ! exercise_cipher_setup( KNOWN_SUPPORTED_CIPHER_KEY_TYPE,
2155 smoke_test_key_data,
2156 sizeof( smoke_test_key_data ),
2157 KNOWN_SUPPORTED_CIPHER_ALG,
2158 &operation, &status ) )
2159 goto exit;
2160 TEST_EQUAL( status, PSA_SUCCESS );
2161#endif
2162
Gilles Peskine16c0f4f2018-06-20 16:05:20 +02002163exit:
Gilles Peskine64f13ef2020-08-25 23:15:20 +02002164 psa_cipher_abort( &operation );
Gilles Peskine1153e7b2019-05-28 15:10:21 +02002165 PSA_DONE( );
Gilles Peskine16c0f4f2018-06-20 16:05:20 +02002166}
2167/* END_CASE */
2168
Ronald Cronee414c72021-03-18 18:50:08 +01002169/* BEGIN_CASE depends_on:PSA_WANT_KEY_TYPE_AES:PSA_WANT_ALG_CBC_PKCS7 */
Jaeden Ameroab439972019-02-15 14:12:05 +00002170void cipher_bad_order( )
2171{
Ronald Cron5425a212020-08-04 14:58:35 +02002172 mbedtls_svc_key_id_t key = MBEDTLS_SVC_KEY_ID_INIT;
Jaeden Ameroab439972019-02-15 14:12:05 +00002173 psa_key_type_t key_type = PSA_KEY_TYPE_AES;
2174 psa_algorithm_t alg = PSA_ALG_CBC_PKCS7;
Gilles Peskine2c2cf0e2019-04-19 19:58:20 +02002175 psa_key_attributes_t attributes = PSA_KEY_ATTRIBUTES_INIT;
Jaeden Ameroab439972019-02-15 14:12:05 +00002176 psa_cipher_operation_t operation = PSA_CIPHER_OPERATION_INIT;
gabor-mezei-armcbcec212020-12-18 14:23:51 +01002177 unsigned char iv[PSA_BLOCK_CIPHER_BLOCK_LENGTH(PSA_KEY_TYPE_AES)] = { 0 };
Ronald Cron5425a212020-08-04 14:58:35 +02002178 const uint8_t key_data[] = {
Jaeden Ameroab439972019-02-15 14:12:05 +00002179 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
2180 0xaa, 0xaa, 0xaa, 0xaa };
2181 const uint8_t text[] = {
2182 0xbb, 0xbb, 0xbb, 0xbb, 0xbb, 0xbb, 0xbb, 0xbb, 0xbb, 0xbb, 0xbb, 0xbb,
2183 0xbb, 0xbb, 0xbb, 0xbb };
gabor-mezei-armcbcec212020-12-18 14:23:51 +01002184 uint8_t buffer[PSA_BLOCK_CIPHER_BLOCK_LENGTH(PSA_KEY_TYPE_AES)] = { 0 };
Jaeden Ameroab439972019-02-15 14:12:05 +00002185 size_t length = 0;
2186
2187 PSA_ASSERT( psa_crypto_init( ) );
Gilles Peskine2c2cf0e2019-04-19 19:58:20 +02002188 psa_set_key_usage_flags( &attributes, PSA_KEY_USAGE_ENCRYPT | PSA_KEY_USAGE_DECRYPT );
2189 psa_set_key_algorithm( &attributes, alg );
2190 psa_set_key_type( &attributes, key_type );
Ronald Cron5425a212020-08-04 14:58:35 +02002191 PSA_ASSERT( psa_import_key( &attributes, key_data, sizeof( key_data ),
2192 &key ) );
Jaeden Ameroab439972019-02-15 14:12:05 +00002193
Jaeden Amero36ee5d02019-02-19 09:25:10 +00002194 /* Call encrypt setup twice in a row. */
Ronald Cron5425a212020-08-04 14:58:35 +02002195 PSA_ASSERT( psa_cipher_encrypt_setup( &operation, key, alg ) );
2196 TEST_EQUAL( psa_cipher_encrypt_setup( &operation, key, alg ),
Jaeden Amero36ee5d02019-02-19 09:25:10 +00002197 PSA_ERROR_BAD_STATE );
2198 PSA_ASSERT( psa_cipher_abort( &operation ) );
2199
2200 /* Call decrypt setup twice in a row. */
Ronald Cron5425a212020-08-04 14:58:35 +02002201 PSA_ASSERT( psa_cipher_decrypt_setup( &operation, key, alg ) );
2202 TEST_EQUAL( psa_cipher_decrypt_setup( &operation, key, alg ),
Jaeden Amero36ee5d02019-02-19 09:25:10 +00002203 PSA_ERROR_BAD_STATE );
2204 PSA_ASSERT( psa_cipher_abort( &operation ) );
2205
Jaeden Ameroab439972019-02-15 14:12:05 +00002206 /* Generate an IV without calling setup beforehand. */
2207 TEST_EQUAL( psa_cipher_generate_iv( &operation,
2208 buffer, sizeof( buffer ),
2209 &length ),
2210 PSA_ERROR_BAD_STATE );
2211 PSA_ASSERT( psa_cipher_abort( &operation ) );
2212
2213 /* Generate an IV twice in a row. */
Ronald Cron5425a212020-08-04 14:58:35 +02002214 PSA_ASSERT( psa_cipher_encrypt_setup( &operation, key, alg ) );
Jaeden Ameroab439972019-02-15 14:12:05 +00002215 PSA_ASSERT( psa_cipher_generate_iv( &operation,
2216 buffer, sizeof( buffer ),
2217 &length ) );
2218 TEST_EQUAL( psa_cipher_generate_iv( &operation,
2219 buffer, sizeof( buffer ),
2220 &length ),
2221 PSA_ERROR_BAD_STATE );
2222 PSA_ASSERT( psa_cipher_abort( &operation ) );
2223
2224 /* Generate an IV after it's already set. */
Ronald Cron5425a212020-08-04 14:58:35 +02002225 PSA_ASSERT( psa_cipher_encrypt_setup( &operation, key, alg ) );
Jaeden Ameroab439972019-02-15 14:12:05 +00002226 PSA_ASSERT( psa_cipher_set_iv( &operation,
2227 iv, sizeof( iv ) ) );
2228 TEST_EQUAL( psa_cipher_generate_iv( &operation,
2229 buffer, sizeof( buffer ),
2230 &length ),
2231 PSA_ERROR_BAD_STATE );
2232 PSA_ASSERT( psa_cipher_abort( &operation ) );
2233
2234 /* Set an IV without calling setup beforehand. */
2235 TEST_EQUAL( psa_cipher_set_iv( &operation,
2236 iv, sizeof( iv ) ),
2237 PSA_ERROR_BAD_STATE );
2238 PSA_ASSERT( psa_cipher_abort( &operation ) );
2239
2240 /* Set an IV after it's already set. */
Ronald Cron5425a212020-08-04 14:58:35 +02002241 PSA_ASSERT( psa_cipher_encrypt_setup( &operation, key, alg ) );
Jaeden Ameroab439972019-02-15 14:12:05 +00002242 PSA_ASSERT( psa_cipher_set_iv( &operation,
2243 iv, sizeof( iv ) ) );
2244 TEST_EQUAL( psa_cipher_set_iv( &operation,
2245 iv, sizeof( iv ) ),
2246 PSA_ERROR_BAD_STATE );
2247 PSA_ASSERT( psa_cipher_abort( &operation ) );
2248
2249 /* Set an IV after it's already generated. */
Ronald Cron5425a212020-08-04 14:58:35 +02002250 PSA_ASSERT( psa_cipher_encrypt_setup( &operation, key, alg ) );
Jaeden Ameroab439972019-02-15 14:12:05 +00002251 PSA_ASSERT( psa_cipher_generate_iv( &operation,
2252 buffer, sizeof( buffer ),
2253 &length ) );
2254 TEST_EQUAL( psa_cipher_set_iv( &operation,
2255 iv, sizeof( iv ) ),
2256 PSA_ERROR_BAD_STATE );
2257 PSA_ASSERT( psa_cipher_abort( &operation ) );
2258
2259 /* Call update without calling setup beforehand. */
2260 TEST_EQUAL( psa_cipher_update( &operation,
2261 text, sizeof( text ),
2262 buffer, sizeof( buffer ),
2263 &length ),
2264 PSA_ERROR_BAD_STATE );
2265 PSA_ASSERT( psa_cipher_abort( &operation ) );
2266
2267 /* Call update without an IV where an IV is required. */
2268 TEST_EQUAL( psa_cipher_update( &operation,
2269 text, sizeof( text ),
2270 buffer, sizeof( buffer ),
2271 &length ),
2272 PSA_ERROR_BAD_STATE );
2273 PSA_ASSERT( psa_cipher_abort( &operation ) );
2274
2275 /* Call update after finish. */
Ronald Cron5425a212020-08-04 14:58:35 +02002276 PSA_ASSERT( psa_cipher_encrypt_setup( &operation, key, alg ) );
Jaeden Ameroab439972019-02-15 14:12:05 +00002277 PSA_ASSERT( psa_cipher_set_iv( &operation,
2278 iv, sizeof( iv ) ) );
2279 PSA_ASSERT( psa_cipher_finish( &operation,
2280 buffer, sizeof( buffer ), &length ) );
2281 TEST_EQUAL( psa_cipher_update( &operation,
2282 text, sizeof( text ),
2283 buffer, sizeof( buffer ),
2284 &length ),
2285 PSA_ERROR_BAD_STATE );
2286 PSA_ASSERT( psa_cipher_abort( &operation ) );
2287
2288 /* Call finish without calling setup beforehand. */
2289 TEST_EQUAL( psa_cipher_finish( &operation,
2290 buffer, sizeof( buffer ), &length ),
2291 PSA_ERROR_BAD_STATE );
2292 PSA_ASSERT( psa_cipher_abort( &operation ) );
2293
2294 /* Call finish without an IV where an IV is required. */
Ronald Cron5425a212020-08-04 14:58:35 +02002295 PSA_ASSERT( psa_cipher_encrypt_setup( &operation, key, alg ) );
Jaeden Ameroab439972019-02-15 14:12:05 +00002296 /* Not calling update means we are encrypting an empty buffer, which is OK
2297 * for cipher modes with padding. */
2298 TEST_EQUAL( psa_cipher_finish( &operation,
2299 buffer, sizeof( buffer ), &length ),
2300 PSA_ERROR_BAD_STATE );
2301 PSA_ASSERT( psa_cipher_abort( &operation ) );
2302
2303 /* Call finish twice in a row. */
Ronald Cron5425a212020-08-04 14:58:35 +02002304 PSA_ASSERT( psa_cipher_encrypt_setup( &operation, key, alg ) );
Jaeden Ameroab439972019-02-15 14:12:05 +00002305 PSA_ASSERT( psa_cipher_set_iv( &operation,
2306 iv, sizeof( iv ) ) );
2307 PSA_ASSERT( psa_cipher_finish( &operation,
2308 buffer, sizeof( buffer ), &length ) );
2309 TEST_EQUAL( psa_cipher_finish( &operation,
2310 buffer, sizeof( buffer ), &length ),
2311 PSA_ERROR_BAD_STATE );
2312 PSA_ASSERT( psa_cipher_abort( &operation ) );
2313
Ronald Cron5425a212020-08-04 14:58:35 +02002314 PSA_ASSERT( psa_destroy_key( key ) );
Gilles Peskine76b29a72019-05-28 14:08:50 +02002315
Jaeden Ameroab439972019-02-15 14:12:05 +00002316exit:
Gilles Peskine64f13ef2020-08-25 23:15:20 +02002317 psa_cipher_abort( &operation );
Gilles Peskine1153e7b2019-05-28 15:10:21 +02002318 PSA_DONE( );
Gilles Peskine16c0f4f2018-06-20 16:05:20 +02002319}
2320/* END_CASE */
2321
2322/* BEGIN_CASE */
Gilles Peskine50e586b2018-06-08 14:28:46 +02002323void cipher_encrypt( int alg_arg, int key_type_arg,
Ronald Cron5425a212020-08-04 14:58:35 +02002324 data_t *key_data, data_t *iv,
itayzafrir3e02b3b2018-06-12 17:06:52 +03002325 data_t *input, data_t *expected_output,
Gilles Peskineb866e2b2018-06-21 09:25:10 +02002326 int expected_status_arg )
Gilles Peskine50e586b2018-06-08 14:28:46 +02002327{
Ronald Cron5425a212020-08-04 14:58:35 +02002328 mbedtls_svc_key_id_t key = MBEDTLS_SVC_KEY_ID_INIT;
Gilles Peskine50e586b2018-06-08 14:28:46 +02002329 psa_status_t status;
2330 psa_key_type_t key_type = key_type_arg;
2331 psa_algorithm_t alg = alg_arg;
Gilles Peskineb866e2b2018-06-21 09:25:10 +02002332 psa_status_t expected_status = expected_status_arg;
itayzafrir3e02b3b2018-06-12 17:06:52 +03002333 unsigned char *output = NULL;
Gilles Peskine50e586b2018-06-08 14:28:46 +02002334 size_t output_buffer_size = 0;
2335 size_t function_output_length = 0;
Gilles Peskinea7ec95f2018-06-08 14:40:59 +02002336 size_t total_output_length = 0;
Jaeden Amero5bae2272019-01-04 11:48:27 +00002337 psa_cipher_operation_t operation = PSA_CIPHER_OPERATION_INIT;
Gilles Peskine2c2cf0e2019-04-19 19:58:20 +02002338 psa_key_attributes_t attributes = PSA_KEY_ATTRIBUTES_INIT;
Gilles Peskine50e586b2018-06-08 14:28:46 +02002339
Gilles Peskine8817f612018-12-18 00:18:46 +01002340 PSA_ASSERT( psa_crypto_init( ) );
Gilles Peskine50e586b2018-06-08 14:28:46 +02002341
Gilles Peskine2c2cf0e2019-04-19 19:58:20 +02002342 psa_set_key_usage_flags( &attributes, PSA_KEY_USAGE_ENCRYPT );
2343 psa_set_key_algorithm( &attributes, alg );
2344 psa_set_key_type( &attributes, key_type );
Moran Pekered346952018-07-05 15:22:45 +03002345
Ronald Cron5425a212020-08-04 14:58:35 +02002346 PSA_ASSERT( psa_import_key( &attributes, key_data->x, key_data->len,
2347 &key ) );
Gilles Peskine50e586b2018-06-08 14:28:46 +02002348
Ronald Cron5425a212020-08-04 14:58:35 +02002349 PSA_ASSERT( psa_cipher_encrypt_setup( &operation, key, alg ) );
Gilles Peskine50e586b2018-06-08 14:28:46 +02002350
Steven Cooremaned3c9ec2020-07-06 14:08:59 +02002351 if( iv->len > 0 )
2352 {
Steven Cooremana6033e92020-08-25 11:47:50 +02002353 PSA_ASSERT( psa_cipher_set_iv( &operation, iv->x, iv->len ) );
Steven Cooremaned3c9ec2020-07-06 14:08:59 +02002354 }
2355
gabor-mezei-armceface22021-01-21 12:26:17 +01002356 output_buffer_size = PSA_CIPHER_ENCRYPT_OUTPUT_SIZE( key_type, alg, input->len );
2357 TEST_ASSERT( output_buffer_size <=
2358 PSA_CIPHER_ENCRYPT_OUTPUT_MAX_SIZE( input->len ) );
Gilles Peskine8cebbba2018-09-27 13:54:18 +02002359 ASSERT_ALLOC( output, output_buffer_size );
Gilles Peskine50e586b2018-06-08 14:28:46 +02002360
Gilles Peskine8817f612018-12-18 00:18:46 +01002361 PSA_ASSERT( psa_cipher_update( &operation,
2362 input->x, input->len,
2363 output, output_buffer_size,
2364 &function_output_length ) );
gabor-mezei-armceface22021-01-21 12:26:17 +01002365 TEST_ASSERT( function_output_length <=
2366 PSA_CIPHER_UPDATE_OUTPUT_SIZE( key_type, alg, input->len ) );
2367 TEST_ASSERT( function_output_length <=
2368 PSA_CIPHER_UPDATE_OUTPUT_MAX_SIZE( input->len ) );
Gilles Peskinea7ec95f2018-06-08 14:40:59 +02002369 total_output_length += function_output_length;
gabor-mezei-armceface22021-01-21 12:26:17 +01002370
Gilles Peskine50e586b2018-06-08 14:28:46 +02002371 status = psa_cipher_finish( &operation,
Gilles Peskine0c510f32021-03-24 00:41:51 +01002372 ( output_buffer_size == 0 ? NULL :
2373 output + total_output_length ),
Gilles Peskineee46fe72019-02-19 19:05:33 +01002374 output_buffer_size - total_output_length,
Gilles Peskine50e586b2018-06-08 14:28:46 +02002375 &function_output_length );
gabor-mezei-armceface22021-01-21 12:26:17 +01002376 TEST_ASSERT( function_output_length <=
2377 PSA_CIPHER_FINISH_OUTPUT_SIZE( key_type, alg ) );
2378 TEST_ASSERT( function_output_length <=
2379 PSA_CIPHER_FINISH_OUTPUT_MAX_SIZE );
Gilles Peskinea7ec95f2018-06-08 14:40:59 +02002380 total_output_length += function_output_length;
2381
Gilles Peskinefe11b722018-12-18 00:24:04 +01002382 TEST_EQUAL( status, expected_status );
Gilles Peskine50e586b2018-06-08 14:28:46 +02002383 if( expected_status == PSA_SUCCESS )
2384 {
Gilles Peskine8817f612018-12-18 00:18:46 +01002385 PSA_ASSERT( psa_cipher_abort( &operation ) );
Gilles Peskinebd7dea92018-09-27 13:57:19 +02002386 ASSERT_COMPARE( expected_output->x, expected_output->len,
2387 output, total_output_length );
Gilles Peskine50e586b2018-06-08 14:28:46 +02002388 }
Gilles Peskinea7ec95f2018-06-08 14:40:59 +02002389
Gilles Peskine50e586b2018-06-08 14:28:46 +02002390exit:
Gilles Peskine64f13ef2020-08-25 23:15:20 +02002391 psa_cipher_abort( &operation );
itayzafrir3e02b3b2018-06-12 17:06:52 +03002392 mbedtls_free( output );
Ronald Cron5425a212020-08-04 14:58:35 +02002393 psa_destroy_key( key );
Gilles Peskine1153e7b2019-05-28 15:10:21 +02002394 PSA_DONE( );
Gilles Peskine50e586b2018-06-08 14:28:46 +02002395}
2396/* END_CASE */
2397
2398/* BEGIN_CASE */
2399void cipher_encrypt_multipart( int alg_arg, int key_type_arg,
Ronald Cron5425a212020-08-04 14:58:35 +02002400 data_t *key_data, data_t *iv,
itayzafrir3e02b3b2018-06-12 17:06:52 +03002401 data_t *input,
Gilles Peskinee0866522019-02-19 19:44:00 +01002402 int first_part_size_arg,
2403 int output1_length_arg, int output2_length_arg,
itayzafrir3e02b3b2018-06-12 17:06:52 +03002404 data_t *expected_output )
Gilles Peskine50e586b2018-06-08 14:28:46 +02002405{
Ronald Cron5425a212020-08-04 14:58:35 +02002406 mbedtls_svc_key_id_t key = MBEDTLS_SVC_KEY_ID_INIT;
Gilles Peskine50e586b2018-06-08 14:28:46 +02002407 psa_key_type_t key_type = key_type_arg;
2408 psa_algorithm_t alg = alg_arg;
Gilles Peskinee0866522019-02-19 19:44:00 +01002409 size_t first_part_size = first_part_size_arg;
2410 size_t output1_length = output1_length_arg;
2411 size_t output2_length = output2_length_arg;
itayzafrir3e02b3b2018-06-12 17:06:52 +03002412 unsigned char *output = NULL;
Gilles Peskine50e586b2018-06-08 14:28:46 +02002413 size_t output_buffer_size = 0;
2414 size_t function_output_length = 0;
Gilles Peskinea7ec95f2018-06-08 14:40:59 +02002415 size_t total_output_length = 0;
Jaeden Amero5bae2272019-01-04 11:48:27 +00002416 psa_cipher_operation_t operation = PSA_CIPHER_OPERATION_INIT;
Gilles Peskine2c2cf0e2019-04-19 19:58:20 +02002417 psa_key_attributes_t attributes = PSA_KEY_ATTRIBUTES_INIT;
Gilles Peskine50e586b2018-06-08 14:28:46 +02002418
Gilles Peskine8817f612018-12-18 00:18:46 +01002419 PSA_ASSERT( psa_crypto_init( ) );
Gilles Peskine50e586b2018-06-08 14:28:46 +02002420
Gilles Peskine2c2cf0e2019-04-19 19:58:20 +02002421 psa_set_key_usage_flags( &attributes, PSA_KEY_USAGE_ENCRYPT );
2422 psa_set_key_algorithm( &attributes, alg );
2423 psa_set_key_type( &attributes, key_type );
Moran Pekered346952018-07-05 15:22:45 +03002424
Ronald Cron5425a212020-08-04 14:58:35 +02002425 PSA_ASSERT( psa_import_key( &attributes, key_data->x, key_data->len,
2426 &key ) );
Gilles Peskine50e586b2018-06-08 14:28:46 +02002427
Ronald Cron5425a212020-08-04 14:58:35 +02002428 PSA_ASSERT( psa_cipher_encrypt_setup( &operation, key, alg ) );
Gilles Peskine50e586b2018-06-08 14:28:46 +02002429
Steven Cooremaned3c9ec2020-07-06 14:08:59 +02002430 if( iv->len > 0 )
2431 {
Steven Cooremana6033e92020-08-25 11:47:50 +02002432 PSA_ASSERT( psa_cipher_set_iv( &operation, iv->x, iv->len ) );
Steven Cooremaned3c9ec2020-07-06 14:08:59 +02002433 }
2434
gabor-mezei-armceface22021-01-21 12:26:17 +01002435 output_buffer_size = PSA_CIPHER_ENCRYPT_OUTPUT_SIZE( key_type, alg, input->len );
2436 TEST_ASSERT( output_buffer_size <=
2437 PSA_CIPHER_ENCRYPT_OUTPUT_MAX_SIZE( input->len ) );
Gilles Peskine8cebbba2018-09-27 13:54:18 +02002438 ASSERT_ALLOC( output, output_buffer_size );
Gilles Peskine50e586b2018-06-08 14:28:46 +02002439
Gilles Peskinee0866522019-02-19 19:44:00 +01002440 TEST_ASSERT( first_part_size <= input->len );
Gilles Peskine8817f612018-12-18 00:18:46 +01002441 PSA_ASSERT( psa_cipher_update( &operation, input->x, first_part_size,
2442 output, output_buffer_size,
2443 &function_output_length ) );
Gilles Peskinee0866522019-02-19 19:44:00 +01002444 TEST_ASSERT( function_output_length == output1_length );
gabor-mezei-armceface22021-01-21 12:26:17 +01002445 TEST_ASSERT( function_output_length <=
2446 PSA_CIPHER_UPDATE_OUTPUT_SIZE( key_type, alg, first_part_size ) );
2447 TEST_ASSERT( function_output_length <=
2448 PSA_CIPHER_UPDATE_OUTPUT_MAX_SIZE( first_part_size) );
Gilles Peskinea7ec95f2018-06-08 14:40:59 +02002449 total_output_length += function_output_length;
gabor-mezei-armceface22021-01-21 12:26:17 +01002450
Gilles Peskine8817f612018-12-18 00:18:46 +01002451 PSA_ASSERT( psa_cipher_update( &operation,
2452 input->x + first_part_size,
2453 input->len - first_part_size,
Gilles Peskine0c510f32021-03-24 00:41:51 +01002454 ( output_buffer_size == 0 ? NULL :
2455 output + total_output_length ),
Gilles Peskineee46fe72019-02-19 19:05:33 +01002456 output_buffer_size - total_output_length,
Gilles Peskine8817f612018-12-18 00:18:46 +01002457 &function_output_length ) );
Gilles Peskinee0866522019-02-19 19:44:00 +01002458 TEST_ASSERT( function_output_length == output2_length );
gabor-mezei-armceface22021-01-21 12:26:17 +01002459 TEST_ASSERT( function_output_length <=
2460 PSA_CIPHER_UPDATE_OUTPUT_SIZE( key_type,
2461 alg,
2462 input->len - first_part_size ) );
2463 TEST_ASSERT( function_output_length <=
2464 PSA_CIPHER_UPDATE_OUTPUT_MAX_SIZE( input->len ) );
Gilles Peskinea7ec95f2018-06-08 14:40:59 +02002465 total_output_length += function_output_length;
gabor-mezei-armceface22021-01-21 12:26:17 +01002466
Gilles Peskine8817f612018-12-18 00:18:46 +01002467 PSA_ASSERT( psa_cipher_finish( &operation,
Gilles Peskine0c510f32021-03-24 00:41:51 +01002468 ( output_buffer_size == 0 ? NULL :
2469 output + total_output_length ),
Gilles Peskineee46fe72019-02-19 19:05:33 +01002470 output_buffer_size - total_output_length,
Gilles Peskine8817f612018-12-18 00:18:46 +01002471 &function_output_length ) );
gabor-mezei-armceface22021-01-21 12:26:17 +01002472 TEST_ASSERT( function_output_length <=
2473 PSA_CIPHER_FINISH_OUTPUT_SIZE( key_type, alg ) );
2474 TEST_ASSERT( function_output_length <=
2475 PSA_CIPHER_FINISH_OUTPUT_MAX_SIZE );
Gilles Peskinea7ec95f2018-06-08 14:40:59 +02002476 total_output_length += function_output_length;
Gilles Peskine8817f612018-12-18 00:18:46 +01002477 PSA_ASSERT( psa_cipher_abort( &operation ) );
Gilles Peskine50e586b2018-06-08 14:28:46 +02002478
Gilles Peskinebd7dea92018-09-27 13:57:19 +02002479 ASSERT_COMPARE( expected_output->x, expected_output->len,
2480 output, total_output_length );
Gilles Peskine50e586b2018-06-08 14:28:46 +02002481
2482exit:
Gilles Peskine64f13ef2020-08-25 23:15:20 +02002483 psa_cipher_abort( &operation );
itayzafrir3e02b3b2018-06-12 17:06:52 +03002484 mbedtls_free( output );
Ronald Cron5425a212020-08-04 14:58:35 +02002485 psa_destroy_key( key );
Gilles Peskine1153e7b2019-05-28 15:10:21 +02002486 PSA_DONE( );
Gilles Peskine50e586b2018-06-08 14:28:46 +02002487}
2488/* END_CASE */
2489
2490/* BEGIN_CASE */
2491void cipher_decrypt_multipart( int alg_arg, int key_type_arg,
Ronald Cron5425a212020-08-04 14:58:35 +02002492 data_t *key_data, data_t *iv,
itayzafrir3e02b3b2018-06-12 17:06:52 +03002493 data_t *input,
Gilles Peskinee0866522019-02-19 19:44:00 +01002494 int first_part_size_arg,
2495 int output1_length_arg, int output2_length_arg,
itayzafrir3e02b3b2018-06-12 17:06:52 +03002496 data_t *expected_output )
Gilles Peskine50e586b2018-06-08 14:28:46 +02002497{
Ronald Cron5425a212020-08-04 14:58:35 +02002498 mbedtls_svc_key_id_t key = MBEDTLS_SVC_KEY_ID_INIT;
Gilles Peskine50e586b2018-06-08 14:28:46 +02002499 psa_key_type_t key_type = key_type_arg;
2500 psa_algorithm_t alg = alg_arg;
Gilles Peskinee0866522019-02-19 19:44:00 +01002501 size_t first_part_size = first_part_size_arg;
2502 size_t output1_length = output1_length_arg;
2503 size_t output2_length = output2_length_arg;
itayzafrir3e02b3b2018-06-12 17:06:52 +03002504 unsigned char *output = NULL;
Gilles Peskine50e586b2018-06-08 14:28:46 +02002505 size_t output_buffer_size = 0;
2506 size_t function_output_length = 0;
Gilles Peskinea7ec95f2018-06-08 14:40:59 +02002507 size_t total_output_length = 0;
Jaeden Amero5bae2272019-01-04 11:48:27 +00002508 psa_cipher_operation_t operation = PSA_CIPHER_OPERATION_INIT;
Gilles Peskine2c2cf0e2019-04-19 19:58:20 +02002509 psa_key_attributes_t attributes = PSA_KEY_ATTRIBUTES_INIT;
Gilles Peskine50e586b2018-06-08 14:28:46 +02002510
Gilles Peskine8817f612018-12-18 00:18:46 +01002511 PSA_ASSERT( psa_crypto_init( ) );
Gilles Peskine50e586b2018-06-08 14:28:46 +02002512
Gilles Peskine2c2cf0e2019-04-19 19:58:20 +02002513 psa_set_key_usage_flags( &attributes, PSA_KEY_USAGE_DECRYPT );
2514 psa_set_key_algorithm( &attributes, alg );
2515 psa_set_key_type( &attributes, key_type );
Moran Pekered346952018-07-05 15:22:45 +03002516
Ronald Cron5425a212020-08-04 14:58:35 +02002517 PSA_ASSERT( psa_import_key( &attributes, key_data->x, key_data->len,
2518 &key ) );
Gilles Peskine50e586b2018-06-08 14:28:46 +02002519
Ronald Cron5425a212020-08-04 14:58:35 +02002520 PSA_ASSERT( psa_cipher_decrypt_setup( &operation, key, alg ) );
Gilles Peskine50e586b2018-06-08 14:28:46 +02002521
Steven Cooreman177deba2020-09-07 17:14:14 +02002522 if( iv->len > 0 )
2523 {
Steven Cooremana6033e92020-08-25 11:47:50 +02002524 PSA_ASSERT( psa_cipher_set_iv( &operation, iv->x, iv->len ) );
Steven Cooremaned3c9ec2020-07-06 14:08:59 +02002525 }
Gilles Peskine50e586b2018-06-08 14:28:46 +02002526
gabor-mezei-armceface22021-01-21 12:26:17 +01002527 output_buffer_size = PSA_CIPHER_DECRYPT_OUTPUT_SIZE( key_type, alg, input->len );
2528 TEST_ASSERT( output_buffer_size <=
2529 PSA_CIPHER_DECRYPT_OUTPUT_MAX_SIZE( input->len ) );
Gilles Peskine8cebbba2018-09-27 13:54:18 +02002530 ASSERT_ALLOC( output, output_buffer_size );
Gilles Peskine50e586b2018-06-08 14:28:46 +02002531
Gilles Peskinee0866522019-02-19 19:44:00 +01002532 TEST_ASSERT( first_part_size <= input->len );
Gilles Peskine8817f612018-12-18 00:18:46 +01002533 PSA_ASSERT( psa_cipher_update( &operation,
2534 input->x, first_part_size,
2535 output, output_buffer_size,
2536 &function_output_length ) );
Gilles Peskinee0866522019-02-19 19:44:00 +01002537 TEST_ASSERT( function_output_length == output1_length );
gabor-mezei-armceface22021-01-21 12:26:17 +01002538 TEST_ASSERT( function_output_length <=
2539 PSA_CIPHER_UPDATE_OUTPUT_SIZE( key_type, alg, first_part_size ) );
2540 TEST_ASSERT( function_output_length <=
2541 PSA_CIPHER_UPDATE_OUTPUT_MAX_SIZE( first_part_size ) );
Gilles Peskinea7ec95f2018-06-08 14:40:59 +02002542 total_output_length += function_output_length;
gabor-mezei-armceface22021-01-21 12:26:17 +01002543
Gilles Peskine8817f612018-12-18 00:18:46 +01002544 PSA_ASSERT( psa_cipher_update( &operation,
2545 input->x + first_part_size,
2546 input->len - first_part_size,
Gilles Peskine0c510f32021-03-24 00:41:51 +01002547 ( output_buffer_size == 0 ? NULL :
2548 output + total_output_length ),
Gilles Peskineee46fe72019-02-19 19:05:33 +01002549 output_buffer_size - total_output_length,
Gilles Peskine8817f612018-12-18 00:18:46 +01002550 &function_output_length ) );
Gilles Peskinee0866522019-02-19 19:44:00 +01002551 TEST_ASSERT( function_output_length == output2_length );
gabor-mezei-armceface22021-01-21 12:26:17 +01002552 TEST_ASSERT( function_output_length <=
2553 PSA_CIPHER_UPDATE_OUTPUT_SIZE( key_type,
2554 alg,
2555 input->len - first_part_size ) );
2556 TEST_ASSERT( function_output_length <=
2557 PSA_CIPHER_UPDATE_OUTPUT_MAX_SIZE( input->len ) );
Gilles Peskinea7ec95f2018-06-08 14:40:59 +02002558 total_output_length += function_output_length;
gabor-mezei-armceface22021-01-21 12:26:17 +01002559
Gilles Peskine8817f612018-12-18 00:18:46 +01002560 PSA_ASSERT( psa_cipher_finish( &operation,
Gilles Peskine0c510f32021-03-24 00:41:51 +01002561 ( output_buffer_size == 0 ? NULL :
2562 output + total_output_length ),
Gilles Peskineee46fe72019-02-19 19:05:33 +01002563 output_buffer_size - total_output_length,
Gilles Peskine8817f612018-12-18 00:18:46 +01002564 &function_output_length ) );
gabor-mezei-armceface22021-01-21 12:26:17 +01002565 TEST_ASSERT( function_output_length <=
2566 PSA_CIPHER_FINISH_OUTPUT_SIZE( key_type, alg ) );
2567 TEST_ASSERT( function_output_length <=
2568 PSA_CIPHER_FINISH_OUTPUT_MAX_SIZE );
Gilles Peskinea7ec95f2018-06-08 14:40:59 +02002569 total_output_length += function_output_length;
Gilles Peskine8817f612018-12-18 00:18:46 +01002570 PSA_ASSERT( psa_cipher_abort( &operation ) );
Gilles Peskine50e586b2018-06-08 14:28:46 +02002571
Gilles Peskinebd7dea92018-09-27 13:57:19 +02002572 ASSERT_COMPARE( expected_output->x, expected_output->len,
2573 output, total_output_length );
Gilles Peskine50e586b2018-06-08 14:28:46 +02002574
2575exit:
Gilles Peskine64f13ef2020-08-25 23:15:20 +02002576 psa_cipher_abort( &operation );
itayzafrir3e02b3b2018-06-12 17:06:52 +03002577 mbedtls_free( output );
Ronald Cron5425a212020-08-04 14:58:35 +02002578 psa_destroy_key( key );
Gilles Peskine1153e7b2019-05-28 15:10:21 +02002579 PSA_DONE( );
Gilles Peskine50e586b2018-06-08 14:28:46 +02002580}
2581/* END_CASE */
2582
Gilles Peskine50e586b2018-06-08 14:28:46 +02002583/* BEGIN_CASE */
2584void cipher_decrypt( int alg_arg, int key_type_arg,
Ronald Cron5425a212020-08-04 14:58:35 +02002585 data_t *key_data, data_t *iv,
itayzafrir3e02b3b2018-06-12 17:06:52 +03002586 data_t *input, data_t *expected_output,
Gilles Peskineb866e2b2018-06-21 09:25:10 +02002587 int expected_status_arg )
Gilles Peskine50e586b2018-06-08 14:28:46 +02002588{
Ronald Cron5425a212020-08-04 14:58:35 +02002589 mbedtls_svc_key_id_t key = MBEDTLS_SVC_KEY_ID_INIT;
Gilles Peskine50e586b2018-06-08 14:28:46 +02002590 psa_status_t status;
2591 psa_key_type_t key_type = key_type_arg;
2592 psa_algorithm_t alg = alg_arg;
Gilles Peskineb866e2b2018-06-21 09:25:10 +02002593 psa_status_t expected_status = expected_status_arg;
itayzafrir3e02b3b2018-06-12 17:06:52 +03002594 unsigned char *output = NULL;
Gilles Peskine50e586b2018-06-08 14:28:46 +02002595 size_t output_buffer_size = 0;
2596 size_t function_output_length = 0;
Gilles Peskinea7ec95f2018-06-08 14:40:59 +02002597 size_t total_output_length = 0;
Jaeden Amero5bae2272019-01-04 11:48:27 +00002598 psa_cipher_operation_t operation = PSA_CIPHER_OPERATION_INIT;
Gilles Peskine2c2cf0e2019-04-19 19:58:20 +02002599 psa_key_attributes_t attributes = PSA_KEY_ATTRIBUTES_INIT;
Gilles Peskine50e586b2018-06-08 14:28:46 +02002600
Gilles Peskine8817f612018-12-18 00:18:46 +01002601 PSA_ASSERT( psa_crypto_init( ) );
Gilles Peskine50e586b2018-06-08 14:28:46 +02002602
Gilles Peskine2c2cf0e2019-04-19 19:58:20 +02002603 psa_set_key_usage_flags( &attributes, PSA_KEY_USAGE_DECRYPT );
2604 psa_set_key_algorithm( &attributes, alg );
2605 psa_set_key_type( &attributes, key_type );
Moran Pekered346952018-07-05 15:22:45 +03002606
Ronald Cron5425a212020-08-04 14:58:35 +02002607 PSA_ASSERT( psa_import_key( &attributes, key_data->x, key_data->len,
2608 &key ) );
Gilles Peskine50e586b2018-06-08 14:28:46 +02002609
Ronald Cron5425a212020-08-04 14:58:35 +02002610 PSA_ASSERT( psa_cipher_decrypt_setup( &operation, key, alg ) );
Gilles Peskine50e586b2018-06-08 14:28:46 +02002611
Steven Cooreman177deba2020-09-07 17:14:14 +02002612 if( iv->len > 0 )
2613 {
Steven Cooremana6033e92020-08-25 11:47:50 +02002614 PSA_ASSERT( psa_cipher_set_iv( &operation, iv->x, iv->len ) );
Steven Cooremaned3c9ec2020-07-06 14:08:59 +02002615 }
Gilles Peskine50e586b2018-06-08 14:28:46 +02002616
gabor-mezei-armceface22021-01-21 12:26:17 +01002617 output_buffer_size = PSA_CIPHER_DECRYPT_OUTPUT_SIZE( key_type, alg, input->len );
2618 TEST_ASSERT( output_buffer_size <=
2619 PSA_CIPHER_DECRYPT_OUTPUT_MAX_SIZE( input->len ) );
Gilles Peskine8cebbba2018-09-27 13:54:18 +02002620 ASSERT_ALLOC( output, output_buffer_size );
Gilles Peskine50e586b2018-06-08 14:28:46 +02002621
Gilles Peskine8817f612018-12-18 00:18:46 +01002622 PSA_ASSERT( psa_cipher_update( &operation,
2623 input->x, input->len,
2624 output, output_buffer_size,
2625 &function_output_length ) );
gabor-mezei-armceface22021-01-21 12:26:17 +01002626 TEST_ASSERT( function_output_length <=
2627 PSA_CIPHER_UPDATE_OUTPUT_SIZE( key_type, alg, input->len ) );
2628 TEST_ASSERT( function_output_length <=
2629 PSA_CIPHER_UPDATE_OUTPUT_MAX_SIZE( input->len ) );
Gilles Peskinea7ec95f2018-06-08 14:40:59 +02002630 total_output_length += function_output_length;
gabor-mezei-armceface22021-01-21 12:26:17 +01002631
Gilles Peskine50e586b2018-06-08 14:28:46 +02002632 status = psa_cipher_finish( &operation,
Gilles Peskine0c510f32021-03-24 00:41:51 +01002633 ( output_buffer_size == 0 ? NULL :
2634 output + total_output_length ),
Gilles Peskineee46fe72019-02-19 19:05:33 +01002635 output_buffer_size - total_output_length,
Gilles Peskine50e586b2018-06-08 14:28:46 +02002636 &function_output_length );
gabor-mezei-armceface22021-01-21 12:26:17 +01002637 TEST_ASSERT( function_output_length <=
2638 PSA_CIPHER_FINISH_OUTPUT_SIZE( key_type, alg ) );
2639 TEST_ASSERT( function_output_length <=
2640 PSA_CIPHER_FINISH_OUTPUT_MAX_SIZE );
Gilles Peskinea7ec95f2018-06-08 14:40:59 +02002641 total_output_length += function_output_length;
Gilles Peskinefe11b722018-12-18 00:24:04 +01002642 TEST_EQUAL( status, expected_status );
Gilles Peskine50e586b2018-06-08 14:28:46 +02002643
2644 if( expected_status == PSA_SUCCESS )
2645 {
Gilles Peskine8817f612018-12-18 00:18:46 +01002646 PSA_ASSERT( psa_cipher_abort( &operation ) );
Gilles Peskinebd7dea92018-09-27 13:57:19 +02002647 ASSERT_COMPARE( expected_output->x, expected_output->len,
2648 output, total_output_length );
Gilles Peskine50e586b2018-06-08 14:28:46 +02002649 }
2650
Gilles Peskine50e586b2018-06-08 14:28:46 +02002651exit:
Gilles Peskine64f13ef2020-08-25 23:15:20 +02002652 psa_cipher_abort( &operation );
itayzafrir3e02b3b2018-06-12 17:06:52 +03002653 mbedtls_free( output );
Ronald Cron5425a212020-08-04 14:58:35 +02002654 psa_destroy_key( key );
Gilles Peskine1153e7b2019-05-28 15:10:21 +02002655 PSA_DONE( );
Gilles Peskine50e586b2018-06-08 14:28:46 +02002656}
2657/* END_CASE */
2658
Gilles Peskine50e586b2018-06-08 14:28:46 +02002659/* BEGIN_CASE */
2660void cipher_verify_output( int alg_arg, int key_type_arg,
Ronald Cron5425a212020-08-04 14:58:35 +02002661 data_t *key_data,
itayzafrir3e02b3b2018-06-12 17:06:52 +03002662 data_t *input )
mohammad1603d7d7ba52018-03-12 18:51:53 +02002663{
Ronald Cron5425a212020-08-04 14:58:35 +02002664 mbedtls_svc_key_id_t key = MBEDTLS_SVC_KEY_ID_INIT;
mohammad1603d7d7ba52018-03-12 18:51:53 +02002665 psa_key_type_t key_type = key_type_arg;
2666 psa_algorithm_t alg = alg_arg;
mohammad1603e6b67a12018-03-12 10:38:49 -07002667 unsigned char iv[16] = {0};
mohammad1603d7d7ba52018-03-12 18:51:53 +02002668 size_t iv_size = 16;
2669 size_t iv_length = 0;
itayzafrir3e02b3b2018-06-12 17:06:52 +03002670 unsigned char *output1 = NULL;
mohammad1603d7d7ba52018-03-12 18:51:53 +02002671 size_t output1_size = 0;
2672 size_t output1_length = 0;
itayzafrir3e02b3b2018-06-12 17:06:52 +03002673 unsigned char *output2 = NULL;
mohammad1603d7d7ba52018-03-12 18:51:53 +02002674 size_t output2_size = 0;
2675 size_t output2_length = 0;
Gilles Peskine048b7f02018-06-08 14:20:49 +02002676 size_t function_output_length = 0;
Jaeden Amero5bae2272019-01-04 11:48:27 +00002677 psa_cipher_operation_t operation1 = PSA_CIPHER_OPERATION_INIT;
2678 psa_cipher_operation_t operation2 = PSA_CIPHER_OPERATION_INIT;
Gilles Peskine2c2cf0e2019-04-19 19:58:20 +02002679 psa_key_attributes_t attributes = PSA_KEY_ATTRIBUTES_INIT;
mohammad1603d7d7ba52018-03-12 18:51:53 +02002680
Gilles Peskine8817f612018-12-18 00:18:46 +01002681 PSA_ASSERT( psa_crypto_init( ) );
mohammad1603d7d7ba52018-03-12 18:51:53 +02002682
Gilles Peskine2c2cf0e2019-04-19 19:58:20 +02002683 psa_set_key_usage_flags( &attributes, PSA_KEY_USAGE_ENCRYPT | PSA_KEY_USAGE_DECRYPT );
2684 psa_set_key_algorithm( &attributes, alg );
2685 psa_set_key_type( &attributes, key_type );
Moran Pekered346952018-07-05 15:22:45 +03002686
Ronald Cron5425a212020-08-04 14:58:35 +02002687 PSA_ASSERT( psa_import_key( &attributes, key_data->x, key_data->len,
2688 &key ) );
mohammad1603d7d7ba52018-03-12 18:51:53 +02002689
Ronald Cron5425a212020-08-04 14:58:35 +02002690 PSA_ASSERT( psa_cipher_encrypt_setup( &operation1, key, alg ) );
2691 PSA_ASSERT( psa_cipher_decrypt_setup( &operation2, key, alg ) );
mohammad1603d7d7ba52018-03-12 18:51:53 +02002692
Steven Cooreman177deba2020-09-07 17:14:14 +02002693 if( alg != PSA_ALG_ECB_NO_PADDING )
2694 {
Steven Cooremana6033e92020-08-25 11:47:50 +02002695 PSA_ASSERT( psa_cipher_generate_iv( &operation1,
2696 iv, iv_size,
2697 &iv_length ) );
Steven Cooremaned3c9ec2020-07-06 14:08:59 +02002698 }
gabor-mezei-armceface22021-01-21 12:26:17 +01002699 output1_size = PSA_CIPHER_ENCRYPT_OUTPUT_SIZE( key_type, alg, input->len );
2700 TEST_ASSERT( output1_size <=
2701 PSA_CIPHER_ENCRYPT_OUTPUT_MAX_SIZE( input->len ) );
Gilles Peskine8cebbba2018-09-27 13:54:18 +02002702 ASSERT_ALLOC( output1, output1_size );
Moran Pekerded84402018-06-06 16:36:50 +03002703
Gilles Peskine8817f612018-12-18 00:18:46 +01002704 PSA_ASSERT( psa_cipher_update( &operation1, input->x, input->len,
2705 output1, output1_size,
2706 &output1_length ) );
gabor-mezei-armceface22021-01-21 12:26:17 +01002707 TEST_ASSERT( output1_length <=
2708 PSA_CIPHER_UPDATE_OUTPUT_SIZE( key_type, alg, input->len ) );
2709 TEST_ASSERT( output1_length <=
2710 PSA_CIPHER_UPDATE_OUTPUT_MAX_SIZE( input->len ) );
2711
Gilles Peskine8817f612018-12-18 00:18:46 +01002712 PSA_ASSERT( psa_cipher_finish( &operation1,
Gilles Peskineee46fe72019-02-19 19:05:33 +01002713 output1 + output1_length,
2714 output1_size - output1_length,
Gilles Peskine8817f612018-12-18 00:18:46 +01002715 &function_output_length ) );
gabor-mezei-armceface22021-01-21 12:26:17 +01002716 TEST_ASSERT( function_output_length <=
2717 PSA_CIPHER_FINISH_OUTPUT_SIZE( key_type, alg ) );
2718 TEST_ASSERT( function_output_length <=
2719 PSA_CIPHER_FINISH_OUTPUT_MAX_SIZE );
Gilles Peskine4ca9c3f2018-06-06 18:44:09 +02002720
Gilles Peskine048b7f02018-06-08 14:20:49 +02002721 output1_length += function_output_length;
Moran Pekerded84402018-06-06 16:36:50 +03002722
Gilles Peskine8817f612018-12-18 00:18:46 +01002723 PSA_ASSERT( psa_cipher_abort( &operation1 ) );
Moran Pekerded84402018-06-06 16:36:50 +03002724
2725 output2_size = output1_length;
gabor-mezei-armceface22021-01-21 12:26:17 +01002726 TEST_ASSERT( output2_size <=
2727 PSA_CIPHER_DECRYPT_OUTPUT_SIZE( key_type, alg, output1_length ) );
2728 TEST_ASSERT( output2_size <=
2729 PSA_CIPHER_DECRYPT_OUTPUT_MAX_SIZE( output1_length ) );
Gilles Peskine8cebbba2018-09-27 13:54:18 +02002730 ASSERT_ALLOC( output2, output2_size );
Moran Pekerded84402018-06-06 16:36:50 +03002731
Steven Cooreman177deba2020-09-07 17:14:14 +02002732 if( iv_length > 0 )
2733 {
Steven Cooremana6033e92020-08-25 11:47:50 +02002734 PSA_ASSERT( psa_cipher_set_iv( &operation2,
2735 iv, iv_length ) );
Steven Cooremaned3c9ec2020-07-06 14:08:59 +02002736 }
2737
Gilles Peskine8817f612018-12-18 00:18:46 +01002738 PSA_ASSERT( psa_cipher_update( &operation2, output1, output1_length,
2739 output2, output2_size,
2740 &output2_length ) );
gabor-mezei-armceface22021-01-21 12:26:17 +01002741 TEST_ASSERT( output2_length <=
2742 PSA_CIPHER_UPDATE_OUTPUT_SIZE( key_type, alg, output1_length ) );
2743 TEST_ASSERT( output2_length <=
2744 PSA_CIPHER_UPDATE_OUTPUT_MAX_SIZE( output1_length ) );
2745
Gilles Peskine048b7f02018-06-08 14:20:49 +02002746 function_output_length = 0;
Gilles Peskine8817f612018-12-18 00:18:46 +01002747 PSA_ASSERT( psa_cipher_finish( &operation2,
2748 output2 + output2_length,
Gilles Peskineee46fe72019-02-19 19:05:33 +01002749 output2_size - output2_length,
Gilles Peskine8817f612018-12-18 00:18:46 +01002750 &function_output_length ) );
gabor-mezei-armceface22021-01-21 12:26:17 +01002751 TEST_ASSERT( function_output_length <=
2752 PSA_CIPHER_FINISH_OUTPUT_SIZE( key_type, alg ) );
2753 TEST_ASSERT( function_output_length <=
2754 PSA_CIPHER_FINISH_OUTPUT_MAX_SIZE );
Moran Pekerded84402018-06-06 16:36:50 +03002755
Gilles Peskine048b7f02018-06-08 14:20:49 +02002756 output2_length += function_output_length;
Gilles Peskine4ca9c3f2018-06-06 18:44:09 +02002757
Gilles Peskine8817f612018-12-18 00:18:46 +01002758 PSA_ASSERT( psa_cipher_abort( &operation2 ) );
Moran Pekerded84402018-06-06 16:36:50 +03002759
Gilles Peskinebd7dea92018-09-27 13:57:19 +02002760 ASSERT_COMPARE( input->x, input->len, output2, output2_length );
Moran Pekerded84402018-06-06 16:36:50 +03002761
2762exit:
Gilles Peskine64f13ef2020-08-25 23:15:20 +02002763 psa_cipher_abort( &operation1 );
2764 psa_cipher_abort( &operation2 );
itayzafrir3e02b3b2018-06-12 17:06:52 +03002765 mbedtls_free( output1 );
2766 mbedtls_free( output2 );
Ronald Cron5425a212020-08-04 14:58:35 +02002767 psa_destroy_key( key );
Gilles Peskine1153e7b2019-05-28 15:10:21 +02002768 PSA_DONE( );
Moran Pekerded84402018-06-06 16:36:50 +03002769}
2770/* END_CASE */
2771
2772/* BEGIN_CASE */
Gilles Peskine50e586b2018-06-08 14:28:46 +02002773void cipher_verify_output_multipart( int alg_arg,
2774 int key_type_arg,
Ronald Cron5425a212020-08-04 14:58:35 +02002775 data_t *key_data,
itayzafrir3e02b3b2018-06-12 17:06:52 +03002776 data_t *input,
Gilles Peskinee0866522019-02-19 19:44:00 +01002777 int first_part_size_arg )
Moran Pekerded84402018-06-06 16:36:50 +03002778{
Ronald Cron5425a212020-08-04 14:58:35 +02002779 mbedtls_svc_key_id_t key = MBEDTLS_SVC_KEY_ID_INIT;
Moran Pekerded84402018-06-06 16:36:50 +03002780 psa_key_type_t key_type = key_type_arg;
2781 psa_algorithm_t alg = alg_arg;
Gilles Peskinee0866522019-02-19 19:44:00 +01002782 size_t first_part_size = first_part_size_arg;
Moran Pekerded84402018-06-06 16:36:50 +03002783 unsigned char iv[16] = {0};
2784 size_t iv_size = 16;
2785 size_t iv_length = 0;
itayzafrir3e02b3b2018-06-12 17:06:52 +03002786 unsigned char *output1 = NULL;
Gilles Peskine048b7f02018-06-08 14:20:49 +02002787 size_t output1_buffer_size = 0;
Moran Pekerded84402018-06-06 16:36:50 +03002788 size_t output1_length = 0;
itayzafrir3e02b3b2018-06-12 17:06:52 +03002789 unsigned char *output2 = NULL;
Gilles Peskine048b7f02018-06-08 14:20:49 +02002790 size_t output2_buffer_size = 0;
Moran Pekerded84402018-06-06 16:36:50 +03002791 size_t output2_length = 0;
Gilles Peskine048b7f02018-06-08 14:20:49 +02002792 size_t function_output_length;
Jaeden Amero5bae2272019-01-04 11:48:27 +00002793 psa_cipher_operation_t operation1 = PSA_CIPHER_OPERATION_INIT;
2794 psa_cipher_operation_t operation2 = PSA_CIPHER_OPERATION_INIT;
Gilles Peskine2c2cf0e2019-04-19 19:58:20 +02002795 psa_key_attributes_t attributes = PSA_KEY_ATTRIBUTES_INIT;
Moran Pekerded84402018-06-06 16:36:50 +03002796
Gilles Peskine8817f612018-12-18 00:18:46 +01002797 PSA_ASSERT( psa_crypto_init( ) );
Moran Pekerded84402018-06-06 16:36:50 +03002798
Gilles Peskine2c2cf0e2019-04-19 19:58:20 +02002799 psa_set_key_usage_flags( &attributes, PSA_KEY_USAGE_ENCRYPT | PSA_KEY_USAGE_DECRYPT );
2800 psa_set_key_algorithm( &attributes, alg );
2801 psa_set_key_type( &attributes, key_type );
Moran Pekered346952018-07-05 15:22:45 +03002802
Ronald Cron5425a212020-08-04 14:58:35 +02002803 PSA_ASSERT( psa_import_key( &attributes, key_data->x, key_data->len,
2804 &key ) );
Moran Pekerded84402018-06-06 16:36:50 +03002805
Ronald Cron5425a212020-08-04 14:58:35 +02002806 PSA_ASSERT( psa_cipher_encrypt_setup( &operation1, key, alg ) );
2807 PSA_ASSERT( psa_cipher_decrypt_setup( &operation2, key, alg ) );
Moran Pekerded84402018-06-06 16:36:50 +03002808
Steven Cooreman177deba2020-09-07 17:14:14 +02002809 if( alg != PSA_ALG_ECB_NO_PADDING )
2810 {
Steven Cooremana6033e92020-08-25 11:47:50 +02002811 PSA_ASSERT( psa_cipher_generate_iv( &operation1,
2812 iv, iv_size,
2813 &iv_length ) );
Steven Cooremaned3c9ec2020-07-06 14:08:59 +02002814 }
2815
gabor-mezei-armceface22021-01-21 12:26:17 +01002816 output1_buffer_size = PSA_CIPHER_ENCRYPT_OUTPUT_SIZE( key_type, alg, input->len );
2817 TEST_ASSERT( output1_buffer_size <=
2818 PSA_CIPHER_ENCRYPT_OUTPUT_MAX_SIZE( input->len ) );
Gilles Peskine8cebbba2018-09-27 13:54:18 +02002819 ASSERT_ALLOC( output1, output1_buffer_size );
Moran Pekerded84402018-06-06 16:36:50 +03002820
Gilles Peskinee0866522019-02-19 19:44:00 +01002821 TEST_ASSERT( first_part_size <= input->len );
Gilles Peskine4ca9c3f2018-06-06 18:44:09 +02002822
Gilles Peskine8817f612018-12-18 00:18:46 +01002823 PSA_ASSERT( psa_cipher_update( &operation1, input->x, first_part_size,
2824 output1, output1_buffer_size,
2825 &function_output_length ) );
gabor-mezei-armceface22021-01-21 12:26:17 +01002826 TEST_ASSERT( function_output_length <=
2827 PSA_CIPHER_UPDATE_OUTPUT_SIZE( key_type, alg, first_part_size ) );
2828 TEST_ASSERT( function_output_length <=
2829 PSA_CIPHER_UPDATE_OUTPUT_MAX_SIZE( first_part_size ) );
Gilles Peskine048b7f02018-06-08 14:20:49 +02002830 output1_length += function_output_length;
Moran Pekerded84402018-06-06 16:36:50 +03002831
Gilles Peskine8817f612018-12-18 00:18:46 +01002832 PSA_ASSERT( psa_cipher_update( &operation1,
2833 input->x + first_part_size,
2834 input->len - first_part_size,
2835 output1, output1_buffer_size,
2836 &function_output_length ) );
gabor-mezei-armceface22021-01-21 12:26:17 +01002837 TEST_ASSERT( function_output_length <=
2838 PSA_CIPHER_UPDATE_OUTPUT_SIZE( key_type,
2839 alg,
2840 input->len - first_part_size ) );
2841 TEST_ASSERT( function_output_length <=
2842 PSA_CIPHER_UPDATE_OUTPUT_MAX_SIZE( input->len - first_part_size ) );
Gilles Peskine048b7f02018-06-08 14:20:49 +02002843 output1_length += function_output_length;
Moran Pekerded84402018-06-06 16:36:50 +03002844
Gilles Peskine8817f612018-12-18 00:18:46 +01002845 PSA_ASSERT( psa_cipher_finish( &operation1,
2846 output1 + output1_length,
2847 output1_buffer_size - output1_length,
2848 &function_output_length ) );
gabor-mezei-armceface22021-01-21 12:26:17 +01002849 TEST_ASSERT( function_output_length <=
2850 PSA_CIPHER_FINISH_OUTPUT_SIZE( key_type, alg ) );
2851 TEST_ASSERT( function_output_length <=
2852 PSA_CIPHER_FINISH_OUTPUT_MAX_SIZE );
Gilles Peskine048b7f02018-06-08 14:20:49 +02002853 output1_length += function_output_length;
mohammad1603d7d7ba52018-03-12 18:51:53 +02002854
Gilles Peskine8817f612018-12-18 00:18:46 +01002855 PSA_ASSERT( psa_cipher_abort( &operation1 ) );
mohammad1603d7d7ba52018-03-12 18:51:53 +02002856
Gilles Peskine048b7f02018-06-08 14:20:49 +02002857 output2_buffer_size = output1_length;
gabor-mezei-armceface22021-01-21 12:26:17 +01002858 TEST_ASSERT( output2_buffer_size <=
2859 PSA_CIPHER_DECRYPT_OUTPUT_SIZE( key_type, alg, output1_length ) );
2860 TEST_ASSERT( output2_buffer_size <=
2861 PSA_CIPHER_DECRYPT_OUTPUT_MAX_SIZE( output1_length ) );
Gilles Peskine8cebbba2018-09-27 13:54:18 +02002862 ASSERT_ALLOC( output2, output2_buffer_size );
mohammad1603d7d7ba52018-03-12 18:51:53 +02002863
Steven Cooreman177deba2020-09-07 17:14:14 +02002864 if( iv_length > 0 )
2865 {
Steven Cooremana6033e92020-08-25 11:47:50 +02002866 PSA_ASSERT( psa_cipher_set_iv( &operation2,
2867 iv, iv_length ) );
Steven Cooremaned3c9ec2020-07-06 14:08:59 +02002868 }
Moran Pekerded84402018-06-06 16:36:50 +03002869
Gilles Peskine8817f612018-12-18 00:18:46 +01002870 PSA_ASSERT( psa_cipher_update( &operation2, output1, first_part_size,
2871 output2, output2_buffer_size,
2872 &function_output_length ) );
gabor-mezei-armceface22021-01-21 12:26:17 +01002873 TEST_ASSERT( function_output_length <=
2874 PSA_CIPHER_UPDATE_OUTPUT_SIZE( key_type, alg, first_part_size ) );
2875 TEST_ASSERT( function_output_length <=
2876 PSA_CIPHER_UPDATE_OUTPUT_MAX_SIZE( first_part_size ) );
Gilles Peskine048b7f02018-06-08 14:20:49 +02002877 output2_length += function_output_length;
Moran Pekerded84402018-06-06 16:36:50 +03002878
Gilles Peskine8817f612018-12-18 00:18:46 +01002879 PSA_ASSERT( psa_cipher_update( &operation2,
2880 output1 + first_part_size,
2881 output1_length - first_part_size,
2882 output2, output2_buffer_size,
2883 &function_output_length ) );
gabor-mezei-armceface22021-01-21 12:26:17 +01002884 TEST_ASSERT( function_output_length <=
2885 PSA_CIPHER_UPDATE_OUTPUT_SIZE( key_type,
2886 alg,
2887 output1_length - first_part_size ) );
2888 TEST_ASSERT( function_output_length <=
2889 PSA_CIPHER_UPDATE_OUTPUT_MAX_SIZE( output1_length - first_part_size ) );
Gilles Peskine048b7f02018-06-08 14:20:49 +02002890 output2_length += function_output_length;
Moran Pekerded84402018-06-06 16:36:50 +03002891
Gilles Peskine8817f612018-12-18 00:18:46 +01002892 PSA_ASSERT( psa_cipher_finish( &operation2,
2893 output2 + output2_length,
2894 output2_buffer_size - output2_length,
2895 &function_output_length ) );
gabor-mezei-armceface22021-01-21 12:26:17 +01002896 TEST_ASSERT( function_output_length <=
2897 PSA_CIPHER_FINISH_OUTPUT_SIZE( key_type, alg ) );
2898 TEST_ASSERT( function_output_length <=
2899 PSA_CIPHER_FINISH_OUTPUT_MAX_SIZE );
Gilles Peskine048b7f02018-06-08 14:20:49 +02002900 output2_length += function_output_length;
Gilles Peskine4ca9c3f2018-06-06 18:44:09 +02002901
Gilles Peskine8817f612018-12-18 00:18:46 +01002902 PSA_ASSERT( psa_cipher_abort( &operation2 ) );
mohammad1603d7d7ba52018-03-12 18:51:53 +02002903
Gilles Peskinebd7dea92018-09-27 13:57:19 +02002904 ASSERT_COMPARE( input->x, input->len, output2, output2_length );
mohammad1603d7d7ba52018-03-12 18:51:53 +02002905
2906exit:
Gilles Peskine64f13ef2020-08-25 23:15:20 +02002907 psa_cipher_abort( &operation1 );
2908 psa_cipher_abort( &operation2 );
itayzafrir3e02b3b2018-06-12 17:06:52 +03002909 mbedtls_free( output1 );
2910 mbedtls_free( output2 );
Ronald Cron5425a212020-08-04 14:58:35 +02002911 psa_destroy_key( key );
Gilles Peskine1153e7b2019-05-28 15:10:21 +02002912 PSA_DONE( );
mohammad1603d7d7ba52018-03-12 18:51:53 +02002913}
2914/* END_CASE */
Gilles Peskine7268afc2018-06-06 15:19:24 +02002915
Gilles Peskine20035e32018-02-03 22:44:14 +01002916/* BEGIN_CASE */
Gilles Peskine7da96b02018-08-17 18:45:42 +02002917void aead_encrypt_decrypt( int key_type_arg, data_t *key_data,
Gilles Peskinec1bb6c82018-06-18 16:04:39 +02002918 int alg_arg,
Gilles Peskine7da96b02018-08-17 18:45:42 +02002919 data_t *nonce,
2920 data_t *additional_data,
2921 data_t *input_data,
Gilles Peskinec1bb6c82018-06-18 16:04:39 +02002922 int expected_result_arg )
Gilles Peskinea1cac842018-06-11 19:33:02 +02002923{
Ronald Cron5425a212020-08-04 14:58:35 +02002924 mbedtls_svc_key_id_t key = MBEDTLS_SVC_KEY_ID_INIT;
Gilles Peskinea1cac842018-06-11 19:33:02 +02002925 psa_key_type_t key_type = key_type_arg;
2926 psa_algorithm_t alg = alg_arg;
Bence Szépkútiec174e22021-03-19 18:46:15 +01002927 size_t key_bits;
Gilles Peskinea1cac842018-06-11 19:33:02 +02002928 unsigned char *output_data = NULL;
2929 size_t output_size = 0;
2930 size_t output_length = 0;
2931 unsigned char *output_data2 = NULL;
2932 size_t output_length2 = 0;
Steven Cooremanf49478b2021-02-15 15:19:25 +01002933 psa_status_t status = PSA_ERROR_GENERIC_ERROR;
Gilles Peskine4abf7412018-06-18 16:35:34 +02002934 psa_status_t expected_result = expected_result_arg;
Gilles Peskine2c2cf0e2019-04-19 19:58:20 +02002935 psa_key_attributes_t attributes = PSA_KEY_ATTRIBUTES_INIT;
Gilles Peskinea1cac842018-06-11 19:33:02 +02002936
Gilles Peskine8817f612018-12-18 00:18:46 +01002937 PSA_ASSERT( psa_crypto_init( ) );
Gilles Peskinea1cac842018-06-11 19:33:02 +02002938
Gilles Peskine2c2cf0e2019-04-19 19:58:20 +02002939 psa_set_key_usage_flags( &attributes, PSA_KEY_USAGE_ENCRYPT | PSA_KEY_USAGE_DECRYPT );
2940 psa_set_key_algorithm( &attributes, alg );
2941 psa_set_key_type( &attributes, key_type );
Gilles Peskinea1cac842018-06-11 19:33:02 +02002942
Gilles Peskine049c7532019-05-15 20:22:09 +02002943 PSA_ASSERT( psa_import_key( &attributes, key_data->x, key_data->len,
Ronald Cron5425a212020-08-04 14:58:35 +02002944 &key ) );
Bence Szépkútiec174e22021-03-19 18:46:15 +01002945 PSA_ASSERT( psa_get_key_attributes( key, &attributes ) );
2946 key_bits = psa_get_key_bits( &attributes );
2947
2948 output_size = input_data->len + PSA_AEAD_TAG_LENGTH( key_type, key_bits,
2949 alg );
2950 /* For all currently defined algorithms, PSA_AEAD_ENCRYPT_OUTPUT_SIZE
2951 * should be exact. */
2952 if( expected_result != PSA_ERROR_INVALID_ARGUMENT &&
2953 expected_result != PSA_ERROR_NOT_SUPPORTED )
2954 {
2955 TEST_EQUAL( output_size,
2956 PSA_AEAD_ENCRYPT_OUTPUT_SIZE( key_type, alg, input_data->len ) );
2957 TEST_ASSERT( output_size <=
2958 PSA_AEAD_ENCRYPT_OUTPUT_MAX_SIZE( input_data->len ) );
2959 }
2960 ASSERT_ALLOC( output_data, output_size );
Gilles Peskinea1cac842018-06-11 19:33:02 +02002961
Steven Cooremanf49478b2021-02-15 15:19:25 +01002962 status = psa_aead_encrypt( key, alg,
2963 nonce->x, nonce->len,
2964 additional_data->x,
2965 additional_data->len,
2966 input_data->x, input_data->len,
2967 output_data, output_size,
2968 &output_length );
2969
2970 /* If the operation is not supported, just skip and not fail in case the
2971 * encryption involves a common limitation of cryptography hardwares and
2972 * an alternative implementation. */
2973 if( status == PSA_ERROR_NOT_SUPPORTED )
2974 {
2975 MBEDTLS_TEST_PSA_SKIP_IF_ALT_AES_192( key_type, key_data->len * 8 );
2976 MBEDTLS_TEST_PSA_SKIP_IF_ALT_GCM_NOT_12BYTES_NONCE( alg, nonce->len );
2977 }
2978
2979 TEST_EQUAL( status, expected_result );
Gilles Peskinea1cac842018-06-11 19:33:02 +02002980
2981 if( PSA_SUCCESS == expected_result )
2982 {
Gilles Peskine8cebbba2018-09-27 13:54:18 +02002983 ASSERT_ALLOC( output_data2, output_length );
Gilles Peskinea1cac842018-06-11 19:33:02 +02002984
Gilles Peskine003a4a92019-05-14 16:09:40 +02002985 /* For all currently defined algorithms, PSA_AEAD_DECRYPT_OUTPUT_SIZE
2986 * should be exact. */
2987 TEST_EQUAL( input_data->len,
Bence Szépkútiec174e22021-03-19 18:46:15 +01002988 PSA_AEAD_DECRYPT_OUTPUT_SIZE( key_type, alg, output_length ) );
Gilles Peskine003a4a92019-05-14 16:09:40 +02002989
gabor-mezei-armceface22021-01-21 12:26:17 +01002990 TEST_ASSERT( input_data->len <=
2991 PSA_AEAD_DECRYPT_OUTPUT_MAX_SIZE( output_length ) );
2992
Ronald Cron5425a212020-08-04 14:58:35 +02002993 TEST_EQUAL( psa_aead_decrypt( key, alg,
Gilles Peskinefe11b722018-12-18 00:24:04 +01002994 nonce->x, nonce->len,
2995 additional_data->x,
2996 additional_data->len,
2997 output_data, output_length,
2998 output_data2, output_length,
Gilles Peskinef812dcf2018-12-18 00:33:25 +01002999 &output_length2 ),
3000 expected_result );
Gilles Peskine2d277862018-06-18 15:41:12 +02003001
Gilles Peskinebd7dea92018-09-27 13:57:19 +02003002 ASSERT_COMPARE( input_data->x, input_data->len,
3003 output_data2, output_length2 );
Gilles Peskinea1cac842018-06-11 19:33:02 +02003004 }
Gilles Peskine2d277862018-06-18 15:41:12 +02003005
Gilles Peskinea1cac842018-06-11 19:33:02 +02003006exit:
Ronald Cron5425a212020-08-04 14:58:35 +02003007 psa_destroy_key( key );
Gilles Peskinea1cac842018-06-11 19:33:02 +02003008 mbedtls_free( output_data );
3009 mbedtls_free( output_data2 );
Gilles Peskine1153e7b2019-05-28 15:10:21 +02003010 PSA_DONE( );
Gilles Peskinea1cac842018-06-11 19:33:02 +02003011}
3012/* END_CASE */
3013
3014/* BEGIN_CASE */
Gilles Peskine7da96b02018-08-17 18:45:42 +02003015void aead_encrypt( int key_type_arg, data_t *key_data,
3016 int alg_arg,
3017 data_t *nonce,
3018 data_t *additional_data,
3019 data_t *input_data,
3020 data_t *expected_result )
Gilles Peskinea1cac842018-06-11 19:33:02 +02003021{
Ronald Cron5425a212020-08-04 14:58:35 +02003022 mbedtls_svc_key_id_t key = MBEDTLS_SVC_KEY_ID_INIT;
Gilles Peskinea1cac842018-06-11 19:33:02 +02003023 psa_key_type_t key_type = key_type_arg;
3024 psa_algorithm_t alg = alg_arg;
Bence Szépkútiec174e22021-03-19 18:46:15 +01003025 size_t key_bits;
Gilles Peskinea1cac842018-06-11 19:33:02 +02003026 unsigned char *output_data = NULL;
3027 size_t output_size = 0;
3028 size_t output_length = 0;
Gilles Peskine2c2cf0e2019-04-19 19:58:20 +02003029 psa_key_attributes_t attributes = PSA_KEY_ATTRIBUTES_INIT;
Steven Cooremand588ea12021-01-11 19:36:04 +01003030 psa_status_t status = PSA_ERROR_GENERIC_ERROR;
Gilles Peskinea1cac842018-06-11 19:33:02 +02003031
Gilles Peskine8817f612018-12-18 00:18:46 +01003032 PSA_ASSERT( psa_crypto_init( ) );
Gilles Peskinea1cac842018-06-11 19:33:02 +02003033
Gilles Peskine2c2cf0e2019-04-19 19:58:20 +02003034 psa_set_key_usage_flags( &attributes, PSA_KEY_USAGE_ENCRYPT );
3035 psa_set_key_algorithm( &attributes, alg );
3036 psa_set_key_type( &attributes, key_type );
Gilles Peskinea1cac842018-06-11 19:33:02 +02003037
Gilles Peskine049c7532019-05-15 20:22:09 +02003038 PSA_ASSERT( psa_import_key( &attributes, key_data->x, key_data->len,
Ronald Cron5425a212020-08-04 14:58:35 +02003039 &key ) );
Bence Szépkútiec174e22021-03-19 18:46:15 +01003040 PSA_ASSERT( psa_get_key_attributes( key, &attributes ) );
3041 key_bits = psa_get_key_bits( &attributes );
3042
3043 output_size = input_data->len + PSA_AEAD_TAG_LENGTH( key_type, key_bits,
3044 alg );
3045 /* For all currently defined algorithms, PSA_AEAD_ENCRYPT_OUTPUT_SIZE
3046 * should be exact. */
3047 TEST_EQUAL( output_size,
3048 PSA_AEAD_ENCRYPT_OUTPUT_SIZE( key_type, alg, input_data->len ) );
3049 TEST_ASSERT( output_size <=
3050 PSA_AEAD_ENCRYPT_OUTPUT_MAX_SIZE( input_data->len ) );
3051 ASSERT_ALLOC( output_data, output_size );
Gilles Peskinea1cac842018-06-11 19:33:02 +02003052
Steven Cooremand588ea12021-01-11 19:36:04 +01003053 status = psa_aead_encrypt( key, alg,
3054 nonce->x, nonce->len,
3055 additional_data->x, additional_data->len,
3056 input_data->x, input_data->len,
3057 output_data, output_size,
3058 &output_length );
Gilles Peskinea1cac842018-06-11 19:33:02 +02003059
Ronald Cron28a45ed2021-02-09 20:35:42 +01003060 /* If the operation is not supported, just skip and not fail in case the
3061 * encryption involves a common limitation of cryptography hardwares and
3062 * an alternative implementation. */
3063 if( status == PSA_ERROR_NOT_SUPPORTED )
Steven Cooremand588ea12021-01-11 19:36:04 +01003064 {
Ronald Cron28a45ed2021-02-09 20:35:42 +01003065 MBEDTLS_TEST_PSA_SKIP_IF_ALT_AES_192( key_type, key_data->len * 8 );
3066 MBEDTLS_TEST_PSA_SKIP_IF_ALT_GCM_NOT_12BYTES_NONCE( alg, nonce->len );
Steven Cooremand588ea12021-01-11 19:36:04 +01003067 }
Steven Cooremand588ea12021-01-11 19:36:04 +01003068
3069 PSA_ASSERT( status );
Gilles Peskinebd7dea92018-09-27 13:57:19 +02003070 ASSERT_COMPARE( expected_result->x, expected_result->len,
3071 output_data, output_length );
Gilles Peskine2d277862018-06-18 15:41:12 +02003072
Gilles Peskinea1cac842018-06-11 19:33:02 +02003073exit:
Ronald Cron5425a212020-08-04 14:58:35 +02003074 psa_destroy_key( key );
Gilles Peskinea1cac842018-06-11 19:33:02 +02003075 mbedtls_free( output_data );
Gilles Peskine1153e7b2019-05-28 15:10:21 +02003076 PSA_DONE( );
Gilles Peskinea1cac842018-06-11 19:33:02 +02003077}
3078/* END_CASE */
3079
3080/* BEGIN_CASE */
Gilles Peskine7da96b02018-08-17 18:45:42 +02003081void aead_decrypt( int key_type_arg, data_t *key_data,
3082 int alg_arg,
3083 data_t *nonce,
3084 data_t *additional_data,
3085 data_t *input_data,
3086 data_t *expected_data,
3087 int expected_result_arg )
Gilles Peskinea1cac842018-06-11 19:33:02 +02003088{
Ronald Cron5425a212020-08-04 14:58:35 +02003089 mbedtls_svc_key_id_t key = MBEDTLS_SVC_KEY_ID_INIT;
Gilles Peskinea1cac842018-06-11 19:33:02 +02003090 psa_key_type_t key_type = key_type_arg;
3091 psa_algorithm_t alg = alg_arg;
Bence Szépkútiec174e22021-03-19 18:46:15 +01003092 size_t key_bits;
Gilles Peskinea1cac842018-06-11 19:33:02 +02003093 unsigned char *output_data = NULL;
3094 size_t output_size = 0;
3095 size_t output_length = 0;
Gilles Peskine2c2cf0e2019-04-19 19:58:20 +02003096 psa_key_attributes_t attributes = PSA_KEY_ATTRIBUTES_INIT;
Gilles Peskine4abf7412018-06-18 16:35:34 +02003097 psa_status_t expected_result = expected_result_arg;
Steven Cooremand588ea12021-01-11 19:36:04 +01003098 psa_status_t status = PSA_ERROR_GENERIC_ERROR;
Gilles Peskinea1cac842018-06-11 19:33:02 +02003099
Gilles Peskine8817f612018-12-18 00:18:46 +01003100 PSA_ASSERT( psa_crypto_init( ) );
Gilles Peskinea1cac842018-06-11 19:33:02 +02003101
Gilles Peskine2c2cf0e2019-04-19 19:58:20 +02003102 psa_set_key_usage_flags( &attributes, PSA_KEY_USAGE_DECRYPT );
3103 psa_set_key_algorithm( &attributes, alg );
3104 psa_set_key_type( &attributes, key_type );
Gilles Peskinea1cac842018-06-11 19:33:02 +02003105
Gilles Peskine049c7532019-05-15 20:22:09 +02003106 PSA_ASSERT( psa_import_key( &attributes, key_data->x, key_data->len,
Ronald Cron5425a212020-08-04 14:58:35 +02003107 &key ) );
Bence Szépkútiec174e22021-03-19 18:46:15 +01003108 PSA_ASSERT( psa_get_key_attributes( key, &attributes ) );
3109 key_bits = psa_get_key_bits( &attributes );
3110
3111 output_size = input_data->len - PSA_AEAD_TAG_LENGTH( key_type, key_bits,
3112 alg );
3113 if( expected_result != PSA_ERROR_INVALID_ARGUMENT &&
3114 expected_result != PSA_ERROR_NOT_SUPPORTED )
3115 {
3116 /* For all currently defined algorithms, PSA_AEAD_DECRYPT_OUTPUT_SIZE
3117 * should be exact. */
3118 TEST_EQUAL( output_size,
3119 PSA_AEAD_DECRYPT_OUTPUT_SIZE( key_type, alg, input_data->len ) );
3120 TEST_ASSERT( output_size <=
3121 PSA_AEAD_DECRYPT_OUTPUT_MAX_SIZE( input_data->len ) );
3122 }
3123 ASSERT_ALLOC( output_data, output_size );
Gilles Peskinea1cac842018-06-11 19:33:02 +02003124
Steven Cooremand588ea12021-01-11 19:36:04 +01003125 status = psa_aead_decrypt( key, alg,
3126 nonce->x, nonce->len,
3127 additional_data->x,
3128 additional_data->len,
3129 input_data->x, input_data->len,
3130 output_data, output_size,
3131 &output_length );
3132
Ronald Cron28a45ed2021-02-09 20:35:42 +01003133 /* If the operation is not supported, just skip and not fail in case the
3134 * decryption involves a common limitation of cryptography hardwares and
3135 * an alternative implementation. */
3136 if( status == PSA_ERROR_NOT_SUPPORTED )
Steven Cooremand588ea12021-01-11 19:36:04 +01003137 {
Ronald Cron28a45ed2021-02-09 20:35:42 +01003138 MBEDTLS_TEST_PSA_SKIP_IF_ALT_AES_192( key_type, key_data->len * 8 );
3139 MBEDTLS_TEST_PSA_SKIP_IF_ALT_GCM_NOT_12BYTES_NONCE( alg, nonce->len );
Steven Cooremand588ea12021-01-11 19:36:04 +01003140 }
Steven Cooremand588ea12021-01-11 19:36:04 +01003141
3142 TEST_EQUAL( status, expected_result );
Gilles Peskinea1cac842018-06-11 19:33:02 +02003143
Gilles Peskine2d277862018-06-18 15:41:12 +02003144 if( expected_result == PSA_SUCCESS )
Gilles Peskinebd7dea92018-09-27 13:57:19 +02003145 ASSERT_COMPARE( expected_data->x, expected_data->len,
3146 output_data, output_length );
Gilles Peskinea1cac842018-06-11 19:33:02 +02003147
Gilles Peskinea1cac842018-06-11 19:33:02 +02003148exit:
Ronald Cron5425a212020-08-04 14:58:35 +02003149 psa_destroy_key( key );
Gilles Peskinea1cac842018-06-11 19:33:02 +02003150 mbedtls_free( output_data );
Gilles Peskine1153e7b2019-05-28 15:10:21 +02003151 PSA_DONE( );
Gilles Peskinea1cac842018-06-11 19:33:02 +02003152}
3153/* END_CASE */
3154
3155/* BEGIN_CASE */
Paul Elliott0023e0a2021-04-27 10:06:22 +01003156void aead_multipart_encrypt( int key_type_arg, data_t *key_data,
3157 int alg_arg,
3158 data_t *nonce,
3159 data_t *additional_data,
3160 int ad_part_len,
3161 data_t *input_data,
3162 int data_part_len,
3163 data_t *expected_result )
3164{
3165 mbedtls_svc_key_id_t key = MBEDTLS_SVC_KEY_ID_INIT;
3166 psa_key_type_t key_type = key_type_arg;
3167 psa_algorithm_t alg = alg_arg;
3168 psa_aead_operation_t operation;
3169 unsigned char *output_data = NULL;
3170 unsigned char *part_data = NULL;
3171 unsigned char *final_data = NULL;
3172 size_t output_size = 0;
3173 size_t part_data_size = 0;
3174 size_t output_length = 0;
3175 size_t key_bits = 0;
3176 size_t tag_length = 0;
3177 size_t tag_size = 0;
3178 size_t nonce_length = 0;
3179 uint8_t nonce_buffer[16];
3180 uint8_t tag_buffer[16];
3181 uint32_t part_offset = 0;
3182 size_t part_length = 0;
3183 size_t output_part_length = 0;
3184 psa_key_attributes_t attributes = PSA_KEY_ATTRIBUTES_INIT;
3185 psa_status_t status = PSA_ERROR_GENERIC_ERROR;
3186
3187 PSA_ASSERT( psa_crypto_init( ) );
3188
3189 psa_set_key_usage_flags( &attributes, PSA_KEY_USAGE_ENCRYPT );
3190 psa_set_key_algorithm( &attributes, alg );
3191 psa_set_key_type( &attributes, key_type );
3192
3193 PSA_ASSERT( psa_import_key( &attributes, key_data->x, key_data->len,
3194 &key ) );
3195
3196 PSA_ASSERT( psa_get_key_attributes( key, &attributes ) );
3197 key_bits = psa_get_key_bits( &attributes );
3198
3199 tag_length = PSA_AEAD_TAG_LENGTH( key_type, key_bits, alg );
3200
3201 TEST_ASSERT( tag_length <= 16 );
3202
3203 output_size = PSA_AEAD_UPDATE_OUTPUT_SIZE( key_type, alg,
Paul Elliott2df40052021-05-07 17:52:18 +01003204 ( input_data->len +
3205 tag_length ) );
Paul Elliott0023e0a2021-04-27 10:06:22 +01003206
3207 ASSERT_ALLOC( output_data, output_size );
3208
3209 ASSERT_ALLOC( final_data, PSA_AEAD_FINISH_OUTPUT_MAX_SIZE );
3210
3211 operation = psa_aead_operation_init();
3212
3213 status = psa_aead_encrypt_setup( &operation, key, alg );
3214
3215 /* If the operation is not supported, just skip and not fail in case the
3216 * encryption involves a common limitation of cryptography hardwares and
3217 * an alternative implementation. */
3218 if( status == PSA_ERROR_NOT_SUPPORTED )
3219 {
3220 MBEDTLS_TEST_PSA_SKIP_IF_ALT_AES_192( key_type, key_data->len * 8 );
3221 MBEDTLS_TEST_PSA_SKIP_IF_ALT_GCM_NOT_12BYTES_NONCE( alg, nonce->len );
3222 }
3223
3224 PSA_ASSERT( status );
3225
3226 if( nonce->len == 0 )
3227 {
Paul Elliott2df40052021-05-07 17:52:18 +01003228 PSA_ASSERT( psa_aead_generate_nonce( &operation, nonce_buffer,
3229 sizeof( nonce_buffer ),
3230 &nonce_length ) );
Paul Elliott0023e0a2021-04-27 10:06:22 +01003231 }
3232 else
3233 {
3234 nonce_length = nonce->len;
3235 PSA_ASSERT( psa_aead_set_nonce( &operation, nonce->x, nonce->len ) );
3236 }
3237
3238#if defined(MBEDTLS_PSA_BUILTIN_ALG_GCM)
3239 if( operation.alg == PSA_ALG_GCM )
3240 {
Paul Elliott2df40052021-05-07 17:52:18 +01003241 PSA_ASSERT( psa_aead_set_lengths( &operation, additional_data->len,
3242 input_data->len ) );
Paul Elliott0023e0a2021-04-27 10:06:22 +01003243 }
3244#endif
3245
3246 if( ad_part_len != -1 )
3247 {
3248 /* Pass addtional data in parts */
3249 part_offset = 0;
3250
3251 while( part_offset <= additional_data->len)
3252 {
3253 if( additional_data->len - part_offset < ( uint32_t ) ad_part_len )
3254 {
3255 part_length = additional_data->len - part_offset;
3256 }
3257 else
3258 {
3259 part_length = ad_part_len;
3260 }
3261
Paul Elliott2df40052021-05-07 17:52:18 +01003262 PSA_ASSERT( psa_aead_update_ad( &operation,
3263 additional_data->x + part_offset,
Paul Elliott0023e0a2021-04-27 10:06:22 +01003264 part_length ) );
3265
3266 part_offset += part_length;
3267 }
3268 }
3269 else
3270 {
3271 /* Pass additional data in one go. */
Paul Elliott2df40052021-05-07 17:52:18 +01003272 PSA_ASSERT( psa_aead_update_ad(&operation, additional_data->x,
3273 additional_data->len) );
Paul Elliott0023e0a2021-04-27 10:06:22 +01003274 }
3275
3276 if( data_part_len != -1 )
3277 {
3278 /* Pass data in parts */
Paul Elliott2df40052021-05-07 17:52:18 +01003279 part_data_size = PSA_AEAD_UPDATE_OUTPUT_SIZE( key_type, alg,
3280 ( size_t ) data_part_len );
Paul Elliott0023e0a2021-04-27 10:06:22 +01003281
3282 ASSERT_ALLOC( part_data, part_data_size );
3283
3284 part_offset = 0;
3285
3286 while( part_offset <= input_data->len)
3287 {
3288 if( input_data->len - part_offset < ( uint32_t ) data_part_len )
3289 {
3290 part_length = input_data->len - part_offset;
3291 }
3292 else
3293 {
3294 part_length = data_part_len;
3295 }
3296
Paul Elliott2df40052021-05-07 17:52:18 +01003297 PSA_ASSERT( psa_aead_update( &operation,
3298 ( input_data->x + part_offset ),
Paul Elliott0023e0a2021-04-27 10:06:22 +01003299 part_length, part_data,
Paul Elliott2df40052021-05-07 17:52:18 +01003300 part_data_size,
3301 &output_part_length ) );
Paul Elliott0023e0a2021-04-27 10:06:22 +01003302
Paul Elliottac3c2002021-04-27 19:10:18 +01003303 if( output_data && output_part_length )
3304 {
Paul Elliott2df40052021-05-07 17:52:18 +01003305 memcpy( ( output_data + part_offset ), part_data,
3306 output_part_length );
Paul Elliottac3c2002021-04-27 19:10:18 +01003307 }
Paul Elliott0023e0a2021-04-27 10:06:22 +01003308
3309 part_offset += part_length;
3310 output_length += output_part_length;
3311 }
3312 }
3313 else
3314 {
3315 /* Pass whole data in one go */
3316 PSA_ASSERT( psa_aead_update( &operation, input_data->x,
3317 input_data->len, output_data,
3318 output_size, &output_length ) );
3319 }
3320
3321 PSA_ASSERT( psa_aead_finish( &operation, final_data,
3322 PSA_AEAD_FINISH_OUTPUT_MAX_SIZE,
3323 &output_part_length,
3324 tag_buffer, tag_length,
3325 &tag_size ) );
3326
Paul Elliottac3c2002021-04-27 19:10:18 +01003327 if( output_data && output_part_length )
3328 {
Paul Elliott2df40052021-05-07 17:52:18 +01003329 memcpy( ( output_data + output_length ), final_data,
3330 output_part_length );
Paul Elliottac3c2002021-04-27 19:10:18 +01003331 }
Paul Elliott0023e0a2021-04-27 10:06:22 +01003332
3333 TEST_EQUAL(tag_length, tag_size);
3334
3335 output_length += output_part_length;
3336
Paul Elliottac3c2002021-04-27 19:10:18 +01003337 if( output_data && tag_length )
3338 {
3339 memcpy( ( output_data + output_length ), tag_buffer, tag_length );
3340 }
Paul Elliott0023e0a2021-04-27 10:06:22 +01003341
3342 output_length += tag_length;
3343
3344 /* For all currently defined algorithms, PSA_AEAD_ENCRYPT_OUTPUT_SIZE
3345 * should be exact. */
3346 TEST_EQUAL( output_length,
Paul Elliott2df40052021-05-07 17:52:18 +01003347 PSA_AEAD_ENCRYPT_OUTPUT_SIZE( key_type, alg,
3348 input_data->len ) );
Paul Elliott0023e0a2021-04-27 10:06:22 +01003349 TEST_ASSERT( output_length <=
3350 PSA_AEAD_ENCRYPT_OUTPUT_MAX_SIZE( input_data->len ) );
3351
3352 ASSERT_COMPARE( expected_result->x, expected_result->len,
3353 output_data, output_length );
3354
3355exit:
3356 psa_destroy_key( key );
Paul Elliott16e6dcd2021-04-28 13:27:39 +01003357 psa_aead_abort( &operation );
Paul Elliott0023e0a2021-04-27 10:06:22 +01003358 mbedtls_free( output_data );
3359 mbedtls_free( part_data );
3360 mbedtls_free( final_data );
3361 PSA_DONE( );
3362}
3363/* END_CASE */
3364
3365/* BEGIN_CASE */
3366void aead_multipart_encrypt_decrypt( int key_type_arg, data_t *key_data,
3367 int alg_arg,
3368 data_t *nonce,
3369 data_t *additional_data,
3370 int ad_part_len,
3371 data_t *input_data,
3372 int data_part_len,
3373 int expected_result_arg )
3374{
3375 mbedtls_svc_key_id_t key = MBEDTLS_SVC_KEY_ID_INIT;
3376 psa_key_type_t key_type = key_type_arg;
3377 psa_algorithm_t alg = alg_arg;
3378 psa_aead_operation_t operation;
3379 unsigned char *output_data = NULL;
3380 unsigned char *part_data = NULL;
3381 unsigned char *final_data = NULL;
3382 size_t part_data_size;
3383 size_t output_size = 0;
3384 size_t output_length = 0;
3385 unsigned char *output_data2 = NULL;
3386 size_t output_size2 = 0;
3387 size_t output_length2 = 0;
3388 size_t key_bits = 0;
3389 size_t tag_length = 0;
3390 size_t tag_size = 0;
3391 size_t nonce_length = 0;
3392 uint8_t nonce_buffer[16];
3393 uint8_t tag_buffer[16];
3394 uint32_t part_offset = 0;
3395 size_t part_length = 0;
3396 size_t output_part_length = 0;
3397 psa_status_t status = PSA_ERROR_GENERIC_ERROR;
3398 psa_status_t expected_result = expected_result_arg;
3399 psa_key_attributes_t attributes = PSA_KEY_ATTRIBUTES_INIT;
3400
3401 PSA_ASSERT( psa_crypto_init( ) );
3402
Paul Elliott2df40052021-05-07 17:52:18 +01003403 psa_set_key_usage_flags( &attributes,
3404 PSA_KEY_USAGE_ENCRYPT | PSA_KEY_USAGE_DECRYPT );
Paul Elliott0023e0a2021-04-27 10:06:22 +01003405 psa_set_key_algorithm( &attributes, alg );
3406 psa_set_key_type( &attributes, key_type );
3407
3408 PSA_ASSERT( psa_import_key( &attributes, key_data->x, key_data->len,
3409 &key ) );
3410
3411 PSA_ASSERT( psa_get_key_attributes( key, &attributes ) );
3412 key_bits = psa_get_key_bits( &attributes );
3413
3414 tag_length = PSA_AEAD_TAG_LENGTH( key_type, key_bits, alg );
3415
3416 TEST_ASSERT( tag_length <= 16 );
3417
3418 output_size = PSA_AEAD_UPDATE_OUTPUT_SIZE( key_type, alg, input_data->len );
3419
3420 ASSERT_ALLOC( output_data, output_size );
3421 ASSERT_ALLOC( final_data, PSA_AEAD_FINISH_OUTPUT_MAX_SIZE );
3422
3423 operation = psa_aead_operation_init();
3424
3425 status = psa_aead_encrypt_setup( &operation, key, alg );
3426
3427 /* If the operation is not supported, just skip and not fail in case the
3428 * encryption involves a common limitation of cryptography hardwares and
3429 * an alternative implementation. */
3430 if( status == PSA_ERROR_NOT_SUPPORTED )
3431 {
3432 MBEDTLS_TEST_PSA_SKIP_IF_ALT_AES_192( key_type, key_data->len * 8 );
3433 MBEDTLS_TEST_PSA_SKIP_IF_ALT_GCM_NOT_12BYTES_NONCE( alg, nonce->len );
3434 }
3435
3436 if( status != PSA_SUCCESS )
3437 {
3438 TEST_EQUAL( status, expected_result_arg );
3439 goto exit;
3440 }
3441
3442 if( nonce->len == 0 )
3443 {
Paul Elliott2df40052021-05-07 17:52:18 +01003444 status = psa_aead_generate_nonce( &operation, nonce_buffer,
3445 sizeof( nonce_buffer ),
Paul Elliott0023e0a2021-04-27 10:06:22 +01003446 &nonce_length );
3447 }
3448 else
3449 {
3450 nonce_length = nonce->len;
3451 status = psa_aead_set_nonce( &operation, nonce->x, nonce->len );
3452 }
3453
3454 if( status != PSA_SUCCESS )
3455 {
3456 TEST_EQUAL( status, expected_result_arg );
3457 goto exit;
3458 }
3459
3460#if defined(MBEDTLS_PSA_BUILTIN_ALG_GCM)
3461 if( operation.alg == PSA_ALG_GCM )
3462 {
Paul Elliott2df40052021-05-07 17:52:18 +01003463 status = psa_aead_set_lengths( &operation, additional_data->len,
3464 input_data->len );
Paul Elliott0023e0a2021-04-27 10:06:22 +01003465
3466 if( status != PSA_SUCCESS )
3467 {
3468 TEST_EQUAL( status, expected_result_arg );
3469 goto exit;
3470 }
3471 }
3472#endif
3473
3474 if( ad_part_len != -1 )
3475 {
3476 part_offset = 0;
3477
3478 while( part_offset <= additional_data->len)
3479 {
3480 if( additional_data->len - part_offset < ( uint32_t ) ad_part_len )
3481 {
3482 part_length = additional_data->len - part_offset;
3483 }
3484 else
3485 {
3486 part_length = ad_part_len;
3487 }
3488
Paul Elliott2df40052021-05-07 17:52:18 +01003489 status = psa_aead_update_ad( &operation,
3490 additional_data->x + part_offset,
Paul Elliott0023e0a2021-04-27 10:06:22 +01003491 part_length );
3492
3493 if( status != PSA_SUCCESS )
3494 {
3495 TEST_EQUAL( status, expected_result_arg );
3496 goto exit;
3497 }
3498
3499 part_offset += part_length;
3500 }
3501 }
3502 else
3503 {
Paul Elliott2df40052021-05-07 17:52:18 +01003504 status = psa_aead_update_ad(&operation, additional_data->x,
3505 additional_data->len);
Paul Elliott0023e0a2021-04-27 10:06:22 +01003506
3507 if( status != PSA_SUCCESS )
3508 {
3509 TEST_EQUAL( status, expected_result_arg );
3510 goto exit;
3511 }
3512 }
3513
3514 if( data_part_len != -1 )
3515 {
3516 /* Pass data in parts */
3517 part_data_size = PSA_AEAD_UPDATE_OUTPUT_SIZE( key_type, alg,
Paul Elliott2df40052021-05-07 17:52:18 +01003518 ( size_t ) data_part_len );
Paul Elliott0023e0a2021-04-27 10:06:22 +01003519
3520 ASSERT_ALLOC( part_data, part_data_size );
3521
3522 part_offset = 0;
3523
3524 while( part_offset <= input_data->len)
3525 {
3526 if( input_data->len - part_offset < ( uint32_t ) data_part_len )
3527 {
3528 part_length = input_data->len - part_offset;
3529 }
3530 else
3531 {
3532 part_length = data_part_len;
3533 }
3534
Paul Elliott2df40052021-05-07 17:52:18 +01003535 status = psa_aead_update( &operation,
3536 ( input_data->x + part_offset ),
Paul Elliott0023e0a2021-04-27 10:06:22 +01003537 part_length, part_data,
3538 part_data_size, &output_part_length );
3539
3540 if( status != PSA_SUCCESS )
3541 {
3542 TEST_EQUAL( status, expected_result_arg );
3543 goto exit;
3544 }
3545
Paul Elliottac3c2002021-04-27 19:10:18 +01003546 if( output_data && output_part_length )
3547 {
Paul Elliott2df40052021-05-07 17:52:18 +01003548 memcpy( ( output_data + part_offset ), part_data,
3549 output_part_length );
Paul Elliottac3c2002021-04-27 19:10:18 +01003550 }
Paul Elliott0023e0a2021-04-27 10:06:22 +01003551
3552 part_offset += part_length;
3553 output_length += output_part_length;
3554 }
3555 }
3556 else
3557 {
3558 status = psa_aead_update( &operation, input_data->x,
3559 input_data->len, output_data,
3560 output_size, &output_length );
3561
3562 if( status != PSA_SUCCESS )
3563 {
3564 TEST_EQUAL( status, expected_result_arg );
3565 goto exit;
3566 }
3567 }
3568
3569 status = psa_aead_finish( &operation, final_data,
3570 PSA_AEAD_FINISH_OUTPUT_MAX_SIZE,
3571 &output_part_length,
3572 tag_buffer, tag_length,
3573 &tag_size );
3574
3575 if( status != PSA_SUCCESS )
3576 {
3577 TEST_EQUAL( status, expected_result_arg );
3578 goto exit;
3579 }
3580
Paul Elliottac3c2002021-04-27 19:10:18 +01003581 if( output_data &&output_part_length )
3582 {
Paul Elliott2df40052021-05-07 17:52:18 +01003583 memcpy( ( output_data + output_length ), final_data,
3584 output_part_length );
Paul Elliottac3c2002021-04-27 19:10:18 +01003585 }
Paul Elliott0023e0a2021-04-27 10:06:22 +01003586
3587 output_length += output_part_length;
3588
3589 /* For all currently defined algorithms, PSA_AEAD_ENCRYPT_OUTPUT_SIZE
3590 * should be exact. */
3591 if( expected_result != PSA_ERROR_INVALID_ARGUMENT )
3592 TEST_EQUAL( ( output_length + tag_length ),
Paul Elliott2df40052021-05-07 17:52:18 +01003593 PSA_AEAD_ENCRYPT_OUTPUT_SIZE( key_type, alg,
3594 input_data->len ) );
Paul Elliott0023e0a2021-04-27 10:06:22 +01003595
3596 TEST_EQUAL(tag_length, tag_size);
3597
3598 if( PSA_SUCCESS == expected_result )
3599 {
Paul Elliott2df40052021-05-07 17:52:18 +01003600 output_size2 = PSA_AEAD_UPDATE_OUTPUT_SIZE( key_type, alg,
3601 output_length );
Paul Elliott0023e0a2021-04-27 10:06:22 +01003602 ASSERT_ALLOC( output_data2, output_size2 );
3603
3604 /* For all currently defined algorithms, PSA_AEAD_DECRYPT_OUTPUT_SIZE
3605 * should be exact. */
3606 TEST_EQUAL( input_data->len,
3607 PSA_AEAD_DECRYPT_OUTPUT_SIZE( key_type, alg,
Paul Elliott2df40052021-05-07 17:52:18 +01003608 ( output_length +
3609 tag_length ) ) );
Paul Elliott0023e0a2021-04-27 10:06:22 +01003610
3611 TEST_ASSERT( input_data->len <=
Paul Elliott2df40052021-05-07 17:52:18 +01003612 PSA_AEAD_DECRYPT_OUTPUT_MAX_SIZE( output_length +
3613 tag_length ) );
Paul Elliott0023e0a2021-04-27 10:06:22 +01003614
3615 operation = psa_aead_operation_init();
3616
3617 status = psa_aead_decrypt_setup( &operation, key, alg );
3618
3619 /* If the operation is not supported, just skip and not fail in case the
3620 * encryption involves a common limitation of cryptography hardwares and
3621 * an alternative implementation. */
3622 if( status == PSA_ERROR_NOT_SUPPORTED )
3623 {
3624 MBEDTLS_TEST_PSA_SKIP_IF_ALT_AES_192( key_type, key_data->len * 8 );
Paul Elliott2df40052021-05-07 17:52:18 +01003625 MBEDTLS_TEST_PSA_SKIP_IF_ALT_GCM_NOT_12BYTES_NONCE( alg,
3626 nonce->len );
Paul Elliott0023e0a2021-04-27 10:06:22 +01003627 }
3628
3629 TEST_EQUAL( status, expected_result );
3630
3631 if( nonce->len == 0 )
3632 {
3633 /* Use previously generated nonce. */
Paul Elliott2df40052021-05-07 17:52:18 +01003634 status = psa_aead_set_nonce( &operation, nonce_buffer,
3635 nonce_length );
Paul Elliott0023e0a2021-04-27 10:06:22 +01003636 }
3637 else
3638 {
3639 nonce_length = nonce->len;
3640 status = psa_aead_set_nonce( &operation, nonce->x, nonce->len );
3641 }
3642
3643 if( status != PSA_SUCCESS )
3644 {
3645 TEST_EQUAL( status, expected_result_arg );
3646 }
3647
3648#if defined(MBEDTLS_PSA_BUILTIN_ALG_GCM)
3649 if( operation.alg == PSA_ALG_GCM )
3650 {
Paul Elliott2df40052021-05-07 17:52:18 +01003651 status = psa_aead_set_lengths( &operation, additional_data->len,
3652 output_length );
Paul Elliott0023e0a2021-04-27 10:06:22 +01003653
3654 if( status != PSA_SUCCESS )
3655 {
3656 TEST_EQUAL( status, expected_result_arg );
3657 }
3658 }
3659#endif
3660
3661 if( ad_part_len != -1 )
3662 {
3663 part_offset = 0;
3664
3665 while( part_offset <= additional_data->len)
3666 {
Paul Elliott2df40052021-05-07 17:52:18 +01003667 if( additional_data->len - part_offset <
3668 ( uint32_t ) ad_part_len )
Paul Elliott0023e0a2021-04-27 10:06:22 +01003669 {
3670 part_length = additional_data->len - part_offset;
3671 }
3672 else
3673 {
3674 part_length = ad_part_len;
3675 }
3676
Paul Elliott2df40052021-05-07 17:52:18 +01003677 PSA_ASSERT( psa_aead_update_ad( &operation,
3678 additional_data->x +
3679 part_offset,
Paul Elliott0023e0a2021-04-27 10:06:22 +01003680 part_length ) );
3681
3682 part_offset += part_length;
3683 }
3684 }
3685 else
3686 {
Paul Elliott2df40052021-05-07 17:52:18 +01003687 PSA_ASSERT( psa_aead_update_ad(&operation, additional_data->x,
3688 additional_data->len) );
Paul Elliott0023e0a2021-04-27 10:06:22 +01003689 }
3690
3691 if( data_part_len != -1 )
3692 {
3693 /* Pass data in parts */
Paul Elliott2df40052021-05-07 17:52:18 +01003694 part_data_size = PSA_AEAD_UPDATE_OUTPUT_SIZE( key_type, alg,
3695 ( size_t ) data_part_len );
Paul Elliott0023e0a2021-04-27 10:06:22 +01003696
3697 ASSERT_ALLOC( part_data, part_data_size );
3698
3699 part_offset = 0;
3700
3701 while( part_offset <= ( input_data->len - tag_length ) )
3702 {
Paul Elliott2df40052021-05-07 17:52:18 +01003703 if( ( input_data->len - tag_length - part_offset ) <
3704 ( uint32_t ) data_part_len )
Paul Elliott0023e0a2021-04-27 10:06:22 +01003705 {
Paul Elliott2df40052021-05-07 17:52:18 +01003706 part_length =
3707 ( input_data->len - tag_length - part_offset );
Paul Elliott0023e0a2021-04-27 10:06:22 +01003708 }
3709 else
3710 {
3711 part_length = data_part_len;
3712 }
3713
Paul Elliott2df40052021-05-07 17:52:18 +01003714 PSA_ASSERT( psa_aead_update( &operation,
3715 ( input_data->x + part_offset ),
Paul Elliott0023e0a2021-04-27 10:06:22 +01003716 part_length, part_data,
Paul Elliott2df40052021-05-07 17:52:18 +01003717 part_data_size,
3718 &output_part_length ) );
Paul Elliott0023e0a2021-04-27 10:06:22 +01003719
Paul Elliottac3c2002021-04-27 19:10:18 +01003720 if( output_data2 && output_part_length )
3721 {
Paul Elliott2df40052021-05-07 17:52:18 +01003722 memcpy( ( output_data2 + part_offset ),
3723 part_data, output_part_length );
Paul Elliottac3c2002021-04-27 19:10:18 +01003724 }
Paul Elliott0023e0a2021-04-27 10:06:22 +01003725
3726 part_offset += part_length;
3727 output_length2 += output_part_length;
3728 }
3729 }
3730 else
3731 {
3732 PSA_ASSERT( psa_aead_update( &operation, output_data,
3733 output_length, output_data2,
3734 output_size2, &output_length2 ) );
3735 }
3736
3737 PSA_ASSERT( psa_aead_verify( &operation, final_data,
3738 PSA_AEAD_FINISH_OUTPUT_MAX_SIZE,
3739 &output_part_length,
3740 tag_buffer, tag_length ) );
3741
Paul Elliottac3c2002021-04-27 19:10:18 +01003742 if( output_data2 && output_part_length )
3743 {
Paul Elliott2df40052021-05-07 17:52:18 +01003744 memcpy( ( output_data2 + output_length2 ), final_data,
3745 output_part_length);
Paul Elliottac3c2002021-04-27 19:10:18 +01003746 }
Paul Elliott0023e0a2021-04-27 10:06:22 +01003747
3748 output_length2 += output_part_length;
3749
3750 ASSERT_COMPARE( input_data->x, input_data->len,
3751 output_data2, output_length2 );
3752 }
3753
3754exit:
3755 psa_destroy_key( key );
Paul Elliott16e6dcd2021-04-28 13:27:39 +01003756 psa_aead_abort( &operation );
Paul Elliott0023e0a2021-04-27 10:06:22 +01003757 mbedtls_free( output_data );
3758 mbedtls_free( output_data2 );
3759 mbedtls_free( part_data );
3760 mbedtls_free( final_data );
3761 PSA_DONE( );
3762}
3763/* END_CASE */
3764
3765/* BEGIN_CASE */
3766void aead_multipart_decrypt( int key_type_arg, data_t *key_data,
3767 int alg_arg,
3768 data_t *nonce,
3769 data_t *additional_data,
3770 int ad_part_len,
3771 data_t *input_data,
3772 int data_part_len,
3773 data_t *expected_data,
3774 int expected_result_arg )
3775{
3776 mbedtls_svc_key_id_t key = MBEDTLS_SVC_KEY_ID_INIT;
3777 psa_key_type_t key_type = key_type_arg;
3778 psa_algorithm_t alg = alg_arg;
3779 psa_aead_operation_t operation;
3780 unsigned char *output_data = NULL;
3781 unsigned char *part_data = NULL;
3782 unsigned char *final_data = NULL;
3783 size_t part_data_size;
3784 size_t output_size = 0;
3785 size_t output_length = 0;
3786 size_t key_bits = 0;
3787 size_t tag_length = 0;
3788 size_t nonce_length = 0;
3789 uint8_t nonce_buffer[16];
3790 uint32_t part_offset = 0;
3791 size_t part_length = 0;
3792 size_t output_part_length = 0;
3793 psa_key_attributes_t attributes = PSA_KEY_ATTRIBUTES_INIT;
3794 psa_status_t expected_result = expected_result_arg;
3795 psa_status_t status = PSA_ERROR_GENERIC_ERROR;
3796
3797 PSA_ASSERT( psa_crypto_init( ) );
3798
3799 psa_set_key_usage_flags( &attributes, PSA_KEY_USAGE_DECRYPT );
3800 psa_set_key_algorithm( &attributes, alg );
3801 psa_set_key_type( &attributes, key_type );
3802
3803 PSA_ASSERT( psa_import_key( &attributes, key_data->x, key_data->len,
3804 &key ) );
3805
3806 PSA_ASSERT( psa_get_key_attributes( key, &attributes ) );
3807 key_bits = psa_get_key_bits( &attributes );
3808
3809 tag_length = PSA_AEAD_TAG_LENGTH( key_type, key_bits, alg );
3810
3811 output_size = PSA_AEAD_UPDATE_OUTPUT_SIZE( key_type, alg,
Paul Elliott2df40052021-05-07 17:52:18 +01003812 ( input_data->len -
3813 tag_length ) );
Paul Elliott0023e0a2021-04-27 10:06:22 +01003814
3815 ASSERT_ALLOC( output_data, output_size );
3816 ASSERT_ALLOC( final_data, PSA_AEAD_VERIFY_OUTPUT_MAX_SIZE );
3817
3818 operation = psa_aead_operation_init();
3819
3820 status = psa_aead_decrypt_setup( &operation, key, alg );
3821
3822 /* If the operation is not supported, just skip and not fail in case the
3823 * encryption involves a common limitation of cryptography hardwares and
3824 * an alternative implementation. */
3825 if( status == PSA_ERROR_NOT_SUPPORTED )
3826 {
3827 MBEDTLS_TEST_PSA_SKIP_IF_ALT_AES_192( key_type, key_data->len * 8 );
3828 MBEDTLS_TEST_PSA_SKIP_IF_ALT_GCM_NOT_12BYTES_NONCE( alg, nonce->len );
3829 }
3830
3831 if( status != PSA_SUCCESS )
3832 {
3833 TEST_EQUAL( status, expected_result_arg );
3834 goto exit;
3835 }
3836
3837 if( nonce->len == 0 )
3838 {
Paul Elliott2df40052021-05-07 17:52:18 +01003839 status = psa_aead_generate_nonce( &operation, nonce_buffer,
3840 sizeof( nonce_buffer ),
Paul Elliott0023e0a2021-04-27 10:06:22 +01003841 &nonce_length );
3842 }
3843 else
3844 {
3845 nonce_length = nonce->len;
3846 status = psa_aead_set_nonce( &operation, nonce->x, nonce->len );
3847 }
3848
3849 if( status != PSA_SUCCESS )
3850 {
3851 TEST_EQUAL( status, expected_result_arg );
3852 goto exit;
3853 }
3854
3855#if defined(MBEDTLS_PSA_BUILTIN_ALG_GCM)
3856 if( operation.alg == PSA_ALG_GCM )
3857 {
3858 status = psa_aead_set_lengths( &operation, additional_data->len,
3859 ( input_data->len - tag_length ) );
3860
3861 if( status != PSA_SUCCESS )
3862 {
3863 TEST_EQUAL( status, expected_result_arg );
3864 goto exit;
3865 }
3866 }
3867#endif
3868
3869 if( ad_part_len != -1 )
3870 {
3871 part_offset = 0;
3872
3873 while( part_offset <= additional_data->len)
3874 {
3875 if( additional_data->len - part_offset < ( uint32_t ) ad_part_len )
3876 {
3877 part_length = additional_data->len - part_offset;
3878 }
3879 else
3880 {
3881 part_length = ad_part_len;
3882 }
3883
Paul Elliott2df40052021-05-07 17:52:18 +01003884 status = psa_aead_update_ad( &operation,
3885 additional_data->x + part_offset,
Paul Elliott0023e0a2021-04-27 10:06:22 +01003886 part_length );
3887
3888 if( status != PSA_SUCCESS )
3889 {
3890 TEST_EQUAL( status, expected_result_arg );
3891 goto exit;
3892 }
3893
3894 part_offset += part_length;
3895 }
3896 }
3897 else
3898 {
Paul Elliott2df40052021-05-07 17:52:18 +01003899 status = psa_aead_update_ad( &operation, additional_data->x,
3900 additional_data->len );
Paul Elliott0023e0a2021-04-27 10:06:22 +01003901
3902 if( status != PSA_SUCCESS )
3903 {
3904 TEST_EQUAL( status, expected_result_arg );
3905 goto exit;
3906 }
3907 }
3908
3909 if( data_part_len != -1 )
3910 {
3911 /* Pass data in parts */
Paul Elliott2df40052021-05-07 17:52:18 +01003912 part_data_size = PSA_AEAD_UPDATE_OUTPUT_SIZE( key_type, alg,
3913 ( size_t ) data_part_len );
Paul Elliott0023e0a2021-04-27 10:06:22 +01003914
3915 ASSERT_ALLOC( part_data, part_data_size );
3916
3917 part_offset = 0;
3918
3919 while( part_offset <= input_data->len)
3920 {
Paul Elliott2df40052021-05-07 17:52:18 +01003921 if( (input_data->len - tag_length - part_offset ) <
3922 ( uint32_t ) data_part_len )
Paul Elliott0023e0a2021-04-27 10:06:22 +01003923 {
3924 part_length = ( input_data->len - tag_length - part_offset );
3925 }
3926 else
3927 {
3928 part_length = data_part_len;
3929 }
3930
Paul Elliott2df40052021-05-07 17:52:18 +01003931 status = psa_aead_update( &operation,
3932 ( input_data->x + part_offset ),
3933 part_length, part_data,
3934 part_data_size, &output_part_length );
Paul Elliott0023e0a2021-04-27 10:06:22 +01003935
3936 if( status != PSA_SUCCESS )
3937 {
3938 TEST_EQUAL( status, expected_result_arg );
3939 goto exit;
3940 }
3941
Paul Elliottac3c2002021-04-27 19:10:18 +01003942 if( output_data && output_part_length )
3943 {
Paul Elliott2df40052021-05-07 17:52:18 +01003944 memcpy( ( output_data + part_offset ), part_data,
3945 output_part_length );
Paul Elliottac3c2002021-04-27 19:10:18 +01003946 }
Paul Elliott0023e0a2021-04-27 10:06:22 +01003947
3948 part_offset += part_length;
3949 output_length += output_part_length;
3950 }
3951 }
3952 else
3953 {
3954 status = psa_aead_update( &operation, input_data->x,
3955 ( input_data->len - tag_length ), output_data,
3956 output_size, &output_length );
3957
3958 if( status != PSA_SUCCESS )
3959 {
3960 TEST_EQUAL( status, expected_result_arg );
3961 goto exit;
3962 }
3963 }
3964
3965 status = psa_aead_verify( &operation, final_data,
3966 PSA_AEAD_VERIFY_OUTPUT_MAX_SIZE,
3967 &output_part_length,
Paul Elliott2df40052021-05-07 17:52:18 +01003968 ( input_data->x + input_data->len -
3969 tag_length ),
Paul Elliott0023e0a2021-04-27 10:06:22 +01003970 tag_length );
3971
3972 if( status != PSA_SUCCESS )
3973 {
3974 TEST_EQUAL( status, expected_result_arg );
3975 goto exit;
3976 }
3977
Paul Elliottac3c2002021-04-27 19:10:18 +01003978 if( output_data && output_part_length )
3979 {
Paul Elliott2df40052021-05-07 17:52:18 +01003980 memcpy( ( output_data + output_length ), final_data,
3981 output_part_length );
Paul Elliottac3c2002021-04-27 19:10:18 +01003982 }
Paul Elliott0023e0a2021-04-27 10:06:22 +01003983
3984 output_length += output_part_length;
3985
3986 if( expected_result != PSA_ERROR_INVALID_ARGUMENT )
3987 {
3988 /* For all currently defined algorithms, PSA_AEAD_DECRYPT_OUTPUT_SIZE
3989 * should be exact. */
3990 TEST_EQUAL( output_length,
Paul Elliott2df40052021-05-07 17:52:18 +01003991 PSA_AEAD_DECRYPT_OUTPUT_SIZE( key_type, alg,
3992 input_data->len ) );
Paul Elliott0023e0a2021-04-27 10:06:22 +01003993 TEST_ASSERT( output_length <=
3994 PSA_AEAD_DECRYPT_OUTPUT_MAX_SIZE( input_data->len ) );
3995 }
3996
3997 if( expected_result == PSA_SUCCESS )
3998 ASSERT_COMPARE( expected_data->x, expected_data->len,
3999 output_data, output_length );
4000
4001exit:
4002 psa_destroy_key( key );
Paul Elliott16e6dcd2021-04-28 13:27:39 +01004003 psa_aead_abort( &operation );
Paul Elliott0023e0a2021-04-27 10:06:22 +01004004 mbedtls_free( output_data );
4005 mbedtls_free( part_data );
4006 mbedtls_free( final_data );
4007 PSA_DONE( );
4008}
4009/* END_CASE */
4010
4011/* BEGIN_CASE */
Gilles Peskinec1bb6c82018-06-18 16:04:39 +02004012void signature_size( int type_arg,
4013 int bits,
4014 int alg_arg,
4015 int expected_size_arg )
Gilles Peskinee59236f2018-01-27 23:32:46 +01004016{
4017 psa_key_type_t type = type_arg;
4018 psa_algorithm_t alg = alg_arg;
Gilles Peskine89d8c5c2019-11-26 17:01:59 +01004019 size_t actual_size = PSA_SIGN_OUTPUT_SIZE( type, bits, alg );
Gilles Peskine841b14b2019-11-26 17:37:37 +01004020
Gilles Peskinefe11b722018-12-18 00:24:04 +01004021 TEST_EQUAL( actual_size, (size_t) expected_size_arg );
Gilles Peskine841b14b2019-11-26 17:37:37 +01004022
Gilles Peskinee59236f2018-01-27 23:32:46 +01004023exit:
4024 ;
4025}
4026/* END_CASE */
4027
4028/* BEGIN_CASE */
gabor-mezei-armb9530232021-04-16 14:21:21 +02004029void sign_hash_deterministic( int key_type_arg, data_t *key_data,
4030 int alg_arg, data_t *input_data,
4031 data_t *output_data )
Gilles Peskinee59236f2018-01-27 23:32:46 +01004032{
Ronald Cron5425a212020-08-04 14:58:35 +02004033 mbedtls_svc_key_id_t key = MBEDTLS_SVC_KEY_ID_INIT;
Gilles Peskinee59236f2018-01-27 23:32:46 +01004034 psa_key_type_t key_type = key_type_arg;
4035 psa_algorithm_t alg = alg_arg;
Gilles Peskine20035e32018-02-03 22:44:14 +01004036 size_t key_bits;
Gilles Peskine20035e32018-02-03 22:44:14 +01004037 unsigned char *signature = NULL;
4038 size_t signature_size;
4039 size_t signature_length = 0xdeadbeef;
Gilles Peskine8c8f2ab2019-04-18 21:44:46 +02004040 psa_key_attributes_t attributes = PSA_KEY_ATTRIBUTES_INIT;
Gilles Peskine20035e32018-02-03 22:44:14 +01004041
Gilles Peskine8817f612018-12-18 00:18:46 +01004042 PSA_ASSERT( psa_crypto_init( ) );
Gilles Peskine20035e32018-02-03 22:44:14 +01004043
Gilles Peskine89d8c5c2019-11-26 17:01:59 +01004044 psa_set_key_usage_flags( &attributes, PSA_KEY_USAGE_SIGN_HASH );
Gilles Peskine2c2cf0e2019-04-19 19:58:20 +02004045 psa_set_key_algorithm( &attributes, alg );
4046 psa_set_key_type( &attributes, key_type );
mohammad1603a97cb8c2018-03-28 03:46:26 -07004047
Gilles Peskine049c7532019-05-15 20:22:09 +02004048 PSA_ASSERT( psa_import_key( &attributes, key_data->x, key_data->len,
Ronald Cron5425a212020-08-04 14:58:35 +02004049 &key ) );
4050 PSA_ASSERT( psa_get_key_attributes( key, &attributes ) );
Gilles Peskine8c8f2ab2019-04-18 21:44:46 +02004051 key_bits = psa_get_key_bits( &attributes );
Gilles Peskine20035e32018-02-03 22:44:14 +01004052
Gilles Peskine860ce9d2018-06-28 12:23:00 +02004053 /* Allocate a buffer which has the size advertized by the
4054 * library. */
Gilles Peskine89d8c5c2019-11-26 17:01:59 +01004055 signature_size = PSA_SIGN_OUTPUT_SIZE( key_type,
Gilles Peskinec1bb6c82018-06-18 16:04:39 +02004056 key_bits, alg );
Gilles Peskine20035e32018-02-03 22:44:14 +01004057 TEST_ASSERT( signature_size != 0 );
Gilles Peskine89d8c5c2019-11-26 17:01:59 +01004058 TEST_ASSERT( signature_size <= PSA_SIGNATURE_MAX_SIZE );
Gilles Peskine8cebbba2018-09-27 13:54:18 +02004059 ASSERT_ALLOC( signature, signature_size );
Gilles Peskine20035e32018-02-03 22:44:14 +01004060
Gilles Peskine860ce9d2018-06-28 12:23:00 +02004061 /* Perform the signature. */
Ronald Cron5425a212020-08-04 14:58:35 +02004062 PSA_ASSERT( psa_sign_hash( key, alg,
Gilles Peskine89d8c5c2019-11-26 17:01:59 +01004063 input_data->x, input_data->len,
4064 signature, signature_size,
4065 &signature_length ) );
Gilles Peskine9911b022018-06-29 17:30:48 +02004066 /* Verify that the signature is what is expected. */
Gilles Peskinebd7dea92018-09-27 13:57:19 +02004067 ASSERT_COMPARE( output_data->x, output_data->len,
4068 signature, signature_length );
Gilles Peskine20035e32018-02-03 22:44:14 +01004069
4070exit:
Ronald Cron3a4f0e32020-11-19 17:55:23 +01004071 /*
4072 * Key attributes may have been returned by psa_get_key_attributes()
4073 * thus reset them as required.
4074 */
Gilles Peskinea1ace9c2019-04-26 16:03:33 +02004075 psa_reset_key_attributes( &attributes );
Ronald Cron3a4f0e32020-11-19 17:55:23 +01004076
Ronald Cron5425a212020-08-04 14:58:35 +02004077 psa_destroy_key( key );
Gilles Peskine0189e752018-02-03 23:57:22 +01004078 mbedtls_free( signature );
Gilles Peskine1153e7b2019-05-28 15:10:21 +02004079 PSA_DONE( );
Gilles Peskine20035e32018-02-03 22:44:14 +01004080}
4081/* END_CASE */
4082
4083/* BEGIN_CASE */
gabor-mezei-armb9530232021-04-16 14:21:21 +02004084void sign_hash_fail( int key_type_arg, data_t *key_data,
4085 int alg_arg, data_t *input_data,
4086 int signature_size_arg, int expected_status_arg )
Gilles Peskine20035e32018-02-03 22:44:14 +01004087{
Ronald Cron5425a212020-08-04 14:58:35 +02004088 mbedtls_svc_key_id_t key = MBEDTLS_SVC_KEY_ID_INIT;
Gilles Peskine20035e32018-02-03 22:44:14 +01004089 psa_key_type_t key_type = key_type_arg;
4090 psa_algorithm_t alg = alg_arg;
Gilles Peskine860ce9d2018-06-28 12:23:00 +02004091 size_t signature_size = signature_size_arg;
Gilles Peskine20035e32018-02-03 22:44:14 +01004092 psa_status_t actual_status;
4093 psa_status_t expected_status = expected_status_arg;
Gilles Peskine40f68b92018-03-07 16:43:36 +01004094 unsigned char *signature = NULL;
Gilles Peskine93aa0332018-02-03 23:58:03 +01004095 size_t signature_length = 0xdeadbeef;
Gilles Peskine2c2cf0e2019-04-19 19:58:20 +02004096 psa_key_attributes_t attributes = PSA_KEY_ATTRIBUTES_INIT;
Gilles Peskine20035e32018-02-03 22:44:14 +01004097
Gilles Peskine8cebbba2018-09-27 13:54:18 +02004098 ASSERT_ALLOC( signature, signature_size );
Gilles Peskine20035e32018-02-03 22:44:14 +01004099
Gilles Peskine8817f612018-12-18 00:18:46 +01004100 PSA_ASSERT( psa_crypto_init( ) );
Gilles Peskine20035e32018-02-03 22:44:14 +01004101
Gilles Peskine89d8c5c2019-11-26 17:01:59 +01004102 psa_set_key_usage_flags( &attributes, PSA_KEY_USAGE_SIGN_HASH );
Gilles Peskine2c2cf0e2019-04-19 19:58:20 +02004103 psa_set_key_algorithm( &attributes, alg );
4104 psa_set_key_type( &attributes, key_type );
mohammad1603a97cb8c2018-03-28 03:46:26 -07004105
Gilles Peskine049c7532019-05-15 20:22:09 +02004106 PSA_ASSERT( psa_import_key( &attributes, key_data->x, key_data->len,
Ronald Cron5425a212020-08-04 14:58:35 +02004107 &key ) );
Gilles Peskine20035e32018-02-03 22:44:14 +01004108
Ronald Cron5425a212020-08-04 14:58:35 +02004109 actual_status = psa_sign_hash( key, alg,
Gilles Peskine89d8c5c2019-11-26 17:01:59 +01004110 input_data->x, input_data->len,
4111 signature, signature_size,
4112 &signature_length );
Gilles Peskinefe11b722018-12-18 00:24:04 +01004113 TEST_EQUAL( actual_status, expected_status );
Gilles Peskine860ce9d2018-06-28 12:23:00 +02004114 /* The value of *signature_length is unspecified on error, but
4115 * whatever it is, it should be less than signature_size, so that
4116 * if the caller tries to read *signature_length bytes without
4117 * checking the error code then they don't overflow a buffer. */
4118 TEST_ASSERT( signature_length <= signature_size );
Gilles Peskine20035e32018-02-03 22:44:14 +01004119
4120exit:
Gilles Peskinea1ace9c2019-04-26 16:03:33 +02004121 psa_reset_key_attributes( &attributes );
Ronald Cron5425a212020-08-04 14:58:35 +02004122 psa_destroy_key( key );
Gilles Peskine20035e32018-02-03 22:44:14 +01004123 mbedtls_free( signature );
Gilles Peskine1153e7b2019-05-28 15:10:21 +02004124 PSA_DONE( );
Gilles Peskine20035e32018-02-03 22:44:14 +01004125}
4126/* END_CASE */
mohammad16038cc1cee2018-03-28 01:21:33 +03004127
4128/* BEGIN_CASE */
gabor-mezei-armb9530232021-04-16 14:21:21 +02004129void sign_verify_hash( int key_type_arg, data_t *key_data,
4130 int alg_arg, data_t *input_data )
Gilles Peskine9911b022018-06-29 17:30:48 +02004131{
Ronald Cron5425a212020-08-04 14:58:35 +02004132 mbedtls_svc_key_id_t key = MBEDTLS_SVC_KEY_ID_INIT;
Gilles Peskine9911b022018-06-29 17:30:48 +02004133 psa_key_type_t key_type = key_type_arg;
4134 psa_algorithm_t alg = alg_arg;
4135 size_t key_bits;
4136 unsigned char *signature = NULL;
4137 size_t signature_size;
4138 size_t signature_length = 0xdeadbeef;
Gilles Peskine8c8f2ab2019-04-18 21:44:46 +02004139 psa_key_attributes_t attributes = PSA_KEY_ATTRIBUTES_INIT;
Gilles Peskine9911b022018-06-29 17:30:48 +02004140
Gilles Peskine8817f612018-12-18 00:18:46 +01004141 PSA_ASSERT( psa_crypto_init( ) );
Gilles Peskine9911b022018-06-29 17:30:48 +02004142
Gilles Peskine89d8c5c2019-11-26 17:01:59 +01004143 psa_set_key_usage_flags( &attributes, PSA_KEY_USAGE_SIGN_HASH | PSA_KEY_USAGE_VERIFY_HASH );
Gilles Peskine2c2cf0e2019-04-19 19:58:20 +02004144 psa_set_key_algorithm( &attributes, alg );
4145 psa_set_key_type( &attributes, key_type );
Gilles Peskine9911b022018-06-29 17:30:48 +02004146
Gilles Peskine049c7532019-05-15 20:22:09 +02004147 PSA_ASSERT( psa_import_key( &attributes, key_data->x, key_data->len,
Ronald Cron5425a212020-08-04 14:58:35 +02004148 &key ) );
4149 PSA_ASSERT( psa_get_key_attributes( key, &attributes ) );
Gilles Peskine8c8f2ab2019-04-18 21:44:46 +02004150 key_bits = psa_get_key_bits( &attributes );
Gilles Peskine9911b022018-06-29 17:30:48 +02004151
4152 /* Allocate a buffer which has the size advertized by the
4153 * library. */
Gilles Peskine89d8c5c2019-11-26 17:01:59 +01004154 signature_size = PSA_SIGN_OUTPUT_SIZE( key_type,
Gilles Peskine9911b022018-06-29 17:30:48 +02004155 key_bits, alg );
4156 TEST_ASSERT( signature_size != 0 );
Gilles Peskine89d8c5c2019-11-26 17:01:59 +01004157 TEST_ASSERT( signature_size <= PSA_SIGNATURE_MAX_SIZE );
Gilles Peskine8cebbba2018-09-27 13:54:18 +02004158 ASSERT_ALLOC( signature, signature_size );
Gilles Peskine9911b022018-06-29 17:30:48 +02004159
4160 /* Perform the signature. */
Ronald Cron5425a212020-08-04 14:58:35 +02004161 PSA_ASSERT( psa_sign_hash( key, alg,
Gilles Peskine89d8c5c2019-11-26 17:01:59 +01004162 input_data->x, input_data->len,
4163 signature, signature_size,
4164 &signature_length ) );
Gilles Peskine9911b022018-06-29 17:30:48 +02004165 /* Check that the signature length looks sensible. */
4166 TEST_ASSERT( signature_length <= signature_size );
4167 TEST_ASSERT( signature_length > 0 );
4168
4169 /* Use the library to verify that the signature is correct. */
Ronald Cron5425a212020-08-04 14:58:35 +02004170 PSA_ASSERT( psa_verify_hash( key, alg,
Gilles Peskine89d8c5c2019-11-26 17:01:59 +01004171 input_data->x, input_data->len,
4172 signature, signature_length ) );
Gilles Peskine9911b022018-06-29 17:30:48 +02004173
4174 if( input_data->len != 0 )
4175 {
4176 /* Flip a bit in the input and verify that the signature is now
4177 * detected as invalid. Flip a bit at the beginning, not at the end,
4178 * because ECDSA may ignore the last few bits of the input. */
4179 input_data->x[0] ^= 1;
Ronald Cron5425a212020-08-04 14:58:35 +02004180 TEST_EQUAL( psa_verify_hash( key, alg,
Gilles Peskine89d8c5c2019-11-26 17:01:59 +01004181 input_data->x, input_data->len,
4182 signature, signature_length ),
Gilles Peskinef812dcf2018-12-18 00:33:25 +01004183 PSA_ERROR_INVALID_SIGNATURE );
Gilles Peskine9911b022018-06-29 17:30:48 +02004184 }
4185
4186exit:
Ronald Cron3a4f0e32020-11-19 17:55:23 +01004187 /*
4188 * Key attributes may have been returned by psa_get_key_attributes()
4189 * thus reset them as required.
4190 */
Gilles Peskinea1ace9c2019-04-26 16:03:33 +02004191 psa_reset_key_attributes( &attributes );
Ronald Cron3a4f0e32020-11-19 17:55:23 +01004192
Ronald Cron5425a212020-08-04 14:58:35 +02004193 psa_destroy_key( key );
Gilles Peskine9911b022018-06-29 17:30:48 +02004194 mbedtls_free( signature );
Gilles Peskine1153e7b2019-05-28 15:10:21 +02004195 PSA_DONE( );
Gilles Peskine9911b022018-06-29 17:30:48 +02004196}
4197/* END_CASE */
4198
4199/* BEGIN_CASE */
gabor-mezei-armb9530232021-04-16 14:21:21 +02004200void verify_hash( int key_type_arg, data_t *key_data,
4201 int alg_arg, data_t *hash_data,
4202 data_t *signature_data )
itayzafrir5c753392018-05-08 11:18:38 +03004203{
Ronald Cron5425a212020-08-04 14:58:35 +02004204 mbedtls_svc_key_id_t key = MBEDTLS_SVC_KEY_ID_INIT;
itayzafrir5c753392018-05-08 11:18:38 +03004205 psa_key_type_t key_type = key_type_arg;
4206 psa_algorithm_t alg = alg_arg;
Gilles Peskine2c2cf0e2019-04-19 19:58:20 +02004207 psa_key_attributes_t attributes = PSA_KEY_ATTRIBUTES_INIT;
itayzafrir5c753392018-05-08 11:18:38 +03004208
Gilles Peskine89d8c5c2019-11-26 17:01:59 +01004209 TEST_ASSERT( signature_data->len <= PSA_SIGNATURE_MAX_SIZE );
Gilles Peskine69c12672018-06-28 00:07:19 +02004210
Gilles Peskine8817f612018-12-18 00:18:46 +01004211 PSA_ASSERT( psa_crypto_init( ) );
itayzafrir5c753392018-05-08 11:18:38 +03004212
Gilles Peskine89d8c5c2019-11-26 17:01:59 +01004213 psa_set_key_usage_flags( &attributes, PSA_KEY_USAGE_VERIFY_HASH );
Gilles Peskine2c2cf0e2019-04-19 19:58:20 +02004214 psa_set_key_algorithm( &attributes, alg );
4215 psa_set_key_type( &attributes, key_type );
itayzafrir5c753392018-05-08 11:18:38 +03004216
Gilles Peskine049c7532019-05-15 20:22:09 +02004217 PSA_ASSERT( psa_import_key( &attributes, key_data->x, key_data->len,
Ronald Cron5425a212020-08-04 14:58:35 +02004218 &key ) );
itayzafrir5c753392018-05-08 11:18:38 +03004219
Ronald Cron5425a212020-08-04 14:58:35 +02004220 PSA_ASSERT( psa_verify_hash( key, alg,
Gilles Peskine89d8c5c2019-11-26 17:01:59 +01004221 hash_data->x, hash_data->len,
4222 signature_data->x, signature_data->len ) );
Gilles Peskine0627f982019-11-26 19:12:16 +01004223
itayzafrir5c753392018-05-08 11:18:38 +03004224exit:
Gilles Peskinea1ace9c2019-04-26 16:03:33 +02004225 psa_reset_key_attributes( &attributes );
Ronald Cron5425a212020-08-04 14:58:35 +02004226 psa_destroy_key( key );
Gilles Peskine1153e7b2019-05-28 15:10:21 +02004227 PSA_DONE( );
itayzafrir5c753392018-05-08 11:18:38 +03004228}
4229/* END_CASE */
Nir Sonnenschein39e59142018-05-02 23:16:26 +03004230
4231/* BEGIN_CASE */
gabor-mezei-armb9530232021-04-16 14:21:21 +02004232void verify_hash_fail( int key_type_arg, data_t *key_data,
4233 int alg_arg, data_t *hash_data,
4234 data_t *signature_data,
4235 int expected_status_arg )
Nir Sonnenschein39e59142018-05-02 23:16:26 +03004236{
Ronald Cron5425a212020-08-04 14:58:35 +02004237 mbedtls_svc_key_id_t key = MBEDTLS_SVC_KEY_ID_INIT;
Nir Sonnenschein39e59142018-05-02 23:16:26 +03004238 psa_key_type_t key_type = key_type_arg;
4239 psa_algorithm_t alg = alg_arg;
Nir Sonnenschein39e59142018-05-02 23:16:26 +03004240 psa_status_t actual_status;
4241 psa_status_t expected_status = expected_status_arg;
Gilles Peskine2c2cf0e2019-04-19 19:58:20 +02004242 psa_key_attributes_t attributes = PSA_KEY_ATTRIBUTES_INIT;
Nir Sonnenschein39e59142018-05-02 23:16:26 +03004243
Gilles Peskine8817f612018-12-18 00:18:46 +01004244 PSA_ASSERT( psa_crypto_init( ) );
Nir Sonnenschein39e59142018-05-02 23:16:26 +03004245
Gilles Peskine89d8c5c2019-11-26 17:01:59 +01004246 psa_set_key_usage_flags( &attributes, PSA_KEY_USAGE_VERIFY_HASH );
Gilles Peskine2c2cf0e2019-04-19 19:58:20 +02004247 psa_set_key_algorithm( &attributes, alg );
4248 psa_set_key_type( &attributes, key_type );
Nir Sonnenscheind7082602018-06-04 16:45:27 +03004249
Gilles Peskine049c7532019-05-15 20:22:09 +02004250 PSA_ASSERT( psa_import_key( &attributes, key_data->x, key_data->len,
Ronald Cron5425a212020-08-04 14:58:35 +02004251 &key ) );
Nir Sonnenschein39e59142018-05-02 23:16:26 +03004252
Ronald Cron5425a212020-08-04 14:58:35 +02004253 actual_status = psa_verify_hash( key, alg,
Gilles Peskine89d8c5c2019-11-26 17:01:59 +01004254 hash_data->x, hash_data->len,
4255 signature_data->x, signature_data->len );
Gilles Peskinefe11b722018-12-18 00:24:04 +01004256 TEST_EQUAL( actual_status, expected_status );
Nir Sonnenschein39e59142018-05-02 23:16:26 +03004257
4258exit:
Gilles Peskinea1ace9c2019-04-26 16:03:33 +02004259 psa_reset_key_attributes( &attributes );
Ronald Cron5425a212020-08-04 14:58:35 +02004260 psa_destroy_key( key );
Gilles Peskine1153e7b2019-05-28 15:10:21 +02004261 PSA_DONE( );
Nir Sonnenschein39e59142018-05-02 23:16:26 +03004262}
4263/* END_CASE */
4264
Nir Sonnenschein39e59142018-05-02 23:16:26 +03004265/* BEGIN_CASE */
gabor-mezei-arm53028482021-04-15 18:19:50 +02004266void sign_message_deterministic( int key_type_arg,
4267 data_t *key_data,
4268 int alg_arg,
4269 data_t *input_data,
4270 data_t *output_data )
4271{
4272 mbedtls_svc_key_id_t key = MBEDTLS_SVC_KEY_ID_INIT;
4273 psa_key_type_t key_type = key_type_arg;
4274 psa_algorithm_t alg = alg_arg;
4275 size_t key_bits;
4276 unsigned char *signature = NULL;
4277 size_t signature_size;
4278 size_t signature_length = 0xdeadbeef;
4279 psa_key_attributes_t attributes = PSA_KEY_ATTRIBUTES_INIT;
4280
4281 PSA_ASSERT( psa_crypto_init( ) );
4282
4283 psa_set_key_usage_flags( &attributes, PSA_KEY_USAGE_SIGN_MESSAGE );
4284 psa_set_key_algorithm( &attributes, alg );
4285 psa_set_key_type( &attributes, key_type );
4286
4287 PSA_ASSERT( psa_import_key( &attributes, key_data->x, key_data->len,
4288 &key ) );
4289 PSA_ASSERT( psa_get_key_attributes( key, &attributes ) );
4290 key_bits = psa_get_key_bits( &attributes );
4291
4292 signature_size = PSA_SIGN_OUTPUT_SIZE( key_type, key_bits, alg );
4293 TEST_ASSERT( signature_size != 0 );
4294 TEST_ASSERT( signature_size <= PSA_SIGNATURE_MAX_SIZE );
4295 ASSERT_ALLOC( signature, signature_size );
4296
4297 PSA_ASSERT( psa_sign_message( key, alg,
4298 input_data->x, input_data->len,
4299 signature, signature_size,
4300 &signature_length ) );
4301
4302 ASSERT_COMPARE( output_data->x, output_data->len,
4303 signature, signature_length );
4304
4305exit:
4306 psa_reset_key_attributes( &attributes );
4307
4308 psa_destroy_key( key );
4309 mbedtls_free( signature );
4310 PSA_DONE( );
4311
4312}
4313/* END_CASE */
4314
4315/* BEGIN_CASE */
4316void sign_message_fail( int key_type_arg,
4317 data_t *key_data,
4318 int alg_arg,
4319 data_t *input_data,
4320 int signature_size_arg,
4321 int expected_status_arg )
4322{
4323 mbedtls_svc_key_id_t key = MBEDTLS_SVC_KEY_ID_INIT;
4324 psa_key_type_t key_type = key_type_arg;
4325 psa_algorithm_t alg = alg_arg;
4326 size_t signature_size = signature_size_arg;
4327 psa_status_t actual_status;
4328 psa_status_t expected_status = expected_status_arg;
4329 unsigned char *signature = NULL;
4330 size_t signature_length = 0xdeadbeef;
4331 psa_key_attributes_t attributes = PSA_KEY_ATTRIBUTES_INIT;
4332
4333 ASSERT_ALLOC( signature, signature_size );
4334
4335 PSA_ASSERT( psa_crypto_init( ) );
4336
4337 psa_set_key_usage_flags( &attributes, PSA_KEY_USAGE_SIGN_MESSAGE );
4338 psa_set_key_algorithm( &attributes, alg );
4339 psa_set_key_type( &attributes, key_type );
4340
4341 PSA_ASSERT( psa_import_key( &attributes, key_data->x, key_data->len,
4342 &key ) );
4343
4344 actual_status = psa_sign_message( key, alg,
4345 input_data->x, input_data->len,
4346 signature, signature_size,
4347 &signature_length );
4348 TEST_EQUAL( actual_status, expected_status );
4349 /* The value of *signature_length is unspecified on error, but
4350 * whatever it is, it should be less than signature_size, so that
4351 * if the caller tries to read *signature_length bytes without
4352 * checking the error code then they don't overflow a buffer. */
4353 TEST_ASSERT( signature_length <= signature_size );
4354
4355exit:
4356 psa_reset_key_attributes( &attributes );
4357 psa_destroy_key( key );
4358 mbedtls_free( signature );
4359 PSA_DONE( );
4360}
4361/* END_CASE */
4362
4363/* BEGIN_CASE */
4364void sign_verify_message( int key_type_arg,
4365 data_t *key_data,
4366 int alg_arg,
4367 data_t *input_data )
4368{
4369 mbedtls_svc_key_id_t key = MBEDTLS_SVC_KEY_ID_INIT;
4370 psa_key_type_t key_type = key_type_arg;
4371 psa_algorithm_t alg = alg_arg;
4372 size_t key_bits;
4373 unsigned char *signature = NULL;
4374 size_t signature_size;
4375 size_t signature_length = 0xdeadbeef;
4376 psa_key_attributes_t attributes = PSA_KEY_ATTRIBUTES_INIT;
4377
4378 PSA_ASSERT( psa_crypto_init( ) );
4379
4380 psa_set_key_usage_flags( &attributes, PSA_KEY_USAGE_SIGN_MESSAGE |
4381 PSA_KEY_USAGE_VERIFY_MESSAGE );
4382 psa_set_key_algorithm( &attributes, alg );
4383 psa_set_key_type( &attributes, key_type );
4384
4385 PSA_ASSERT( psa_import_key( &attributes, key_data->x, key_data->len,
4386 &key ) );
4387 PSA_ASSERT( psa_get_key_attributes( key, &attributes ) );
4388 key_bits = psa_get_key_bits( &attributes );
4389
4390 signature_size = PSA_SIGN_OUTPUT_SIZE( key_type, key_bits, alg );
4391 TEST_ASSERT( signature_size != 0 );
4392 TEST_ASSERT( signature_size <= PSA_SIGNATURE_MAX_SIZE );
4393 ASSERT_ALLOC( signature, signature_size );
4394
4395 PSA_ASSERT( psa_sign_message( key, alg,
4396 input_data->x, input_data->len,
4397 signature, signature_size,
4398 &signature_length ) );
4399 TEST_ASSERT( signature_length <= signature_size );
4400 TEST_ASSERT( signature_length > 0 );
4401
4402 PSA_ASSERT( psa_verify_message( key, alg,
4403 input_data->x, input_data->len,
4404 signature, signature_length ) );
4405
4406 if( input_data->len != 0 )
4407 {
4408 /* Flip a bit in the input and verify that the signature is now
4409 * detected as invalid. Flip a bit at the beginning, not at the end,
4410 * because ECDSA may ignore the last few bits of the input. */
4411 input_data->x[0] ^= 1;
4412 TEST_EQUAL( psa_verify_message( key, alg,
4413 input_data->x, input_data->len,
4414 signature, signature_length ),
4415 PSA_ERROR_INVALID_SIGNATURE );
4416 }
4417
4418exit:
4419 psa_reset_key_attributes( &attributes );
4420
4421 psa_destroy_key( key );
4422 mbedtls_free( signature );
4423 PSA_DONE( );
4424}
4425/* END_CASE */
4426
4427/* BEGIN_CASE */
4428void verify_message( int key_type_arg,
4429 data_t *key_data,
4430 int alg_arg,
4431 data_t *input_data,
4432 data_t *signature_data )
4433{
4434 mbedtls_svc_key_id_t key = MBEDTLS_SVC_KEY_ID_INIT;
4435 psa_key_type_t key_type = key_type_arg;
4436 psa_algorithm_t alg = alg_arg;
4437 psa_key_attributes_t attributes = PSA_KEY_ATTRIBUTES_INIT;
4438
4439 TEST_ASSERT( signature_data->len <= PSA_SIGNATURE_MAX_SIZE );
4440
4441 PSA_ASSERT( psa_crypto_init( ) );
4442
4443 psa_set_key_usage_flags( &attributes, PSA_KEY_USAGE_VERIFY_MESSAGE );
4444 psa_set_key_algorithm( &attributes, alg );
4445 psa_set_key_type( &attributes, key_type );
4446
4447 PSA_ASSERT( psa_import_key( &attributes, key_data->x, key_data->len,
4448 &key ) );
4449
4450 PSA_ASSERT( psa_verify_message( key, alg,
4451 input_data->x, input_data->len,
4452 signature_data->x, signature_data->len ) );
4453
4454exit:
4455 psa_reset_key_attributes( &attributes );
4456 psa_destroy_key( key );
4457 PSA_DONE( );
4458}
4459/* END_CASE */
4460
4461/* BEGIN_CASE */
4462void verify_message_fail( int key_type_arg,
4463 data_t *key_data,
4464 int alg_arg,
4465 data_t *hash_data,
4466 data_t *signature_data,
4467 int expected_status_arg )
4468{
4469 mbedtls_svc_key_id_t key = MBEDTLS_SVC_KEY_ID_INIT;
4470 psa_key_type_t key_type = key_type_arg;
4471 psa_algorithm_t alg = alg_arg;
4472 psa_status_t actual_status;
4473 psa_status_t expected_status = expected_status_arg;
4474 psa_key_attributes_t attributes = PSA_KEY_ATTRIBUTES_INIT;
4475
4476 PSA_ASSERT( psa_crypto_init( ) );
4477
4478 psa_set_key_usage_flags( &attributes, PSA_KEY_USAGE_VERIFY_MESSAGE );
4479 psa_set_key_algorithm( &attributes, alg );
4480 psa_set_key_type( &attributes, key_type );
4481
4482 PSA_ASSERT( psa_import_key( &attributes, key_data->x, key_data->len,
4483 &key ) );
4484
4485 actual_status = psa_verify_message( key, alg,
4486 hash_data->x, hash_data->len,
4487 signature_data->x,
4488 signature_data->len );
4489 TEST_EQUAL( actual_status, expected_status );
4490
4491exit:
4492 psa_reset_key_attributes( &attributes );
4493 psa_destroy_key( key );
4494 PSA_DONE( );
4495}
4496/* END_CASE */
4497
4498/* BEGIN_CASE */
Gilles Peskine656896e2018-06-29 19:12:28 +02004499void asymmetric_encrypt( int key_type_arg,
4500 data_t *key_data,
4501 int alg_arg,
4502 data_t *input_data,
Gilles Peskine68428122018-06-30 18:42:41 +02004503 data_t *label,
Gilles Peskine656896e2018-06-29 19:12:28 +02004504 int expected_output_length_arg,
4505 int expected_status_arg )
4506{
Ronald Cron5425a212020-08-04 14:58:35 +02004507 mbedtls_svc_key_id_t key = MBEDTLS_SVC_KEY_ID_INIT;
Gilles Peskine656896e2018-06-29 19:12:28 +02004508 psa_key_type_t key_type = key_type_arg;
4509 psa_algorithm_t alg = alg_arg;
4510 size_t expected_output_length = expected_output_length_arg;
4511 size_t key_bits;
4512 unsigned char *output = NULL;
4513 size_t output_size;
4514 size_t output_length = ~0;
4515 psa_status_t actual_status;
4516 psa_status_t expected_status = expected_status_arg;
Gilles Peskine8c8f2ab2019-04-18 21:44:46 +02004517 psa_key_attributes_t attributes = PSA_KEY_ATTRIBUTES_INIT;
Gilles Peskine656896e2018-06-29 19:12:28 +02004518
Gilles Peskine8817f612018-12-18 00:18:46 +01004519 PSA_ASSERT( psa_crypto_init( ) );
Gilles Peskinebdf309c2018-12-03 15:36:32 +01004520
Gilles Peskine656896e2018-06-29 19:12:28 +02004521 /* Import the key */
Gilles Peskine2c2cf0e2019-04-19 19:58:20 +02004522 psa_set_key_usage_flags( &attributes, PSA_KEY_USAGE_ENCRYPT );
4523 psa_set_key_algorithm( &attributes, alg );
4524 psa_set_key_type( &attributes, key_type );
Gilles Peskine049c7532019-05-15 20:22:09 +02004525 PSA_ASSERT( psa_import_key( &attributes, key_data->x, key_data->len,
Ronald Cron5425a212020-08-04 14:58:35 +02004526 &key ) );
Gilles Peskine656896e2018-06-29 19:12:28 +02004527
4528 /* Determine the maximum output length */
Ronald Cron5425a212020-08-04 14:58:35 +02004529 PSA_ASSERT( psa_get_key_attributes( key, &attributes ) );
Gilles Peskine8c8f2ab2019-04-18 21:44:46 +02004530 key_bits = psa_get_key_bits( &attributes );
gabor-mezei-armceface22021-01-21 12:26:17 +01004531
Gilles Peskine656896e2018-06-29 19:12:28 +02004532 output_size = PSA_ASYMMETRIC_ENCRYPT_OUTPUT_SIZE( key_type, key_bits, alg );
gabor-mezei-armceface22021-01-21 12:26:17 +01004533 TEST_ASSERT( output_size <= PSA_ASYMMETRIC_ENCRYPT_OUTPUT_MAX_SIZE );
Gilles Peskine8cebbba2018-09-27 13:54:18 +02004534 ASSERT_ALLOC( output, output_size );
Gilles Peskine656896e2018-06-29 19:12:28 +02004535
4536 /* Encrypt the input */
Ronald Cron5425a212020-08-04 14:58:35 +02004537 actual_status = psa_asymmetric_encrypt( key, alg,
Gilles Peskine656896e2018-06-29 19:12:28 +02004538 input_data->x, input_data->len,
Gilles Peskine68428122018-06-30 18:42:41 +02004539 label->x, label->len,
Gilles Peskine656896e2018-06-29 19:12:28 +02004540 output, output_size,
4541 &output_length );
Gilles Peskinefe11b722018-12-18 00:24:04 +01004542 TEST_EQUAL( actual_status, expected_status );
4543 TEST_EQUAL( output_length, expected_output_length );
Gilles Peskine656896e2018-06-29 19:12:28 +02004544
Gilles Peskine68428122018-06-30 18:42:41 +02004545 /* If the label is empty, the test framework puts a non-null pointer
4546 * in label->x. Test that a null pointer works as well. */
4547 if( label->len == 0 )
4548 {
4549 output_length = ~0;
Gilles Peskinef7ab5ad2018-09-26 18:19:24 +02004550 if( output_size != 0 )
4551 memset( output, 0, output_size );
Ronald Cron5425a212020-08-04 14:58:35 +02004552 actual_status = psa_asymmetric_encrypt( key, alg,
Gilles Peskine68428122018-06-30 18:42:41 +02004553 input_data->x, input_data->len,
4554 NULL, label->len,
4555 output, output_size,
4556 &output_length );
Gilles Peskinefe11b722018-12-18 00:24:04 +01004557 TEST_EQUAL( actual_status, expected_status );
4558 TEST_EQUAL( output_length, expected_output_length );
Gilles Peskine68428122018-06-30 18:42:41 +02004559 }
4560
Gilles Peskine656896e2018-06-29 19:12:28 +02004561exit:
Ronald Cron3a4f0e32020-11-19 17:55:23 +01004562 /*
4563 * Key attributes may have been returned by psa_get_key_attributes()
4564 * thus reset them as required.
4565 */
Gilles Peskinea1ace9c2019-04-26 16:03:33 +02004566 psa_reset_key_attributes( &attributes );
Ronald Cron3a4f0e32020-11-19 17:55:23 +01004567
Ronald Cron5425a212020-08-04 14:58:35 +02004568 psa_destroy_key( key );
Gilles Peskine656896e2018-06-29 19:12:28 +02004569 mbedtls_free( output );
Gilles Peskine1153e7b2019-05-28 15:10:21 +02004570 PSA_DONE( );
Gilles Peskine656896e2018-06-29 19:12:28 +02004571}
4572/* END_CASE */
4573
4574/* BEGIN_CASE */
Gilles Peskine68428122018-06-30 18:42:41 +02004575void asymmetric_encrypt_decrypt( int key_type_arg,
4576 data_t *key_data,
4577 int alg_arg,
4578 data_t *input_data,
4579 data_t *label )
Nir Sonnenschein39e59142018-05-02 23:16:26 +03004580{
Ronald Cron5425a212020-08-04 14:58:35 +02004581 mbedtls_svc_key_id_t key = MBEDTLS_SVC_KEY_ID_INIT;
Nir Sonnenschein39e59142018-05-02 23:16:26 +03004582 psa_key_type_t key_type = key_type_arg;
4583 psa_algorithm_t alg = alg_arg;
Gilles Peskine55c94dd2018-06-30 18:54:48 +02004584 size_t key_bits;
Nir Sonnenschein39e59142018-05-02 23:16:26 +03004585 unsigned char *output = NULL;
Gilles Peskine55c94dd2018-06-30 18:54:48 +02004586 size_t output_size;
4587 size_t output_length = ~0;
Nir Sonnenschein0f3bdbd2018-05-02 23:56:12 +03004588 unsigned char *output2 = NULL;
Gilles Peskine55c94dd2018-06-30 18:54:48 +02004589 size_t output2_size;
4590 size_t output2_length = ~0;
Gilles Peskine8c8f2ab2019-04-18 21:44:46 +02004591 psa_key_attributes_t attributes = PSA_KEY_ATTRIBUTES_INIT;
Nir Sonnenschein39e59142018-05-02 23:16:26 +03004592
Gilles Peskine8817f612018-12-18 00:18:46 +01004593 PSA_ASSERT( psa_crypto_init( ) );
Nir Sonnenschein39e59142018-05-02 23:16:26 +03004594
Gilles Peskine2c2cf0e2019-04-19 19:58:20 +02004595 psa_set_key_usage_flags( &attributes, PSA_KEY_USAGE_ENCRYPT | PSA_KEY_USAGE_DECRYPT );
4596 psa_set_key_algorithm( &attributes, alg );
4597 psa_set_key_type( &attributes, key_type );
Nir Sonnenscheind7082602018-06-04 16:45:27 +03004598
Gilles Peskine049c7532019-05-15 20:22:09 +02004599 PSA_ASSERT( psa_import_key( &attributes, key_data->x, key_data->len,
Ronald Cron5425a212020-08-04 14:58:35 +02004600 &key ) );
Gilles Peskine55c94dd2018-06-30 18:54:48 +02004601
4602 /* Determine the maximum ciphertext length */
Ronald Cron5425a212020-08-04 14:58:35 +02004603 PSA_ASSERT( psa_get_key_attributes( key, &attributes ) );
Gilles Peskine8c8f2ab2019-04-18 21:44:46 +02004604 key_bits = psa_get_key_bits( &attributes );
gabor-mezei-armceface22021-01-21 12:26:17 +01004605
Gilles Peskine55c94dd2018-06-30 18:54:48 +02004606 output_size = PSA_ASYMMETRIC_ENCRYPT_OUTPUT_SIZE( key_type, key_bits, alg );
gabor-mezei-armceface22021-01-21 12:26:17 +01004607 TEST_ASSERT( output_size <= PSA_ASYMMETRIC_ENCRYPT_OUTPUT_MAX_SIZE );
Gilles Peskine8cebbba2018-09-27 13:54:18 +02004608 ASSERT_ALLOC( output, output_size );
gabor-mezei-armceface22021-01-21 12:26:17 +01004609
Gilles Peskine55c94dd2018-06-30 18:54:48 +02004610 output2_size = input_data->len;
gabor-mezei-armceface22021-01-21 12:26:17 +01004611 TEST_ASSERT( output2_size <=
4612 PSA_ASYMMETRIC_DECRYPT_OUTPUT_SIZE( key_type, key_bits, alg ) );
4613 TEST_ASSERT( output2_size <= PSA_ASYMMETRIC_DECRYPT_OUTPUT_MAX_SIZE );
Gilles Peskine8cebbba2018-09-27 13:54:18 +02004614 ASSERT_ALLOC( output2, output2_size );
Gilles Peskine55c94dd2018-06-30 18:54:48 +02004615
Gilles Peskineeebd7382018-06-08 18:11:54 +02004616 /* We test encryption by checking that encrypt-then-decrypt gives back
4617 * the original plaintext because of the non-optional random
4618 * part of encryption process which prevents using fixed vectors. */
Ronald Cron5425a212020-08-04 14:58:35 +02004619 PSA_ASSERT( psa_asymmetric_encrypt( key, alg,
Gilles Peskine8817f612018-12-18 00:18:46 +01004620 input_data->x, input_data->len,
4621 label->x, label->len,
4622 output, output_size,
4623 &output_length ) );
Gilles Peskine55c94dd2018-06-30 18:54:48 +02004624 /* We don't know what ciphertext length to expect, but check that
4625 * it looks sensible. */
4626 TEST_ASSERT( output_length <= output_size );
Nir Sonnenschein0f3bdbd2018-05-02 23:56:12 +03004627
Ronald Cron5425a212020-08-04 14:58:35 +02004628 PSA_ASSERT( psa_asymmetric_decrypt( key, alg,
Gilles Peskine8817f612018-12-18 00:18:46 +01004629 output, output_length,
4630 label->x, label->len,
4631 output2, output2_size,
4632 &output2_length ) );
Gilles Peskinebd7dea92018-09-27 13:57:19 +02004633 ASSERT_COMPARE( input_data->x, input_data->len,
4634 output2, output2_length );
Nir Sonnenschein39e59142018-05-02 23:16:26 +03004635
4636exit:
Ronald Cron3a4f0e32020-11-19 17:55:23 +01004637 /*
4638 * Key attributes may have been returned by psa_get_key_attributes()
4639 * thus reset them as required.
4640 */
Gilles Peskinea1ace9c2019-04-26 16:03:33 +02004641 psa_reset_key_attributes( &attributes );
Ronald Cron3a4f0e32020-11-19 17:55:23 +01004642
Ronald Cron5425a212020-08-04 14:58:35 +02004643 psa_destroy_key( key );
itayzafrir3e02b3b2018-06-12 17:06:52 +03004644 mbedtls_free( output );
4645 mbedtls_free( output2 );
Gilles Peskine1153e7b2019-05-28 15:10:21 +02004646 PSA_DONE( );
Nir Sonnenschein39e59142018-05-02 23:16:26 +03004647}
4648/* END_CASE */
4649
Nir Sonnenschein39e59142018-05-02 23:16:26 +03004650/* BEGIN_CASE */
Gilles Peskine68428122018-06-30 18:42:41 +02004651void asymmetric_decrypt( int key_type_arg,
4652 data_t *key_data,
4653 int alg_arg,
4654 data_t *input_data,
4655 data_t *label,
Gilles Peskine66763a02018-06-29 21:54:10 +02004656 data_t *expected_data )
Nir Sonnenschein39e59142018-05-02 23:16:26 +03004657{
Ronald Cron5425a212020-08-04 14:58:35 +02004658 mbedtls_svc_key_id_t key = MBEDTLS_SVC_KEY_ID_INIT;
Nir Sonnenschein39e59142018-05-02 23:16:26 +03004659 psa_key_type_t key_type = key_type_arg;
4660 psa_algorithm_t alg = alg_arg;
gabor-mezei-armceface22021-01-21 12:26:17 +01004661 size_t key_bits;
Nir Sonnenschein39e59142018-05-02 23:16:26 +03004662 unsigned char *output = NULL;
Nir Sonnenscheind70bc482018-06-04 16:31:13 +03004663 size_t output_size = 0;
Gilles Peskine55c94dd2018-06-30 18:54:48 +02004664 size_t output_length = ~0;
Gilles Peskine2c2cf0e2019-04-19 19:58:20 +02004665 psa_key_attributes_t attributes = PSA_KEY_ATTRIBUTES_INIT;
Nir Sonnenschein39e59142018-05-02 23:16:26 +03004666
Gilles Peskine8817f612018-12-18 00:18:46 +01004667 PSA_ASSERT( psa_crypto_init( ) );
Nir Sonnenschein39e59142018-05-02 23:16:26 +03004668
Gilles Peskine2c2cf0e2019-04-19 19:58:20 +02004669 psa_set_key_usage_flags( &attributes, PSA_KEY_USAGE_DECRYPT );
4670 psa_set_key_algorithm( &attributes, alg );
4671 psa_set_key_type( &attributes, key_type );
Nir Sonnenscheind7082602018-06-04 16:45:27 +03004672
Gilles Peskine049c7532019-05-15 20:22:09 +02004673 PSA_ASSERT( psa_import_key( &attributes, key_data->x, key_data->len,
Ronald Cron5425a212020-08-04 14:58:35 +02004674 &key ) );
Nir Sonnenschein39e59142018-05-02 23:16:26 +03004675
gabor-mezei-armceface22021-01-21 12:26:17 +01004676 PSA_ASSERT( psa_get_key_attributes( key, &attributes ) );
4677 key_bits = psa_get_key_bits( &attributes );
4678
4679 /* Determine the maximum ciphertext length */
4680 output_size = PSA_ASYMMETRIC_DECRYPT_OUTPUT_SIZE( key_type, key_bits, alg );
4681 TEST_ASSERT( output_size <= PSA_ASYMMETRIC_DECRYPT_OUTPUT_MAX_SIZE );
4682 ASSERT_ALLOC( output, output_size );
4683
Ronald Cron5425a212020-08-04 14:58:35 +02004684 PSA_ASSERT( psa_asymmetric_decrypt( key, alg,
Gilles Peskine8817f612018-12-18 00:18:46 +01004685 input_data->x, input_data->len,
4686 label->x, label->len,
4687 output,
4688 output_size,
4689 &output_length ) );
Gilles Peskinebd7dea92018-09-27 13:57:19 +02004690 ASSERT_COMPARE( expected_data->x, expected_data->len,
4691 output, output_length );
Nir Sonnenschein39e59142018-05-02 23:16:26 +03004692
Gilles Peskine68428122018-06-30 18:42:41 +02004693 /* If the label is empty, the test framework puts a non-null pointer
4694 * in label->x. Test that a null pointer works as well. */
4695 if( label->len == 0 )
4696 {
4697 output_length = ~0;
Gilles Peskinef7ab5ad2018-09-26 18:19:24 +02004698 if( output_size != 0 )
4699 memset( output, 0, output_size );
Ronald Cron5425a212020-08-04 14:58:35 +02004700 PSA_ASSERT( psa_asymmetric_decrypt( key, alg,
Gilles Peskine8817f612018-12-18 00:18:46 +01004701 input_data->x, input_data->len,
4702 NULL, label->len,
4703 output,
4704 output_size,
4705 &output_length ) );
Gilles Peskinebd7dea92018-09-27 13:57:19 +02004706 ASSERT_COMPARE( expected_data->x, expected_data->len,
4707 output, output_length );
Gilles Peskine68428122018-06-30 18:42:41 +02004708 }
4709
Nir Sonnenschein39e59142018-05-02 23:16:26 +03004710exit:
Gilles Peskinea1ace9c2019-04-26 16:03:33 +02004711 psa_reset_key_attributes( &attributes );
Ronald Cron5425a212020-08-04 14:58:35 +02004712 psa_destroy_key( key );
itayzafrir3e02b3b2018-06-12 17:06:52 +03004713 mbedtls_free( output );
Gilles Peskine1153e7b2019-05-28 15:10:21 +02004714 PSA_DONE( );
Nir Sonnenschein39e59142018-05-02 23:16:26 +03004715}
4716/* END_CASE */
4717
Nir Sonnenschein39e59142018-05-02 23:16:26 +03004718/* BEGIN_CASE */
Gilles Peskine68428122018-06-30 18:42:41 +02004719void asymmetric_decrypt_fail( int key_type_arg,
4720 data_t *key_data,
4721 int alg_arg,
4722 data_t *input_data,
4723 data_t *label,
Jaeden Amerof8daab72019-02-06 12:57:46 +00004724 int output_size_arg,
Gilles Peskine2d277862018-06-18 15:41:12 +02004725 int expected_status_arg )
Nir Sonnenschein39e59142018-05-02 23:16:26 +03004726{
Ronald Cron5425a212020-08-04 14:58:35 +02004727 mbedtls_svc_key_id_t key = MBEDTLS_SVC_KEY_ID_INIT;
Nir Sonnenschein39e59142018-05-02 23:16:26 +03004728 psa_key_type_t key_type = key_type_arg;
4729 psa_algorithm_t alg = alg_arg;
Nir Sonnenschein39e59142018-05-02 23:16:26 +03004730 unsigned char *output = NULL;
Jaeden Amerof8daab72019-02-06 12:57:46 +00004731 size_t output_size = output_size_arg;
Gilles Peskine55c94dd2018-06-30 18:54:48 +02004732 size_t output_length = ~0;
Nir Sonnenschein39e59142018-05-02 23:16:26 +03004733 psa_status_t actual_status;
4734 psa_status_t expected_status = expected_status_arg;
Gilles Peskine2c2cf0e2019-04-19 19:58:20 +02004735 psa_key_attributes_t attributes = PSA_KEY_ATTRIBUTES_INIT;
Nir Sonnenschein39e59142018-05-02 23:16:26 +03004736
Gilles Peskine8cebbba2018-09-27 13:54:18 +02004737 ASSERT_ALLOC( output, output_size );
Gilles Peskine5b051bc2018-05-31 13:25:48 +02004738
Gilles Peskine8817f612018-12-18 00:18:46 +01004739 PSA_ASSERT( psa_crypto_init( ) );
Nir Sonnenschein39e59142018-05-02 23:16:26 +03004740
Gilles Peskine2c2cf0e2019-04-19 19:58:20 +02004741 psa_set_key_usage_flags( &attributes, PSA_KEY_USAGE_DECRYPT );
4742 psa_set_key_algorithm( &attributes, alg );
4743 psa_set_key_type( &attributes, key_type );
Nir Sonnenscheind7082602018-06-04 16:45:27 +03004744
Gilles Peskine049c7532019-05-15 20:22:09 +02004745 PSA_ASSERT( psa_import_key( &attributes, key_data->x, key_data->len,
Ronald Cron5425a212020-08-04 14:58:35 +02004746 &key ) );
Nir Sonnenschein39e59142018-05-02 23:16:26 +03004747
Ronald Cron5425a212020-08-04 14:58:35 +02004748 actual_status = psa_asymmetric_decrypt( key, alg,
Gilles Peskine4abf7412018-06-18 16:35:34 +02004749 input_data->x, input_data->len,
Gilles Peskine68428122018-06-30 18:42:41 +02004750 label->x, label->len,
Gilles Peskine4abf7412018-06-18 16:35:34 +02004751 output, output_size,
Gilles Peskine2d277862018-06-18 15:41:12 +02004752 &output_length );
Gilles Peskinefe11b722018-12-18 00:24:04 +01004753 TEST_EQUAL( actual_status, expected_status );
Gilles Peskine55c94dd2018-06-30 18:54:48 +02004754 TEST_ASSERT( output_length <= output_size );
Nir Sonnenschein39e59142018-05-02 23:16:26 +03004755
Gilles Peskine68428122018-06-30 18:42:41 +02004756 /* If the label is empty, the test framework puts a non-null pointer
4757 * in label->x. Test that a null pointer works as well. */
4758 if( label->len == 0 )
4759 {
4760 output_length = ~0;
Gilles Peskinef7ab5ad2018-09-26 18:19:24 +02004761 if( output_size != 0 )
4762 memset( output, 0, output_size );
Ronald Cron5425a212020-08-04 14:58:35 +02004763 actual_status = psa_asymmetric_decrypt( key, alg,
Gilles Peskine68428122018-06-30 18:42:41 +02004764 input_data->x, input_data->len,
4765 NULL, label->len,
4766 output, output_size,
4767 &output_length );
Gilles Peskinefe11b722018-12-18 00:24:04 +01004768 TEST_EQUAL( actual_status, expected_status );
Gilles Peskine55c94dd2018-06-30 18:54:48 +02004769 TEST_ASSERT( output_length <= output_size );
Gilles Peskine68428122018-06-30 18:42:41 +02004770 }
4771
Nir Sonnenschein39e59142018-05-02 23:16:26 +03004772exit:
Gilles Peskinea1ace9c2019-04-26 16:03:33 +02004773 psa_reset_key_attributes( &attributes );
Ronald Cron5425a212020-08-04 14:58:35 +02004774 psa_destroy_key( key );
Gilles Peskine2d277862018-06-18 15:41:12 +02004775 mbedtls_free( output );
Gilles Peskine1153e7b2019-05-28 15:10:21 +02004776 PSA_DONE( );
Nir Sonnenschein39e59142018-05-02 23:16:26 +03004777}
Gilles Peskine5b051bc2018-05-31 13:25:48 +02004778/* END_CASE */
Gilles Peskine05d69892018-06-19 22:00:52 +02004779
4780/* BEGIN_CASE */
Gilles Peskinecbe66502019-05-16 16:59:18 +02004781void key_derivation_init( )
Jaeden Amerod94d6712019-01-04 14:11:48 +00004782{
4783 /* Test each valid way of initializing the object, except for `= {0}`, as
4784 * Clang 5 complains when `-Wmissing-field-initializers` is used, even
4785 * though it's OK by the C standard. We could test for this, but we'd need
4786 * to supress the Clang warning for the test. */
Jaeden Amero5229bbb2019-02-07 16:33:37 +00004787 size_t capacity;
Gilles Peskinea99d3fb2019-05-16 15:28:51 +02004788 psa_key_derivation_operation_t func = psa_key_derivation_operation_init( );
4789 psa_key_derivation_operation_t init = PSA_KEY_DERIVATION_OPERATION_INIT;
4790 psa_key_derivation_operation_t zero;
Jaeden Amerod94d6712019-01-04 14:11:48 +00004791
4792 memset( &zero, 0, sizeof( zero ) );
4793
Gilles Peskine51ae0e42019-05-16 17:31:03 +02004794 /* A default operation should not be able to report its capacity. */
Gilles Peskinea99d3fb2019-05-16 15:28:51 +02004795 TEST_EQUAL( psa_key_derivation_get_capacity( &func, &capacity ),
Jaeden Amerocf2010c2019-02-15 13:05:49 +00004796 PSA_ERROR_BAD_STATE );
Gilles Peskinea99d3fb2019-05-16 15:28:51 +02004797 TEST_EQUAL( psa_key_derivation_get_capacity( &init, &capacity ),
Jaeden Amerocf2010c2019-02-15 13:05:49 +00004798 PSA_ERROR_BAD_STATE );
Gilles Peskinea99d3fb2019-05-16 15:28:51 +02004799 TEST_EQUAL( psa_key_derivation_get_capacity( &zero, &capacity ),
Jaeden Amerocf2010c2019-02-15 13:05:49 +00004800 PSA_ERROR_BAD_STATE );
Jaeden Amero5229bbb2019-02-07 16:33:37 +00004801
Gilles Peskine51ae0e42019-05-16 17:31:03 +02004802 /* A default operation should be abortable without error. */
Gilles Peskinea99d3fb2019-05-16 15:28:51 +02004803 PSA_ASSERT( psa_key_derivation_abort(&func) );
4804 PSA_ASSERT( psa_key_derivation_abort(&init) );
4805 PSA_ASSERT( psa_key_derivation_abort(&zero) );
Jaeden Amerod94d6712019-01-04 14:11:48 +00004806}
4807/* END_CASE */
4808
Janos Follath16de4a42019-06-13 16:32:24 +01004809/* BEGIN_CASE */
4810void derive_setup( int alg_arg, int expected_status_arg )
Gilles Peskineea0fb492018-07-12 17:17:20 +02004811{
Gilles Peskineea0fb492018-07-12 17:17:20 +02004812 psa_algorithm_t alg = alg_arg;
Gilles Peskineea0fb492018-07-12 17:17:20 +02004813 psa_status_t expected_status = expected_status_arg;
Gilles Peskine51ae0e42019-05-16 17:31:03 +02004814 psa_key_derivation_operation_t operation = PSA_KEY_DERIVATION_OPERATION_INIT;
Gilles Peskineea0fb492018-07-12 17:17:20 +02004815
Gilles Peskine8817f612018-12-18 00:18:46 +01004816 PSA_ASSERT( psa_crypto_init( ) );
Gilles Peskineea0fb492018-07-12 17:17:20 +02004817
Janos Follath16de4a42019-06-13 16:32:24 +01004818 TEST_EQUAL( psa_key_derivation_setup( &operation, alg ),
Gilles Peskinef812dcf2018-12-18 00:33:25 +01004819 expected_status );
Gilles Peskineea0fb492018-07-12 17:17:20 +02004820
4821exit:
Gilles Peskine51ae0e42019-05-16 17:31:03 +02004822 psa_key_derivation_abort( &operation );
Gilles Peskine1153e7b2019-05-28 15:10:21 +02004823 PSA_DONE( );
Gilles Peskineea0fb492018-07-12 17:17:20 +02004824}
4825/* END_CASE */
4826
Janos Follathaf3c2a02019-06-12 12:34:34 +01004827/* BEGIN_CASE */
Janos Follatha27c9272019-06-14 09:59:36 +01004828void derive_set_capacity( int alg_arg, int capacity_arg,
4829 int expected_status_arg )
4830{
4831 psa_algorithm_t alg = alg_arg;
4832 size_t capacity = capacity_arg;
4833 psa_status_t expected_status = expected_status_arg;
4834 psa_key_derivation_operation_t operation = PSA_KEY_DERIVATION_OPERATION_INIT;
4835
4836 PSA_ASSERT( psa_crypto_init( ) );
4837
4838 PSA_ASSERT( psa_key_derivation_setup( &operation, alg ) );
4839
4840 TEST_EQUAL( psa_key_derivation_set_capacity( &operation, capacity ),
4841 expected_status );
4842
4843exit:
4844 psa_key_derivation_abort( &operation );
4845 PSA_DONE( );
4846}
4847/* END_CASE */
4848
4849/* BEGIN_CASE */
Janos Follathaf3c2a02019-06-12 12:34:34 +01004850void derive_input( int alg_arg,
Gilles Peskine6842ba42019-09-23 13:49:33 +02004851 int step_arg1, int key_type_arg1, data_t *input1,
Janos Follathaf3c2a02019-06-12 12:34:34 +01004852 int expected_status_arg1,
Gilles Peskine2058c072019-09-24 17:19:33 +02004853 int step_arg2, int key_type_arg2, data_t *input2,
Janos Follathaf3c2a02019-06-12 12:34:34 +01004854 int expected_status_arg2,
Gilles Peskine2058c072019-09-24 17:19:33 +02004855 int step_arg3, int key_type_arg3, data_t *input3,
Gilles Peskine1a2904c2019-09-24 17:45:07 +02004856 int expected_status_arg3,
4857 int output_key_type_arg, int expected_output_status_arg )
Janos Follathaf3c2a02019-06-12 12:34:34 +01004858{
4859 psa_algorithm_t alg = alg_arg;
Gilles Peskine6842ba42019-09-23 13:49:33 +02004860 psa_key_derivation_step_t steps[] = {step_arg1, step_arg2, step_arg3};
4861 psa_key_type_t key_types[] = {key_type_arg1, key_type_arg2, key_type_arg3};
Janos Follathaf3c2a02019-06-12 12:34:34 +01004862 psa_status_t expected_statuses[] = {expected_status_arg1,
4863 expected_status_arg2,
4864 expected_status_arg3};
4865 data_t *inputs[] = {input1, input2, input3};
Ronald Cron5425a212020-08-04 14:58:35 +02004866 mbedtls_svc_key_id_t keys[] = { MBEDTLS_SVC_KEY_ID_INIT,
4867 MBEDTLS_SVC_KEY_ID_INIT,
4868 MBEDTLS_SVC_KEY_ID_INIT };
Janos Follathaf3c2a02019-06-12 12:34:34 +01004869 psa_key_derivation_operation_t operation = PSA_KEY_DERIVATION_OPERATION_INIT;
4870 psa_key_attributes_t attributes = PSA_KEY_ATTRIBUTES_INIT;
4871 size_t i;
Gilles Peskine1a2904c2019-09-24 17:45:07 +02004872 psa_key_type_t output_key_type = output_key_type_arg;
Ronald Cron5425a212020-08-04 14:58:35 +02004873 mbedtls_svc_key_id_t output_key = MBEDTLS_SVC_KEY_ID_INIT;
Gilles Peskine1a2904c2019-09-24 17:45:07 +02004874 psa_status_t expected_output_status = expected_output_status_arg;
4875 psa_status_t actual_output_status;
Janos Follathaf3c2a02019-06-12 12:34:34 +01004876
4877 PSA_ASSERT( psa_crypto_init( ) );
4878
4879 psa_set_key_usage_flags( &attributes, PSA_KEY_USAGE_DERIVE );
4880 psa_set_key_algorithm( &attributes, alg );
Janos Follathaf3c2a02019-06-12 12:34:34 +01004881
4882 PSA_ASSERT( psa_key_derivation_setup( &operation, alg ) );
4883
4884 for( i = 0; i < ARRAY_LENGTH( steps ); i++ )
4885 {
Gilles Peskineb8965192019-09-24 16:21:10 +02004886 if( key_types[i] != PSA_KEY_TYPE_NONE )
Janos Follathaf3c2a02019-06-12 12:34:34 +01004887 {
Gilles Peskine6842ba42019-09-23 13:49:33 +02004888 psa_set_key_type( &attributes, key_types[i] );
4889 PSA_ASSERT( psa_import_key( &attributes,
4890 inputs[i]->x, inputs[i]->len,
Ronald Cron5425a212020-08-04 14:58:35 +02004891 &keys[i] ) );
Steven Cooreman0ee0d522020-10-05 16:03:42 +02004892 if( PSA_KEY_TYPE_IS_KEY_PAIR( key_types[i] ) &&
4893 steps[i] == PSA_KEY_DERIVATION_INPUT_SECRET )
4894 {
4895 // When taking a private key as secret input, use key agreement
4896 // to add the shared secret to the derivation
Gilles Peskinec18e25f2021-02-12 23:48:20 +01004897 TEST_EQUAL( mbedtls_test_psa_key_agreement_with_self(
4898 &operation, keys[i] ),
Steven Cooreman0ee0d522020-10-05 16:03:42 +02004899 expected_statuses[i] );
4900 }
4901 else
4902 {
4903 TEST_EQUAL( psa_key_derivation_input_key( &operation, steps[i],
Ronald Cron5425a212020-08-04 14:58:35 +02004904 keys[i] ),
Steven Cooreman0ee0d522020-10-05 16:03:42 +02004905 expected_statuses[i] );
4906 }
Gilles Peskine6842ba42019-09-23 13:49:33 +02004907 }
4908 else
4909 {
4910 TEST_EQUAL( psa_key_derivation_input_bytes(
4911 &operation, steps[i],
4912 inputs[i]->x, inputs[i]->len ),
4913 expected_statuses[i] );
Janos Follathaf3c2a02019-06-12 12:34:34 +01004914 }
4915 }
4916
Gilles Peskine1a2904c2019-09-24 17:45:07 +02004917 if( output_key_type != PSA_KEY_TYPE_NONE )
4918 {
4919 psa_reset_key_attributes( &attributes );
4920 psa_set_key_type( &attributes, PSA_KEY_TYPE_RAW_DATA );
4921 psa_set_key_bits( &attributes, 8 );
4922 actual_output_status =
4923 psa_key_derivation_output_key( &attributes, &operation,
Ronald Cron5425a212020-08-04 14:58:35 +02004924 &output_key );
Gilles Peskine1a2904c2019-09-24 17:45:07 +02004925 }
4926 else
4927 {
4928 uint8_t buffer[1];
4929 actual_output_status =
4930 psa_key_derivation_output_bytes( &operation,
4931 buffer, sizeof( buffer ) );
4932 }
4933 TEST_EQUAL( actual_output_status, expected_output_status );
4934
Janos Follathaf3c2a02019-06-12 12:34:34 +01004935exit:
4936 psa_key_derivation_abort( &operation );
Ronald Cron5425a212020-08-04 14:58:35 +02004937 for( i = 0; i < ARRAY_LENGTH( keys ); i++ )
4938 psa_destroy_key( keys[i] );
4939 psa_destroy_key( output_key );
Janos Follathaf3c2a02019-06-12 12:34:34 +01004940 PSA_DONE( );
4941}
4942/* END_CASE */
4943
Janos Follathd958bb72019-07-03 15:02:16 +01004944/* BEGIN_CASE */
4945void test_derive_invalid_key_derivation_state( int alg_arg )
Nir Sonnenscheine5204c92018-10-22 17:24:55 +03004946{
Janos Follathd958bb72019-07-03 15:02:16 +01004947 psa_algorithm_t alg = alg_arg;
Ronald Cron5425a212020-08-04 14:58:35 +02004948 mbedtls_svc_key_id_t key = MBEDTLS_SVC_KEY_ID_INIT;
Nir Sonnenschein4eda37b2018-10-31 12:15:58 +02004949 size_t key_type = PSA_KEY_TYPE_DERIVE;
Gilles Peskine51ae0e42019-05-16 17:31:03 +02004950 psa_key_derivation_operation_t operation = PSA_KEY_DERIVATION_OPERATION_INIT;
Janos Follathd958bb72019-07-03 15:02:16 +01004951 unsigned char input1[] = "Input 1";
4952 size_t input1_length = sizeof( input1 );
4953 unsigned char input2[] = "Input 2";
4954 size_t input2_length = sizeof( input2 );
Nir Sonnenscheinb46e7ca2018-10-25 14:46:09 +03004955 uint8_t buffer[42];
Nir Sonnenschein1caf6d22018-11-01 12:27:20 +02004956 size_t capacity = sizeof( buffer );
Nir Sonnenscheindd69d8b2018-11-01 12:24:23 +02004957 const uint8_t key_data[22] = { 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b,
4958 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b,
4959 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b};
Gilles Peskine2c2cf0e2019-04-19 19:58:20 +02004960 psa_key_attributes_t attributes = PSA_KEY_ATTRIBUTES_INIT;
Nir Sonnenscheine5204c92018-10-22 17:24:55 +03004961
Gilles Peskine8817f612018-12-18 00:18:46 +01004962 PSA_ASSERT( psa_crypto_init( ) );
Nir Sonnenscheinb46e7ca2018-10-25 14:46:09 +03004963
Gilles Peskine2c2cf0e2019-04-19 19:58:20 +02004964 psa_set_key_usage_flags( &attributes, PSA_KEY_USAGE_DERIVE );
4965 psa_set_key_algorithm( &attributes, alg );
4966 psa_set_key_type( &attributes, key_type );
Nir Sonnenscheinb46e7ca2018-10-25 14:46:09 +03004967
Gilles Peskine73676cb2019-05-15 20:15:10 +02004968 PSA_ASSERT( psa_import_key( &attributes,
4969 key_data, sizeof( key_data ),
Ronald Cron5425a212020-08-04 14:58:35 +02004970 &key ) );
Nir Sonnenscheinb46e7ca2018-10-25 14:46:09 +03004971
4972 /* valid key derivation */
Gilles Peskinec18e25f2021-02-12 23:48:20 +01004973 if( !mbedtls_test_psa_setup_key_derivation_wrap( &operation, key, alg,
4974 input1, input1_length,
4975 input2, input2_length,
4976 capacity ) )
Janos Follathd958bb72019-07-03 15:02:16 +01004977 goto exit;
Nir Sonnenscheinb46e7ca2018-10-25 14:46:09 +03004978
Gilles Peskine51ae0e42019-05-16 17:31:03 +02004979 /* state of operation shouldn't allow additional generation */
Janos Follathd958bb72019-07-03 15:02:16 +01004980 TEST_EQUAL( psa_key_derivation_setup( &operation, alg ),
Gilles Peskinef812dcf2018-12-18 00:33:25 +01004981 PSA_ERROR_BAD_STATE );
Nir Sonnenscheinb46e7ca2018-10-25 14:46:09 +03004982
Gilles Peskine51ae0e42019-05-16 17:31:03 +02004983 PSA_ASSERT( psa_key_derivation_output_bytes( &operation, buffer, capacity ) );
Nir Sonnenscheinb46e7ca2018-10-25 14:46:09 +03004984
Gilles Peskine51ae0e42019-05-16 17:31:03 +02004985 TEST_EQUAL( psa_key_derivation_output_bytes( &operation, buffer, capacity ),
David Saadab4ecc272019-02-14 13:48:10 +02004986 PSA_ERROR_INSUFFICIENT_DATA );
Nir Sonnenscheinb46e7ca2018-10-25 14:46:09 +03004987
Nir Sonnenscheinb46e7ca2018-10-25 14:46:09 +03004988exit:
Gilles Peskine51ae0e42019-05-16 17:31:03 +02004989 psa_key_derivation_abort( &operation );
Ronald Cron5425a212020-08-04 14:58:35 +02004990 psa_destroy_key( key );
Gilles Peskine1153e7b2019-05-28 15:10:21 +02004991 PSA_DONE( );
Nir Sonnenscheinb46e7ca2018-10-25 14:46:09 +03004992}
4993/* END_CASE */
4994
Nir Sonnenscheinb46e7ca2018-10-25 14:46:09 +03004995/* BEGIN_CASE */
Gilles Peskinecbe66502019-05-16 16:59:18 +02004996void test_derive_invalid_key_derivation_tests( )
Nir Sonnenscheinb46e7ca2018-10-25 14:46:09 +03004997{
4998 uint8_t output_buffer[16];
4999 size_t buffer_size = 16;
5000 size_t capacity = 0;
Gilles Peskine51ae0e42019-05-16 17:31:03 +02005001 psa_key_derivation_operation_t operation = PSA_KEY_DERIVATION_OPERATION_INIT;
Nir Sonnenscheinb46e7ca2018-10-25 14:46:09 +03005002
Gilles Peskinecf7292e2019-05-16 17:53:40 +02005003 TEST_ASSERT( psa_key_derivation_output_bytes( &operation,
5004 output_buffer, buffer_size )
Jaeden Amerocf2010c2019-02-15 13:05:49 +00005005 == PSA_ERROR_BAD_STATE );
Nir Sonnenscheinb46e7ca2018-10-25 14:46:09 +03005006
Gilles Peskine51ae0e42019-05-16 17:31:03 +02005007 TEST_ASSERT( psa_key_derivation_get_capacity( &operation, &capacity )
Jaeden Amerocf2010c2019-02-15 13:05:49 +00005008 == PSA_ERROR_BAD_STATE );
Nir Sonnenscheinb46e7ca2018-10-25 14:46:09 +03005009
Gilles Peskine51ae0e42019-05-16 17:31:03 +02005010 PSA_ASSERT( psa_key_derivation_abort( &operation ) );
Nir Sonnenscheinb46e7ca2018-10-25 14:46:09 +03005011
Gilles Peskinecf7292e2019-05-16 17:53:40 +02005012 TEST_ASSERT( psa_key_derivation_output_bytes( &operation,
5013 output_buffer, buffer_size )
Jaeden Amerocf2010c2019-02-15 13:05:49 +00005014 == PSA_ERROR_BAD_STATE );
Nir Sonnenscheinb46e7ca2018-10-25 14:46:09 +03005015
Gilles Peskine51ae0e42019-05-16 17:31:03 +02005016 TEST_ASSERT( psa_key_derivation_get_capacity( &operation, &capacity )
Jaeden Amerocf2010c2019-02-15 13:05:49 +00005017 == PSA_ERROR_BAD_STATE );
Nir Sonnenscheinb46e7ca2018-10-25 14:46:09 +03005018
5019exit:
Gilles Peskine51ae0e42019-05-16 17:31:03 +02005020 psa_key_derivation_abort( &operation );
Nir Sonnenscheine5204c92018-10-22 17:24:55 +03005021}
5022/* END_CASE */
5023
5024/* BEGIN_CASE */
Gilles Peskine96ee5c72018-07-12 17:24:54 +02005025void derive_output( int alg_arg,
Gilles Peskine1468da72019-05-29 17:35:49 +02005026 int step1_arg, data_t *input1,
5027 int step2_arg, data_t *input2,
5028 int step3_arg, data_t *input3,
Gilles Peskine96ee5c72018-07-12 17:24:54 +02005029 int requested_capacity_arg,
5030 data_t *expected_output1,
5031 data_t *expected_output2 )
5032{
Gilles Peskine96ee5c72018-07-12 17:24:54 +02005033 psa_algorithm_t alg = alg_arg;
Gilles Peskine1468da72019-05-29 17:35:49 +02005034 psa_key_derivation_step_t steps[] = {step1_arg, step2_arg, step3_arg};
5035 data_t *inputs[] = {input1, input2, input3};
Ronald Cron5425a212020-08-04 14:58:35 +02005036 mbedtls_svc_key_id_t keys[] = { MBEDTLS_SVC_KEY_ID_INIT,
5037 MBEDTLS_SVC_KEY_ID_INIT,
5038 MBEDTLS_SVC_KEY_ID_INIT };
Gilles Peskine96ee5c72018-07-12 17:24:54 +02005039 size_t requested_capacity = requested_capacity_arg;
Gilles Peskine51ae0e42019-05-16 17:31:03 +02005040 psa_key_derivation_operation_t operation = PSA_KEY_DERIVATION_OPERATION_INIT;
Gilles Peskine96ee5c72018-07-12 17:24:54 +02005041 uint8_t *expected_outputs[2] =
5042 {expected_output1->x, expected_output2->x};
5043 size_t output_sizes[2] =
5044 {expected_output1->len, expected_output2->len};
5045 size_t output_buffer_size = 0;
5046 uint8_t *output_buffer = NULL;
5047 size_t expected_capacity;
5048 size_t current_capacity;
Gilles Peskineff5f0e72019-04-18 12:53:30 +02005049 psa_key_attributes_t attributes = PSA_KEY_ATTRIBUTES_INIT;
Gilles Peskine96ee5c72018-07-12 17:24:54 +02005050 psa_status_t status;
Gilles Peskine1468da72019-05-29 17:35:49 +02005051 size_t i;
Gilles Peskine96ee5c72018-07-12 17:24:54 +02005052
5053 for( i = 0; i < ARRAY_LENGTH( expected_outputs ); i++ )
5054 {
5055 if( output_sizes[i] > output_buffer_size )
5056 output_buffer_size = output_sizes[i];
5057 if( output_sizes[i] == 0 )
5058 expected_outputs[i] = NULL;
5059 }
Gilles Peskine8cebbba2018-09-27 13:54:18 +02005060 ASSERT_ALLOC( output_buffer, output_buffer_size );
Gilles Peskine8817f612018-12-18 00:18:46 +01005061 PSA_ASSERT( psa_crypto_init( ) );
Gilles Peskine96ee5c72018-07-12 17:24:54 +02005062
Gilles Peskineff5f0e72019-04-18 12:53:30 +02005063 psa_set_key_usage_flags( &attributes, PSA_KEY_USAGE_DERIVE );
5064 psa_set_key_algorithm( &attributes, alg );
5065 psa_set_key_type( &attributes, PSA_KEY_TYPE_DERIVE );
Gilles Peskine96ee5c72018-07-12 17:24:54 +02005066
Gilles Peskine96ee5c72018-07-12 17:24:54 +02005067 /* Extraction phase. */
Gilles Peskine1468da72019-05-29 17:35:49 +02005068 PSA_ASSERT( psa_key_derivation_setup( &operation, alg ) );
5069 PSA_ASSERT( psa_key_derivation_set_capacity( &operation,
5070 requested_capacity ) );
5071 for( i = 0; i < ARRAY_LENGTH( steps ); i++ )
Gilles Peskineb70a0fd2019-01-07 22:59:38 +01005072 {
Gilles Peskine1468da72019-05-29 17:35:49 +02005073 switch( steps[i] )
5074 {
5075 case 0:
5076 break;
5077 case PSA_KEY_DERIVATION_INPUT_SECRET:
5078 PSA_ASSERT( psa_import_key( &attributes,
5079 inputs[i]->x, inputs[i]->len,
Ronald Cron5425a212020-08-04 14:58:35 +02005080 &keys[i] ) );
gabor-mezei-armceface22021-01-21 12:26:17 +01005081
5082 if ( PSA_ALG_IS_TLS12_PSK_TO_MS( alg ) )
5083 {
5084 PSA_ASSERT( psa_get_key_attributes( keys[i], &attributes ) );
5085 TEST_ASSERT( PSA_BITS_TO_BYTES( psa_get_key_bits( &attributes ) ) <=
5086 PSA_TLS12_PSK_TO_MS_PSK_MAX_SIZE );
5087 }
5088
Gilles Peskine1468da72019-05-29 17:35:49 +02005089 PSA_ASSERT( psa_key_derivation_input_key(
Ronald Cron5425a212020-08-04 14:58:35 +02005090 &operation, steps[i], keys[i] ) );
Gilles Peskine1468da72019-05-29 17:35:49 +02005091 break;
5092 default:
5093 PSA_ASSERT( psa_key_derivation_input_bytes(
5094 &operation, steps[i],
5095 inputs[i]->x, inputs[i]->len ) );
5096 break;
5097 }
Gilles Peskineb70a0fd2019-01-07 22:59:38 +01005098 }
Gilles Peskine1468da72019-05-29 17:35:49 +02005099
Gilles Peskine51ae0e42019-05-16 17:31:03 +02005100 PSA_ASSERT( psa_key_derivation_get_capacity( &operation,
Gilles Peskinecf7292e2019-05-16 17:53:40 +02005101 &current_capacity ) );
Gilles Peskinefe11b722018-12-18 00:24:04 +01005102 TEST_EQUAL( current_capacity, requested_capacity );
Gilles Peskine96ee5c72018-07-12 17:24:54 +02005103 expected_capacity = requested_capacity;
5104
5105 /* Expansion phase. */
5106 for( i = 0; i < ARRAY_LENGTH( expected_outputs ); i++ )
5107 {
5108 /* Read some bytes. */
Gilles Peskine51ae0e42019-05-16 17:31:03 +02005109 status = psa_key_derivation_output_bytes( &operation,
Gilles Peskinecf7292e2019-05-16 17:53:40 +02005110 output_buffer, output_sizes[i] );
Gilles Peskine96ee5c72018-07-12 17:24:54 +02005111 if( expected_capacity == 0 && output_sizes[i] == 0 )
5112 {
5113 /* Reading 0 bytes when 0 bytes are available can go either way. */
5114 TEST_ASSERT( status == PSA_SUCCESS ||
David Saadab4ecc272019-02-14 13:48:10 +02005115 status == PSA_ERROR_INSUFFICIENT_DATA );
Gilles Peskine96ee5c72018-07-12 17:24:54 +02005116 continue;
5117 }
5118 else if( expected_capacity == 0 ||
5119 output_sizes[i] > expected_capacity )
5120 {
5121 /* Capacity exceeded. */
David Saadab4ecc272019-02-14 13:48:10 +02005122 TEST_EQUAL( status, PSA_ERROR_INSUFFICIENT_DATA );
Gilles Peskine96ee5c72018-07-12 17:24:54 +02005123 expected_capacity = 0;
5124 continue;
5125 }
5126 /* Success. Check the read data. */
Gilles Peskine8817f612018-12-18 00:18:46 +01005127 PSA_ASSERT( status );
Gilles Peskine96ee5c72018-07-12 17:24:54 +02005128 if( output_sizes[i] != 0 )
Gilles Peskine0dfba2d2018-12-18 00:40:50 +01005129 ASSERT_COMPARE( output_buffer, output_sizes[i],
5130 expected_outputs[i], output_sizes[i] );
Gilles Peskine51ae0e42019-05-16 17:31:03 +02005131 /* Check the operation status. */
Gilles Peskine96ee5c72018-07-12 17:24:54 +02005132 expected_capacity -= output_sizes[i];
Gilles Peskine51ae0e42019-05-16 17:31:03 +02005133 PSA_ASSERT( psa_key_derivation_get_capacity( &operation,
Gilles Peskinecf7292e2019-05-16 17:53:40 +02005134 &current_capacity ) );
Gilles Peskinefe11b722018-12-18 00:24:04 +01005135 TEST_EQUAL( expected_capacity, current_capacity );
Gilles Peskine96ee5c72018-07-12 17:24:54 +02005136 }
Gilles Peskine51ae0e42019-05-16 17:31:03 +02005137 PSA_ASSERT( psa_key_derivation_abort( &operation ) );
Gilles Peskine96ee5c72018-07-12 17:24:54 +02005138
5139exit:
5140 mbedtls_free( output_buffer );
Gilles Peskine51ae0e42019-05-16 17:31:03 +02005141 psa_key_derivation_abort( &operation );
Ronald Cron5425a212020-08-04 14:58:35 +02005142 for( i = 0; i < ARRAY_LENGTH( keys ); i++ )
5143 psa_destroy_key( keys[i] );
Gilles Peskine1153e7b2019-05-28 15:10:21 +02005144 PSA_DONE( );
Gilles Peskine96ee5c72018-07-12 17:24:54 +02005145}
5146/* END_CASE */
5147
5148/* BEGIN_CASE */
Gilles Peskined54931c2018-07-17 21:06:59 +02005149void derive_full( int alg_arg,
5150 data_t *key_data,
Janos Follath47f27ed2019-06-25 13:24:52 +01005151 data_t *input1,
5152 data_t *input2,
Gilles Peskined54931c2018-07-17 21:06:59 +02005153 int requested_capacity_arg )
5154{
Ronald Cron5425a212020-08-04 14:58:35 +02005155 mbedtls_svc_key_id_t key = MBEDTLS_SVC_KEY_ID_INIT;
Gilles Peskined54931c2018-07-17 21:06:59 +02005156 psa_algorithm_t alg = alg_arg;
5157 size_t requested_capacity = requested_capacity_arg;
Gilles Peskine51ae0e42019-05-16 17:31:03 +02005158 psa_key_derivation_operation_t operation = PSA_KEY_DERIVATION_OPERATION_INIT;
Gilles Peskined54931c2018-07-17 21:06:59 +02005159 unsigned char output_buffer[16];
5160 size_t expected_capacity = requested_capacity;
5161 size_t current_capacity;
Gilles Peskineff5f0e72019-04-18 12:53:30 +02005162 psa_key_attributes_t attributes = PSA_KEY_ATTRIBUTES_INIT;
Gilles Peskined54931c2018-07-17 21:06:59 +02005163
Gilles Peskine8817f612018-12-18 00:18:46 +01005164 PSA_ASSERT( psa_crypto_init( ) );
Gilles Peskined54931c2018-07-17 21:06:59 +02005165
Gilles Peskineff5f0e72019-04-18 12:53:30 +02005166 psa_set_key_usage_flags( &attributes, PSA_KEY_USAGE_DERIVE );
5167 psa_set_key_algorithm( &attributes, alg );
5168 psa_set_key_type( &attributes, PSA_KEY_TYPE_DERIVE );
Gilles Peskined54931c2018-07-17 21:06:59 +02005169
Gilles Peskine049c7532019-05-15 20:22:09 +02005170 PSA_ASSERT( psa_import_key( &attributes, key_data->x, key_data->len,
Ronald Cron5425a212020-08-04 14:58:35 +02005171 &key ) );
Gilles Peskined54931c2018-07-17 21:06:59 +02005172
Gilles Peskinec18e25f2021-02-12 23:48:20 +01005173 if( !mbedtls_test_psa_setup_key_derivation_wrap( &operation, key, alg,
5174 input1->x, input1->len,
5175 input2->x, input2->len,
5176 requested_capacity ) )
Janos Follathf2815ea2019-07-03 12:41:36 +01005177 goto exit;
Janos Follath47f27ed2019-06-25 13:24:52 +01005178
Gilles Peskine51ae0e42019-05-16 17:31:03 +02005179 PSA_ASSERT( psa_key_derivation_get_capacity( &operation,
Gilles Peskinecf7292e2019-05-16 17:53:40 +02005180 &current_capacity ) );
Gilles Peskinefe11b722018-12-18 00:24:04 +01005181 TEST_EQUAL( current_capacity, expected_capacity );
Gilles Peskined54931c2018-07-17 21:06:59 +02005182
5183 /* Expansion phase. */
5184 while( current_capacity > 0 )
5185 {
5186 size_t read_size = sizeof( output_buffer );
5187 if( read_size > current_capacity )
5188 read_size = current_capacity;
Gilles Peskine51ae0e42019-05-16 17:31:03 +02005189 PSA_ASSERT( psa_key_derivation_output_bytes( &operation,
Gilles Peskinecf7292e2019-05-16 17:53:40 +02005190 output_buffer,
5191 read_size ) );
Gilles Peskined54931c2018-07-17 21:06:59 +02005192 expected_capacity -= read_size;
Gilles Peskine51ae0e42019-05-16 17:31:03 +02005193 PSA_ASSERT( psa_key_derivation_get_capacity( &operation,
Gilles Peskinecf7292e2019-05-16 17:53:40 +02005194 &current_capacity ) );
Gilles Peskinefe11b722018-12-18 00:24:04 +01005195 TEST_EQUAL( current_capacity, expected_capacity );
Gilles Peskined54931c2018-07-17 21:06:59 +02005196 }
5197
Gilles Peskine51ae0e42019-05-16 17:31:03 +02005198 /* Check that the operation refuses to go over capacity. */
5199 TEST_EQUAL( psa_key_derivation_output_bytes( &operation, output_buffer, 1 ),
David Saadab4ecc272019-02-14 13:48:10 +02005200 PSA_ERROR_INSUFFICIENT_DATA );
Gilles Peskined54931c2018-07-17 21:06:59 +02005201
Gilles Peskine51ae0e42019-05-16 17:31:03 +02005202 PSA_ASSERT( psa_key_derivation_abort( &operation ) );
Gilles Peskined54931c2018-07-17 21:06:59 +02005203
5204exit:
Gilles Peskine51ae0e42019-05-16 17:31:03 +02005205 psa_key_derivation_abort( &operation );
Ronald Cron5425a212020-08-04 14:58:35 +02005206 psa_destroy_key( key );
Gilles Peskine1153e7b2019-05-28 15:10:21 +02005207 PSA_DONE( );
Gilles Peskined54931c2018-07-17 21:06:59 +02005208}
5209/* END_CASE */
5210
Janos Follathe60c9052019-07-03 13:51:30 +01005211/* BEGIN_CASE */
Gilles Peskine0386fba2018-07-12 17:29:22 +02005212void derive_key_exercise( int alg_arg,
5213 data_t *key_data,
Janos Follathe60c9052019-07-03 13:51:30 +01005214 data_t *input1,
5215 data_t *input2,
Gilles Peskine0386fba2018-07-12 17:29:22 +02005216 int derived_type_arg,
5217 int derived_bits_arg,
5218 int derived_usage_arg,
5219 int derived_alg_arg )
5220{
Ronald Cron5425a212020-08-04 14:58:35 +02005221 mbedtls_svc_key_id_t base_key = MBEDTLS_SVC_KEY_ID_INIT;
5222 mbedtls_svc_key_id_t derived_key = MBEDTLS_SVC_KEY_ID_INIT;
Gilles Peskine0386fba2018-07-12 17:29:22 +02005223 psa_algorithm_t alg = alg_arg;
5224 psa_key_type_t derived_type = derived_type_arg;
5225 size_t derived_bits = derived_bits_arg;
5226 psa_key_usage_t derived_usage = derived_usage_arg;
5227 psa_algorithm_t derived_alg = derived_alg_arg;
5228 size_t capacity = PSA_BITS_TO_BYTES( derived_bits );
Gilles Peskine51ae0e42019-05-16 17:31:03 +02005229 psa_key_derivation_operation_t operation = PSA_KEY_DERIVATION_OPERATION_INIT;
Gilles Peskineff5f0e72019-04-18 12:53:30 +02005230 psa_key_attributes_t attributes = PSA_KEY_ATTRIBUTES_INIT;
Gilles Peskine8c8f2ab2019-04-18 21:44:46 +02005231 psa_key_attributes_t got_attributes = PSA_KEY_ATTRIBUTES_INIT;
Gilles Peskine0386fba2018-07-12 17:29:22 +02005232
Gilles Peskine8817f612018-12-18 00:18:46 +01005233 PSA_ASSERT( psa_crypto_init( ) );
Gilles Peskine0386fba2018-07-12 17:29:22 +02005234
Gilles Peskineff5f0e72019-04-18 12:53:30 +02005235 psa_set_key_usage_flags( &attributes, PSA_KEY_USAGE_DERIVE );
5236 psa_set_key_algorithm( &attributes, alg );
5237 psa_set_key_type( &attributes, PSA_KEY_TYPE_DERIVE );
Gilles Peskine049c7532019-05-15 20:22:09 +02005238 PSA_ASSERT( psa_import_key( &attributes, key_data->x, key_data->len,
Ronald Cron5425a212020-08-04 14:58:35 +02005239 &base_key ) );
Gilles Peskine0386fba2018-07-12 17:29:22 +02005240
5241 /* Derive a key. */
Gilles Peskinec18e25f2021-02-12 23:48:20 +01005242 if ( mbedtls_test_psa_setup_key_derivation_wrap( &operation, base_key, alg,
5243 input1->x, input1->len,
5244 input2->x, input2->len,
5245 capacity ) )
Janos Follathe60c9052019-07-03 13:51:30 +01005246 goto exit;
5247
Gilles Peskineff5f0e72019-04-18 12:53:30 +02005248 psa_set_key_usage_flags( &attributes, derived_usage );
5249 psa_set_key_algorithm( &attributes, derived_alg );
5250 psa_set_key_type( &attributes, derived_type );
Gilles Peskine3a4f1f82019-04-26 13:49:28 +02005251 psa_set_key_bits( &attributes, derived_bits );
Gilles Peskine51ae0e42019-05-16 17:31:03 +02005252 PSA_ASSERT( psa_key_derivation_output_key( &attributes, &operation,
Ronald Cron5425a212020-08-04 14:58:35 +02005253 &derived_key ) );
Gilles Peskine0386fba2018-07-12 17:29:22 +02005254
5255 /* Test the key information */
Ronald Cron5425a212020-08-04 14:58:35 +02005256 PSA_ASSERT( psa_get_key_attributes( derived_key, &got_attributes ) );
Gilles Peskine8c8f2ab2019-04-18 21:44:46 +02005257 TEST_EQUAL( psa_get_key_type( &got_attributes ), derived_type );
5258 TEST_EQUAL( psa_get_key_bits( &got_attributes ), derived_bits );
Gilles Peskine0386fba2018-07-12 17:29:22 +02005259
5260 /* Exercise the derived key. */
Gilles Peskinec18e25f2021-02-12 23:48:20 +01005261 if( ! mbedtls_test_psa_exercise_key( derived_key, derived_usage, derived_alg ) )
Gilles Peskine0386fba2018-07-12 17:29:22 +02005262 goto exit;
5263
5264exit:
Ronald Cron3a4f0e32020-11-19 17:55:23 +01005265 /*
5266 * Key attributes may have been returned by psa_get_key_attributes()
5267 * thus reset them as required.
5268 */
Gilles Peskinea1ace9c2019-04-26 16:03:33 +02005269 psa_reset_key_attributes( &got_attributes );
Ronald Cron3a4f0e32020-11-19 17:55:23 +01005270
5271 psa_key_derivation_abort( &operation );
Ronald Cron5425a212020-08-04 14:58:35 +02005272 psa_destroy_key( base_key );
5273 psa_destroy_key( derived_key );
Gilles Peskine1153e7b2019-05-28 15:10:21 +02005274 PSA_DONE( );
Gilles Peskine0386fba2018-07-12 17:29:22 +02005275}
5276/* END_CASE */
5277
Janos Follath42fd8882019-07-03 14:17:09 +01005278/* BEGIN_CASE */
Gilles Peskine0386fba2018-07-12 17:29:22 +02005279void derive_key_export( int alg_arg,
5280 data_t *key_data,
Janos Follath42fd8882019-07-03 14:17:09 +01005281 data_t *input1,
5282 data_t *input2,
Gilles Peskine0386fba2018-07-12 17:29:22 +02005283 int bytes1_arg,
5284 int bytes2_arg )
5285{
Ronald Cron5425a212020-08-04 14:58:35 +02005286 mbedtls_svc_key_id_t base_key = MBEDTLS_SVC_KEY_ID_INIT;
5287 mbedtls_svc_key_id_t derived_key = MBEDTLS_SVC_KEY_ID_INIT;
Gilles Peskine0386fba2018-07-12 17:29:22 +02005288 psa_algorithm_t alg = alg_arg;
5289 size_t bytes1 = bytes1_arg;
5290 size_t bytes2 = bytes2_arg;
5291 size_t capacity = bytes1 + bytes2;
Gilles Peskine51ae0e42019-05-16 17:31:03 +02005292 psa_key_derivation_operation_t operation = PSA_KEY_DERIVATION_OPERATION_INIT;
Gilles Peskine8cebbba2018-09-27 13:54:18 +02005293 uint8_t *output_buffer = NULL;
5294 uint8_t *export_buffer = NULL;
Gilles Peskineff5f0e72019-04-18 12:53:30 +02005295 psa_key_attributes_t base_attributes = PSA_KEY_ATTRIBUTES_INIT;
5296 psa_key_attributes_t derived_attributes = PSA_KEY_ATTRIBUTES_INIT;
Gilles Peskine0386fba2018-07-12 17:29:22 +02005297 size_t length;
5298
Gilles Peskine8cebbba2018-09-27 13:54:18 +02005299 ASSERT_ALLOC( output_buffer, capacity );
5300 ASSERT_ALLOC( export_buffer, capacity );
Gilles Peskine8817f612018-12-18 00:18:46 +01005301 PSA_ASSERT( psa_crypto_init( ) );
Gilles Peskine0386fba2018-07-12 17:29:22 +02005302
Gilles Peskineff5f0e72019-04-18 12:53:30 +02005303 psa_set_key_usage_flags( &base_attributes, PSA_KEY_USAGE_DERIVE );
5304 psa_set_key_algorithm( &base_attributes, alg );
5305 psa_set_key_type( &base_attributes, PSA_KEY_TYPE_DERIVE );
Gilles Peskine049c7532019-05-15 20:22:09 +02005306 PSA_ASSERT( psa_import_key( &base_attributes, key_data->x, key_data->len,
Ronald Cron5425a212020-08-04 14:58:35 +02005307 &base_key ) );
Gilles Peskine0386fba2018-07-12 17:29:22 +02005308
5309 /* Derive some material and output it. */
Gilles Peskinec18e25f2021-02-12 23:48:20 +01005310 if( !mbedtls_test_psa_setup_key_derivation_wrap( &operation, base_key, alg,
5311 input1->x, input1->len,
5312 input2->x, input2->len,
5313 capacity ) )
Janos Follath42fd8882019-07-03 14:17:09 +01005314 goto exit;
5315
Gilles Peskine51ae0e42019-05-16 17:31:03 +02005316 PSA_ASSERT( psa_key_derivation_output_bytes( &operation,
Gilles Peskinecf7292e2019-05-16 17:53:40 +02005317 output_buffer,
5318 capacity ) );
Gilles Peskine51ae0e42019-05-16 17:31:03 +02005319 PSA_ASSERT( psa_key_derivation_abort( &operation ) );
Gilles Peskine0386fba2018-07-12 17:29:22 +02005320
5321 /* Derive the same output again, but this time store it in key objects. */
Gilles Peskinec18e25f2021-02-12 23:48:20 +01005322 if( !mbedtls_test_psa_setup_key_derivation_wrap( &operation, base_key, alg,
5323 input1->x, input1->len,
5324 input2->x, input2->len,
5325 capacity ) )
Janos Follath42fd8882019-07-03 14:17:09 +01005326 goto exit;
5327
Gilles Peskineff5f0e72019-04-18 12:53:30 +02005328 psa_set_key_usage_flags( &derived_attributes, PSA_KEY_USAGE_EXPORT );
5329 psa_set_key_algorithm( &derived_attributes, 0 );
5330 psa_set_key_type( &derived_attributes, PSA_KEY_TYPE_RAW_DATA );
Gilles Peskine3a4f1f82019-04-26 13:49:28 +02005331 psa_set_key_bits( &derived_attributes, PSA_BYTES_TO_BITS( bytes1 ) );
Gilles Peskine51ae0e42019-05-16 17:31:03 +02005332 PSA_ASSERT( psa_key_derivation_output_key( &derived_attributes, &operation,
Ronald Cron5425a212020-08-04 14:58:35 +02005333 &derived_key ) );
5334 PSA_ASSERT( psa_export_key( derived_key,
Gilles Peskine8817f612018-12-18 00:18:46 +01005335 export_buffer, bytes1,
5336 &length ) );
Gilles Peskinefe11b722018-12-18 00:24:04 +01005337 TEST_EQUAL( length, bytes1 );
Ronald Cron5425a212020-08-04 14:58:35 +02005338 PSA_ASSERT( psa_destroy_key( derived_key ) );
Gilles Peskine3a4f1f82019-04-26 13:49:28 +02005339 psa_set_key_bits( &derived_attributes, PSA_BYTES_TO_BITS( bytes2 ) );
Gilles Peskine51ae0e42019-05-16 17:31:03 +02005340 PSA_ASSERT( psa_key_derivation_output_key( &derived_attributes, &operation,
Ronald Cron5425a212020-08-04 14:58:35 +02005341 &derived_key ) );
5342 PSA_ASSERT( psa_export_key( derived_key,
Gilles Peskine8817f612018-12-18 00:18:46 +01005343 export_buffer + bytes1, bytes2,
5344 &length ) );
Gilles Peskinefe11b722018-12-18 00:24:04 +01005345 TEST_EQUAL( length, bytes2 );
Gilles Peskine0386fba2018-07-12 17:29:22 +02005346
5347 /* Compare the outputs from the two runs. */
Gilles Peskine0dfba2d2018-12-18 00:40:50 +01005348 ASSERT_COMPARE( output_buffer, bytes1 + bytes2,
5349 export_buffer, capacity );
Gilles Peskine0386fba2018-07-12 17:29:22 +02005350
5351exit:
5352 mbedtls_free( output_buffer );
5353 mbedtls_free( export_buffer );
Gilles Peskine51ae0e42019-05-16 17:31:03 +02005354 psa_key_derivation_abort( &operation );
Ronald Cron5425a212020-08-04 14:58:35 +02005355 psa_destroy_key( base_key );
5356 psa_destroy_key( derived_key );
Gilles Peskine1153e7b2019-05-28 15:10:21 +02005357 PSA_DONE( );
Gilles Peskine0386fba2018-07-12 17:29:22 +02005358}
5359/* END_CASE */
5360
5361/* BEGIN_CASE */
Gilles Peskine7c227ae2019-07-31 15:14:44 +02005362void derive_key( int alg_arg,
5363 data_t *key_data, data_t *input1, data_t *input2,
5364 int type_arg, int bits_arg,
Steven Cooreman83fdb702021-01-21 14:24:39 +01005365 int expected_status_arg,
5366 int is_large_output )
Gilles Peskinec744d992019-07-30 17:26:54 +02005367{
Ronald Cron5425a212020-08-04 14:58:35 +02005368 mbedtls_svc_key_id_t base_key = MBEDTLS_SVC_KEY_ID_INIT;
5369 mbedtls_svc_key_id_t derived_key = MBEDTLS_SVC_KEY_ID_INIT;
Gilles Peskinec744d992019-07-30 17:26:54 +02005370 psa_algorithm_t alg = alg_arg;
Gilles Peskine7c227ae2019-07-31 15:14:44 +02005371 psa_key_type_t type = type_arg;
Gilles Peskinec744d992019-07-30 17:26:54 +02005372 size_t bits = bits_arg;
5373 psa_status_t expected_status = expected_status_arg;
5374 psa_key_derivation_operation_t operation = PSA_KEY_DERIVATION_OPERATION_INIT;
5375 psa_key_attributes_t base_attributes = PSA_KEY_ATTRIBUTES_INIT;
5376 psa_key_attributes_t derived_attributes = PSA_KEY_ATTRIBUTES_INIT;
5377
5378 PSA_ASSERT( psa_crypto_init( ) );
5379
5380 psa_set_key_usage_flags( &base_attributes, PSA_KEY_USAGE_DERIVE );
5381 psa_set_key_algorithm( &base_attributes, alg );
5382 psa_set_key_type( &base_attributes, PSA_KEY_TYPE_DERIVE );
5383 PSA_ASSERT( psa_import_key( &base_attributes, key_data->x, key_data->len,
Ronald Cron5425a212020-08-04 14:58:35 +02005384 &base_key ) );
Gilles Peskinec744d992019-07-30 17:26:54 +02005385
Gilles Peskinec18e25f2021-02-12 23:48:20 +01005386 if( !mbedtls_test_psa_setup_key_derivation_wrap( &operation, base_key, alg,
5387 input1->x, input1->len,
5388 input2->x, input2->len,
5389 SIZE_MAX ) )
Gilles Peskinec744d992019-07-30 17:26:54 +02005390 goto exit;
5391
5392 psa_set_key_usage_flags( &derived_attributes, PSA_KEY_USAGE_EXPORT );
5393 psa_set_key_algorithm( &derived_attributes, 0 );
Gilles Peskine7c227ae2019-07-31 15:14:44 +02005394 psa_set_key_type( &derived_attributes, type );
Gilles Peskinec744d992019-07-30 17:26:54 +02005395 psa_set_key_bits( &derived_attributes, bits );
Steven Cooreman83fdb702021-01-21 14:24:39 +01005396
5397 psa_status_t status =
5398 psa_key_derivation_output_key( &derived_attributes,
5399 &operation,
5400 &derived_key );
5401 if( is_large_output > 0 )
5402 TEST_ASSUME( status != PSA_ERROR_INSUFFICIENT_MEMORY );
5403 TEST_EQUAL( status, expected_status );
Gilles Peskinec744d992019-07-30 17:26:54 +02005404
5405exit:
5406 psa_key_derivation_abort( &operation );
Ronald Cron5425a212020-08-04 14:58:35 +02005407 psa_destroy_key( base_key );
5408 psa_destroy_key( derived_key );
Gilles Peskinec744d992019-07-30 17:26:54 +02005409 PSA_DONE( );
5410}
5411/* END_CASE */
5412
5413/* BEGIN_CASE */
Gilles Peskine01d718c2018-09-18 12:01:02 +02005414void key_agreement_setup( int alg_arg,
Steven Cooremance48e852020-10-05 16:02:45 +02005415 int our_key_type_arg, int our_key_alg_arg,
5416 data_t *our_key_data, data_t *peer_key_data,
Gilles Peskine01d718c2018-09-18 12:01:02 +02005417 int expected_status_arg )
5418{
Ronald Cron5425a212020-08-04 14:58:35 +02005419 mbedtls_svc_key_id_t our_key = MBEDTLS_SVC_KEY_ID_INIT;
Gilles Peskine01d718c2018-09-18 12:01:02 +02005420 psa_algorithm_t alg = alg_arg;
Steven Cooremanfa5e6312020-10-15 17:07:12 +02005421 psa_algorithm_t our_key_alg = our_key_alg_arg;
Gilles Peskine01d718c2018-09-18 12:01:02 +02005422 psa_key_type_t our_key_type = our_key_type_arg;
Gilles Peskine51ae0e42019-05-16 17:31:03 +02005423 psa_key_derivation_operation_t operation = PSA_KEY_DERIVATION_OPERATION_INIT;
Gilles Peskineff5f0e72019-04-18 12:53:30 +02005424 psa_key_attributes_t attributes = PSA_KEY_ATTRIBUTES_INIT;
Gilles Peskine77f40d82019-04-11 21:27:06 +02005425 psa_status_t expected_status = expected_status_arg;
5426 psa_status_t status;
Gilles Peskine01d718c2018-09-18 12:01:02 +02005427
Gilles Peskine8817f612018-12-18 00:18:46 +01005428 PSA_ASSERT( psa_crypto_init( ) );
Gilles Peskine01d718c2018-09-18 12:01:02 +02005429
Gilles Peskineff5f0e72019-04-18 12:53:30 +02005430 psa_set_key_usage_flags( &attributes, PSA_KEY_USAGE_DERIVE );
Steven Cooremanfa5e6312020-10-15 17:07:12 +02005431 psa_set_key_algorithm( &attributes, our_key_alg );
Gilles Peskineff5f0e72019-04-18 12:53:30 +02005432 psa_set_key_type( &attributes, our_key_type );
Gilles Peskine049c7532019-05-15 20:22:09 +02005433 PSA_ASSERT( psa_import_key( &attributes,
5434 our_key_data->x, our_key_data->len,
5435 &our_key ) );
Gilles Peskine01d718c2018-09-18 12:01:02 +02005436
Gilles Peskine77f40d82019-04-11 21:27:06 +02005437 /* The tests currently include inputs that should fail at either step.
5438 * Test cases that fail at the setup step should be changed to call
5439 * key_derivation_setup instead, and this function should be renamed
5440 * to key_agreement_fail. */
Gilles Peskine51ae0e42019-05-16 17:31:03 +02005441 status = psa_key_derivation_setup( &operation, alg );
Gilles Peskine77f40d82019-04-11 21:27:06 +02005442 if( status == PSA_SUCCESS )
5443 {
Gilles Peskinecf7292e2019-05-16 17:53:40 +02005444 TEST_EQUAL( psa_key_derivation_key_agreement(
5445 &operation, PSA_KEY_DERIVATION_INPUT_SECRET,
5446 our_key,
5447 peer_key_data->x, peer_key_data->len ),
Gilles Peskine77f40d82019-04-11 21:27:06 +02005448 expected_status );
5449 }
5450 else
5451 {
5452 TEST_ASSERT( status == expected_status );
5453 }
Gilles Peskine01d718c2018-09-18 12:01:02 +02005454
5455exit:
Gilles Peskine51ae0e42019-05-16 17:31:03 +02005456 psa_key_derivation_abort( &operation );
Gilles Peskine01d718c2018-09-18 12:01:02 +02005457 psa_destroy_key( our_key );
Gilles Peskine1153e7b2019-05-28 15:10:21 +02005458 PSA_DONE( );
Gilles Peskine01d718c2018-09-18 12:01:02 +02005459}
5460/* END_CASE */
5461
5462/* BEGIN_CASE */
Gilles Peskinef0cba732019-04-11 22:12:38 +02005463void raw_key_agreement( int alg_arg,
5464 int our_key_type_arg, data_t *our_key_data,
5465 data_t *peer_key_data,
5466 data_t *expected_output )
5467{
Ronald Cron5425a212020-08-04 14:58:35 +02005468 mbedtls_svc_key_id_t our_key = MBEDTLS_SVC_KEY_ID_INIT;
Gilles Peskinef0cba732019-04-11 22:12:38 +02005469 psa_algorithm_t alg = alg_arg;
5470 psa_key_type_t our_key_type = our_key_type_arg;
Gilles Peskineff5f0e72019-04-18 12:53:30 +02005471 psa_key_attributes_t attributes = PSA_KEY_ATTRIBUTES_INIT;
Gilles Peskinef0cba732019-04-11 22:12:38 +02005472 unsigned char *output = NULL;
5473 size_t output_length = ~0;
gabor-mezei-armceface22021-01-21 12:26:17 +01005474 size_t key_bits;
Gilles Peskinef0cba732019-04-11 22:12:38 +02005475
5476 ASSERT_ALLOC( output, expected_output->len );
5477 PSA_ASSERT( psa_crypto_init( ) );
5478
Gilles Peskineff5f0e72019-04-18 12:53:30 +02005479 psa_set_key_usage_flags( &attributes, PSA_KEY_USAGE_DERIVE );
5480 psa_set_key_algorithm( &attributes, alg );
5481 psa_set_key_type( &attributes, our_key_type );
Gilles Peskine049c7532019-05-15 20:22:09 +02005482 PSA_ASSERT( psa_import_key( &attributes,
5483 our_key_data->x, our_key_data->len,
5484 &our_key ) );
Gilles Peskinef0cba732019-04-11 22:12:38 +02005485
gabor-mezei-armceface22021-01-21 12:26:17 +01005486 PSA_ASSERT( psa_get_key_attributes( our_key, &attributes ) );
5487 key_bits = psa_get_key_bits( &attributes );
5488
Gilles Peskinebe697d82019-05-16 18:00:41 +02005489 PSA_ASSERT( psa_raw_key_agreement( alg, our_key,
5490 peer_key_data->x, peer_key_data->len,
5491 output, expected_output->len,
5492 &output_length ) );
Gilles Peskinef0cba732019-04-11 22:12:38 +02005493 ASSERT_COMPARE( output, output_length,
5494 expected_output->x, expected_output->len );
gabor-mezei-armceface22021-01-21 12:26:17 +01005495 TEST_ASSERT( output_length <=
5496 PSA_RAW_KEY_AGREEMENT_OUTPUT_SIZE( our_key_type, key_bits ) );
5497 TEST_ASSERT( output_length <=
5498 PSA_RAW_KEY_AGREEMENT_OUTPUT_MAX_SIZE );
Gilles Peskinef0cba732019-04-11 22:12:38 +02005499
5500exit:
5501 mbedtls_free( output );
5502 psa_destroy_key( our_key );
Gilles Peskine1153e7b2019-05-28 15:10:21 +02005503 PSA_DONE( );
Gilles Peskinef0cba732019-04-11 22:12:38 +02005504}
5505/* END_CASE */
5506
5507/* BEGIN_CASE */
Gilles Peskine59685592018-09-18 12:11:34 +02005508void key_agreement_capacity( int alg_arg,
5509 int our_key_type_arg, data_t *our_key_data,
5510 data_t *peer_key_data,
5511 int expected_capacity_arg )
5512{
Ronald Cron5425a212020-08-04 14:58:35 +02005513 mbedtls_svc_key_id_t our_key = MBEDTLS_SVC_KEY_ID_INIT;
Gilles Peskine59685592018-09-18 12:11:34 +02005514 psa_algorithm_t alg = alg_arg;
5515 psa_key_type_t our_key_type = our_key_type_arg;
Gilles Peskine51ae0e42019-05-16 17:31:03 +02005516 psa_key_derivation_operation_t operation = PSA_KEY_DERIVATION_OPERATION_INIT;
Gilles Peskineff5f0e72019-04-18 12:53:30 +02005517 psa_key_attributes_t attributes = PSA_KEY_ATTRIBUTES_INIT;
Gilles Peskine59685592018-09-18 12:11:34 +02005518 size_t actual_capacity;
Gilles Peskinebf491972018-10-25 22:36:12 +02005519 unsigned char output[16];
Gilles Peskine59685592018-09-18 12:11:34 +02005520
Gilles Peskine8817f612018-12-18 00:18:46 +01005521 PSA_ASSERT( psa_crypto_init( ) );
Gilles Peskine59685592018-09-18 12:11:34 +02005522
Gilles Peskineff5f0e72019-04-18 12:53:30 +02005523 psa_set_key_usage_flags( &attributes, PSA_KEY_USAGE_DERIVE );
5524 psa_set_key_algorithm( &attributes, alg );
5525 psa_set_key_type( &attributes, our_key_type );
Gilles Peskine049c7532019-05-15 20:22:09 +02005526 PSA_ASSERT( psa_import_key( &attributes,
5527 our_key_data->x, our_key_data->len,
5528 &our_key ) );
Gilles Peskine59685592018-09-18 12:11:34 +02005529
Gilles Peskine51ae0e42019-05-16 17:31:03 +02005530 PSA_ASSERT( psa_key_derivation_setup( &operation, alg ) );
Gilles Peskinecf7292e2019-05-16 17:53:40 +02005531 PSA_ASSERT( psa_key_derivation_key_agreement(
5532 &operation,
5533 PSA_KEY_DERIVATION_INPUT_SECRET, our_key,
5534 peer_key_data->x, peer_key_data->len ) );
Gilles Peskinef8a9d942019-04-11 22:13:20 +02005535 if( PSA_ALG_IS_HKDF( PSA_ALG_KEY_AGREEMENT_GET_KDF( alg ) ) )
5536 {
5537 /* The test data is for info="" */
Gilles Peskine51ae0e42019-05-16 17:31:03 +02005538 PSA_ASSERT( psa_key_derivation_input_bytes( &operation,
Gilles Peskine03410b52019-05-16 16:05:19 +02005539 PSA_KEY_DERIVATION_INPUT_INFO,
Gilles Peskinef8a9d942019-04-11 22:13:20 +02005540 NULL, 0 ) );
5541 }
Gilles Peskine59685592018-09-18 12:11:34 +02005542
Gilles Peskinebf491972018-10-25 22:36:12 +02005543 /* Test the advertized capacity. */
Gilles Peskinea99d3fb2019-05-16 15:28:51 +02005544 PSA_ASSERT( psa_key_derivation_get_capacity(
Gilles Peskine51ae0e42019-05-16 17:31:03 +02005545 &operation, &actual_capacity ) );
Gilles Peskinefe11b722018-12-18 00:24:04 +01005546 TEST_EQUAL( actual_capacity, (size_t) expected_capacity_arg );
Gilles Peskine59685592018-09-18 12:11:34 +02005547
Gilles Peskinebf491972018-10-25 22:36:12 +02005548 /* Test the actual capacity by reading the output. */
5549 while( actual_capacity > sizeof( output ) )
5550 {
Gilles Peskine51ae0e42019-05-16 17:31:03 +02005551 PSA_ASSERT( psa_key_derivation_output_bytes( &operation,
Gilles Peskinecf7292e2019-05-16 17:53:40 +02005552 output, sizeof( output ) ) );
Gilles Peskinebf491972018-10-25 22:36:12 +02005553 actual_capacity -= sizeof( output );
5554 }
Gilles Peskine51ae0e42019-05-16 17:31:03 +02005555 PSA_ASSERT( psa_key_derivation_output_bytes( &operation,
Gilles Peskinecf7292e2019-05-16 17:53:40 +02005556 output, actual_capacity ) );
Gilles Peskine51ae0e42019-05-16 17:31:03 +02005557 TEST_EQUAL( psa_key_derivation_output_bytes( &operation, output, 1 ),
David Saadab4ecc272019-02-14 13:48:10 +02005558 PSA_ERROR_INSUFFICIENT_DATA );
Gilles Peskinebf491972018-10-25 22:36:12 +02005559
Gilles Peskine59685592018-09-18 12:11:34 +02005560exit:
Gilles Peskine51ae0e42019-05-16 17:31:03 +02005561 psa_key_derivation_abort( &operation );
Gilles Peskine59685592018-09-18 12:11:34 +02005562 psa_destroy_key( our_key );
Gilles Peskine1153e7b2019-05-28 15:10:21 +02005563 PSA_DONE( );
Gilles Peskine59685592018-09-18 12:11:34 +02005564}
5565/* END_CASE */
5566
5567/* BEGIN_CASE */
5568void key_agreement_output( int alg_arg,
5569 int our_key_type_arg, data_t *our_key_data,
5570 data_t *peer_key_data,
Gilles Peskine3ec8ed82018-10-25 22:37:15 +02005571 data_t *expected_output1, data_t *expected_output2 )
Gilles Peskine59685592018-09-18 12:11:34 +02005572{
Ronald Cron5425a212020-08-04 14:58:35 +02005573 mbedtls_svc_key_id_t our_key = MBEDTLS_SVC_KEY_ID_INIT;
Gilles Peskine59685592018-09-18 12:11:34 +02005574 psa_algorithm_t alg = alg_arg;
5575 psa_key_type_t our_key_type = our_key_type_arg;
Gilles Peskine51ae0e42019-05-16 17:31:03 +02005576 psa_key_derivation_operation_t operation = PSA_KEY_DERIVATION_OPERATION_INIT;
Gilles Peskineff5f0e72019-04-18 12:53:30 +02005577 psa_key_attributes_t attributes = PSA_KEY_ATTRIBUTES_INIT;
Gilles Peskine3ec8ed82018-10-25 22:37:15 +02005578 uint8_t *actual_output = NULL;
Gilles Peskine59685592018-09-18 12:11:34 +02005579
Gilles Peskine3ec8ed82018-10-25 22:37:15 +02005580 ASSERT_ALLOC( actual_output, MAX( expected_output1->len,
5581 expected_output2->len ) );
Gilles Peskine59685592018-09-18 12:11:34 +02005582
Gilles Peskine8817f612018-12-18 00:18:46 +01005583 PSA_ASSERT( psa_crypto_init( ) );
Gilles Peskine59685592018-09-18 12:11:34 +02005584
Gilles Peskineff5f0e72019-04-18 12:53:30 +02005585 psa_set_key_usage_flags( &attributes, PSA_KEY_USAGE_DERIVE );
5586 psa_set_key_algorithm( &attributes, alg );
5587 psa_set_key_type( &attributes, our_key_type );
Gilles Peskine049c7532019-05-15 20:22:09 +02005588 PSA_ASSERT( psa_import_key( &attributes,
5589 our_key_data->x, our_key_data->len,
5590 &our_key ) );
Gilles Peskine59685592018-09-18 12:11:34 +02005591
Gilles Peskine51ae0e42019-05-16 17:31:03 +02005592 PSA_ASSERT( psa_key_derivation_setup( &operation, alg ) );
Gilles Peskinecf7292e2019-05-16 17:53:40 +02005593 PSA_ASSERT( psa_key_derivation_key_agreement(
5594 &operation,
5595 PSA_KEY_DERIVATION_INPUT_SECRET, our_key,
5596 peer_key_data->x, peer_key_data->len ) );
Gilles Peskinef8a9d942019-04-11 22:13:20 +02005597 if( PSA_ALG_IS_HKDF( PSA_ALG_KEY_AGREEMENT_GET_KDF( alg ) ) )
5598 {
5599 /* The test data is for info="" */
Gilles Peskine51ae0e42019-05-16 17:31:03 +02005600 PSA_ASSERT( psa_key_derivation_input_bytes( &operation,
Gilles Peskine03410b52019-05-16 16:05:19 +02005601 PSA_KEY_DERIVATION_INPUT_INFO,
Gilles Peskinef8a9d942019-04-11 22:13:20 +02005602 NULL, 0 ) );
5603 }
Gilles Peskine59685592018-09-18 12:11:34 +02005604
Gilles Peskine51ae0e42019-05-16 17:31:03 +02005605 PSA_ASSERT( psa_key_derivation_output_bytes( &operation,
Gilles Peskinecf7292e2019-05-16 17:53:40 +02005606 actual_output,
5607 expected_output1->len ) );
Gilles Peskine0dfba2d2018-12-18 00:40:50 +01005608 ASSERT_COMPARE( actual_output, expected_output1->len,
5609 expected_output1->x, expected_output1->len );
Gilles Peskine3ec8ed82018-10-25 22:37:15 +02005610 if( expected_output2->len != 0 )
5611 {
Gilles Peskine51ae0e42019-05-16 17:31:03 +02005612 PSA_ASSERT( psa_key_derivation_output_bytes( &operation,
Gilles Peskinecf7292e2019-05-16 17:53:40 +02005613 actual_output,
5614 expected_output2->len ) );
Gilles Peskine0dfba2d2018-12-18 00:40:50 +01005615 ASSERT_COMPARE( actual_output, expected_output2->len,
5616 expected_output2->x, expected_output2->len );
Gilles Peskine3ec8ed82018-10-25 22:37:15 +02005617 }
Gilles Peskine59685592018-09-18 12:11:34 +02005618
5619exit:
Gilles Peskine51ae0e42019-05-16 17:31:03 +02005620 psa_key_derivation_abort( &operation );
Gilles Peskine59685592018-09-18 12:11:34 +02005621 psa_destroy_key( our_key );
Gilles Peskine1153e7b2019-05-28 15:10:21 +02005622 PSA_DONE( );
Gilles Peskine59685592018-09-18 12:11:34 +02005623 mbedtls_free( actual_output );
5624}
5625/* END_CASE */
5626
5627/* BEGIN_CASE */
Gilles Peskinea50d7392018-06-21 10:22:13 +02005628void generate_random( int bytes_arg )
Gilles Peskine05d69892018-06-19 22:00:52 +02005629{
Gilles Peskinea50d7392018-06-21 10:22:13 +02005630 size_t bytes = bytes_arg;
Gilles Peskine8cebbba2018-09-27 13:54:18 +02005631 unsigned char *output = NULL;
5632 unsigned char *changed = NULL;
Gilles Peskinea50d7392018-06-21 10:22:13 +02005633 size_t i;
5634 unsigned run;
Gilles Peskine05d69892018-06-19 22:00:52 +02005635
Simon Butcher49f8e312020-03-03 15:51:50 +00005636 TEST_ASSERT( bytes_arg >= 0 );
5637
Gilles Peskine91892022021-02-08 19:50:26 +01005638 ASSERT_ALLOC( output, bytes );
Gilles Peskine8cebbba2018-09-27 13:54:18 +02005639 ASSERT_ALLOC( changed, bytes );
Gilles Peskine05d69892018-06-19 22:00:52 +02005640
Gilles Peskine8817f612018-12-18 00:18:46 +01005641 PSA_ASSERT( psa_crypto_init( ) );
Gilles Peskine05d69892018-06-19 22:00:52 +02005642
Gilles Peskinea50d7392018-06-21 10:22:13 +02005643 /* Run several times, to ensure that every output byte will be
5644 * nonzero at least once with overwhelming probability
5645 * (2^(-8*number_of_runs)). */
5646 for( run = 0; run < 10; run++ )
Gilles Peskine05d69892018-06-19 22:00:52 +02005647 {
Gilles Peskinef7ab5ad2018-09-26 18:19:24 +02005648 if( bytes != 0 )
5649 memset( output, 0, bytes );
Gilles Peskine8817f612018-12-18 00:18:46 +01005650 PSA_ASSERT( psa_generate_random( output, bytes ) );
Gilles Peskinea50d7392018-06-21 10:22:13 +02005651
Gilles Peskinea50d7392018-06-21 10:22:13 +02005652 for( i = 0; i < bytes; i++ )
5653 {
5654 if( output[i] != 0 )
5655 ++changed[i];
5656 }
Gilles Peskine05d69892018-06-19 22:00:52 +02005657 }
Gilles Peskinea50d7392018-06-21 10:22:13 +02005658
5659 /* Check that every byte was changed to nonzero at least once. This
5660 * validates that psa_generate_random is overwriting every byte of
5661 * the output buffer. */
5662 for( i = 0; i < bytes; i++ )
5663 {
5664 TEST_ASSERT( changed[i] != 0 );
5665 }
Gilles Peskine05d69892018-06-19 22:00:52 +02005666
5667exit:
Gilles Peskine1153e7b2019-05-28 15:10:21 +02005668 PSA_DONE( );
Gilles Peskinea50d7392018-06-21 10:22:13 +02005669 mbedtls_free( output );
5670 mbedtls_free( changed );
Gilles Peskine05d69892018-06-19 22:00:52 +02005671}
5672/* END_CASE */
Gilles Peskine12313cd2018-06-20 00:20:32 +02005673
5674/* BEGIN_CASE */
5675void generate_key( int type_arg,
5676 int bits_arg,
5677 int usage_arg,
5678 int alg_arg,
Steven Cooreman83fdb702021-01-21 14:24:39 +01005679 int expected_status_arg,
5680 int is_large_key )
Gilles Peskine12313cd2018-06-20 00:20:32 +02005681{
Ronald Cron5425a212020-08-04 14:58:35 +02005682 mbedtls_svc_key_id_t key = MBEDTLS_SVC_KEY_ID_INIT;
Gilles Peskine12313cd2018-06-20 00:20:32 +02005683 psa_key_type_t type = type_arg;
5684 psa_key_usage_t usage = usage_arg;
5685 size_t bits = bits_arg;
5686 psa_algorithm_t alg = alg_arg;
5687 psa_status_t expected_status = expected_status_arg;
Gilles Peskineff5f0e72019-04-18 12:53:30 +02005688 psa_key_attributes_t attributes = PSA_KEY_ATTRIBUTES_INIT;
Gilles Peskine8c8f2ab2019-04-18 21:44:46 +02005689 psa_key_attributes_t got_attributes = PSA_KEY_ATTRIBUTES_INIT;
Gilles Peskine12313cd2018-06-20 00:20:32 +02005690
Gilles Peskine8817f612018-12-18 00:18:46 +01005691 PSA_ASSERT( psa_crypto_init( ) );
Gilles Peskine12313cd2018-06-20 00:20:32 +02005692
Gilles Peskineff5f0e72019-04-18 12:53:30 +02005693 psa_set_key_usage_flags( &attributes, usage );
5694 psa_set_key_algorithm( &attributes, alg );
5695 psa_set_key_type( &attributes, type );
Gilles Peskine3a4f1f82019-04-26 13:49:28 +02005696 psa_set_key_bits( &attributes, bits );
Gilles Peskine12313cd2018-06-20 00:20:32 +02005697
5698 /* Generate a key */
Steven Cooreman83fdb702021-01-21 14:24:39 +01005699 psa_status_t status = psa_generate_key( &attributes, &key );
5700
5701 if( is_large_key > 0 )
5702 TEST_ASSUME( status != PSA_ERROR_INSUFFICIENT_MEMORY );
5703 TEST_EQUAL( status , expected_status );
Gilles Peskinee56e8782019-04-26 17:34:02 +02005704 if( expected_status != PSA_SUCCESS )
Gilles Peskineff5f0e72019-04-18 12:53:30 +02005705 goto exit;
Gilles Peskine12313cd2018-06-20 00:20:32 +02005706
5707 /* Test the key information */
Ronald Cron5425a212020-08-04 14:58:35 +02005708 PSA_ASSERT( psa_get_key_attributes( key, &got_attributes ) );
Gilles Peskine8c8f2ab2019-04-18 21:44:46 +02005709 TEST_EQUAL( psa_get_key_type( &got_attributes ), type );
5710 TEST_EQUAL( psa_get_key_bits( &got_attributes ), bits );
Gilles Peskine12313cd2018-06-20 00:20:32 +02005711
Gilles Peskine818ca122018-06-20 18:16:48 +02005712 /* Do something with the key according to its type and permitted usage. */
Gilles Peskinec18e25f2021-02-12 23:48:20 +01005713 if( ! mbedtls_test_psa_exercise_key( key, usage, alg ) )
Gilles Peskine02b75072018-07-01 22:31:34 +02005714 goto exit;
Gilles Peskine12313cd2018-06-20 00:20:32 +02005715
5716exit:
Ronald Cron3a4f0e32020-11-19 17:55:23 +01005717 /*
5718 * Key attributes may have been returned by psa_get_key_attributes()
5719 * thus reset them as required.
5720 */
Gilles Peskinea1ace9c2019-04-26 16:03:33 +02005721 psa_reset_key_attributes( &got_attributes );
Ronald Cron3a4f0e32020-11-19 17:55:23 +01005722
Ronald Cron5425a212020-08-04 14:58:35 +02005723 psa_destroy_key( key );
Gilles Peskine1153e7b2019-05-28 15:10:21 +02005724 PSA_DONE( );
Gilles Peskine12313cd2018-06-20 00:20:32 +02005725}
5726/* END_CASE */
itayzafrir0adf0fc2018-09-06 16:24:41 +03005727
Ronald Cronee414c72021-03-18 18:50:08 +01005728/* BEGIN_CASE depends_on:PSA_WANT_KEY_TYPE_RSA_KEY_PAIR:PSA_WANT_ALG_RSA_PKCS1V15_CRYPT:PSA_WANT_ALG_RSA_PKCS1V15_SIGN:MBEDTLS_GENPRIME */
Gilles Peskinee56e8782019-04-26 17:34:02 +02005729void generate_key_rsa( int bits_arg,
5730 data_t *e_arg,
5731 int expected_status_arg )
5732{
Ronald Cron5425a212020-08-04 14:58:35 +02005733 mbedtls_svc_key_id_t key = MBEDTLS_SVC_KEY_ID_INIT;
Gilles Peskinec93b80c2019-05-16 19:39:54 +02005734 psa_key_type_t type = PSA_KEY_TYPE_RSA_KEY_PAIR;
Gilles Peskinee56e8782019-04-26 17:34:02 +02005735 size_t bits = bits_arg;
5736 psa_key_usage_t usage = PSA_KEY_USAGE_ENCRYPT | PSA_KEY_USAGE_DECRYPT;
5737 psa_algorithm_t alg = PSA_ALG_RSA_PKCS1V15_SIGN_RAW;
5738 psa_status_t expected_status = expected_status_arg;
5739 psa_key_attributes_t attributes = PSA_KEY_ATTRIBUTES_INIT;
5740 uint8_t *exported = NULL;
5741 size_t exported_size =
gabor-mezei-armcbcec212020-12-18 14:23:51 +01005742 PSA_EXPORT_KEY_OUTPUT_SIZE( PSA_KEY_TYPE_RSA_PUBLIC_KEY, bits );
Gilles Peskinee56e8782019-04-26 17:34:02 +02005743 size_t exported_length = SIZE_MAX;
5744 uint8_t *e_read_buffer = NULL;
5745 int is_default_public_exponent = 0;
Gilles Peskineaa02c172019-04-28 11:44:17 +02005746 size_t e_read_size = PSA_KEY_DOMAIN_PARAMETERS_SIZE( type, bits );
Gilles Peskinee56e8782019-04-26 17:34:02 +02005747 size_t e_read_length = SIZE_MAX;
5748
5749 if( e_arg->len == 0 ||
5750 ( e_arg->len == 3 &&
5751 e_arg->x[0] == 1 && e_arg->x[1] == 0 && e_arg->x[2] == 1 ) )
5752 {
5753 is_default_public_exponent = 1;
5754 e_read_size = 0;
5755 }
5756 ASSERT_ALLOC( e_read_buffer, e_read_size );
5757 ASSERT_ALLOC( exported, exported_size );
5758
5759 PSA_ASSERT( psa_crypto_init( ) );
5760
5761 psa_set_key_usage_flags( &attributes, usage );
5762 psa_set_key_algorithm( &attributes, alg );
5763 PSA_ASSERT( psa_set_key_domain_parameters( &attributes, type,
5764 e_arg->x, e_arg->len ) );
5765 psa_set_key_bits( &attributes, bits );
5766
5767 /* Generate a key */
Ronald Cron5425a212020-08-04 14:58:35 +02005768 TEST_EQUAL( psa_generate_key( &attributes, &key ), expected_status );
Gilles Peskinee56e8782019-04-26 17:34:02 +02005769 if( expected_status != PSA_SUCCESS )
5770 goto exit;
5771
5772 /* Test the key information */
Ronald Cron5425a212020-08-04 14:58:35 +02005773 PSA_ASSERT( psa_get_key_attributes( key, &attributes ) );
Gilles Peskinee56e8782019-04-26 17:34:02 +02005774 TEST_EQUAL( psa_get_key_type( &attributes ), type );
5775 TEST_EQUAL( psa_get_key_bits( &attributes ), bits );
5776 PSA_ASSERT( psa_get_key_domain_parameters( &attributes,
5777 e_read_buffer, e_read_size,
5778 &e_read_length ) );
5779 if( is_default_public_exponent )
5780 TEST_EQUAL( e_read_length, 0 );
5781 else
5782 ASSERT_COMPARE( e_read_buffer, e_read_length, e_arg->x, e_arg->len );
5783
5784 /* Do something with the key according to its type and permitted usage. */
Gilles Peskinec18e25f2021-02-12 23:48:20 +01005785 if( ! mbedtls_test_psa_exercise_key( key, usage, alg ) )
Gilles Peskinee56e8782019-04-26 17:34:02 +02005786 goto exit;
5787
5788 /* Export the key and check the public exponent. */
Ronald Cron5425a212020-08-04 14:58:35 +02005789 PSA_ASSERT( psa_export_public_key( key,
Gilles Peskinee56e8782019-04-26 17:34:02 +02005790 exported, exported_size,
5791 &exported_length ) );
5792 {
5793 uint8_t *p = exported;
5794 uint8_t *end = exported + exported_length;
5795 size_t len;
5796 /* RSAPublicKey ::= SEQUENCE {
5797 * modulus INTEGER, -- n
5798 * publicExponent INTEGER } -- e
5799 */
5800 TEST_EQUAL( 0, mbedtls_asn1_get_tag( &p, end, &len,
Gilles Peskinecf7292e2019-05-16 17:53:40 +02005801 MBEDTLS_ASN1_SEQUENCE |
5802 MBEDTLS_ASN1_CONSTRUCTED ) );
Gilles Peskine8e94efe2021-02-13 00:25:53 +01005803 TEST_ASSERT( mbedtls_test_asn1_skip_integer( &p, end, bits, bits, 1 ) );
Gilles Peskinee56e8782019-04-26 17:34:02 +02005804 TEST_EQUAL( 0, mbedtls_asn1_get_tag( &p, end, &len,
5805 MBEDTLS_ASN1_INTEGER ) );
5806 if( len >= 1 && p[0] == 0 )
5807 {
5808 ++p;
5809 --len;
5810 }
5811 if( e_arg->len == 0 )
5812 {
5813 TEST_EQUAL( len, 3 );
5814 TEST_EQUAL( p[0], 1 );
5815 TEST_EQUAL( p[1], 0 );
5816 TEST_EQUAL( p[2], 1 );
5817 }
5818 else
5819 ASSERT_COMPARE( p, len, e_arg->x, e_arg->len );
5820 }
5821
5822exit:
Ronald Cron3a4f0e32020-11-19 17:55:23 +01005823 /*
5824 * Key attributes may have been returned by psa_get_key_attributes() or
5825 * set by psa_set_key_domain_parameters() thus reset them as required.
5826 */
Gilles Peskinee56e8782019-04-26 17:34:02 +02005827 psa_reset_key_attributes( &attributes );
Ronald Cron3a4f0e32020-11-19 17:55:23 +01005828
Ronald Cron5425a212020-08-04 14:58:35 +02005829 psa_destroy_key( key );
Gilles Peskine1153e7b2019-05-28 15:10:21 +02005830 PSA_DONE( );
Gilles Peskinee56e8782019-04-26 17:34:02 +02005831 mbedtls_free( e_read_buffer );
5832 mbedtls_free( exported );
5833}
5834/* END_CASE */
5835
Darryl Greend49a4992018-06-18 17:27:26 +01005836/* BEGIN_CASE depends_on:MBEDTLS_PSA_CRYPTO_STORAGE_C */
Gilles Peskine5c648ab2019-04-19 14:06:53 +02005837void persistent_key_load_key_from_storage( data_t *data,
5838 int type_arg, int bits_arg,
5839 int usage_flags_arg, int alg_arg,
5840 int generation_method )
Darryl Greend49a4992018-06-18 17:27:26 +01005841{
Ronald Cron71016a92020-08-28 19:01:50 +02005842 mbedtls_svc_key_id_t key_id = mbedtls_svc_key_id_make( 1, 1 );
Gilles Peskine5c648ab2019-04-19 14:06:53 +02005843 psa_key_attributes_t attributes = PSA_KEY_ATTRIBUTES_INIT;
Ronald Cron5425a212020-08-04 14:58:35 +02005844 mbedtls_svc_key_id_t key = MBEDTLS_SVC_KEY_ID_INIT;
5845 mbedtls_svc_key_id_t base_key = MBEDTLS_SVC_KEY_ID_INIT;
Gilles Peskine5c648ab2019-04-19 14:06:53 +02005846 psa_key_type_t type = type_arg;
5847 size_t bits = bits_arg;
5848 psa_key_usage_t usage_flags = usage_flags_arg;
5849 psa_algorithm_t alg = alg_arg;
Gilles Peskine51ae0e42019-05-16 17:31:03 +02005850 psa_key_derivation_operation_t operation = PSA_KEY_DERIVATION_OPERATION_INIT;
Darryl Greend49a4992018-06-18 17:27:26 +01005851 unsigned char *first_export = NULL;
5852 unsigned char *second_export = NULL;
gabor-mezei-armcbcec212020-12-18 14:23:51 +01005853 size_t export_size = PSA_EXPORT_KEY_OUTPUT_SIZE( type, bits );
Darryl Greend49a4992018-06-18 17:27:26 +01005854 size_t first_exported_length;
5855 size_t second_exported_length;
5856
Gilles Peskine5c648ab2019-04-19 14:06:53 +02005857 if( usage_flags & PSA_KEY_USAGE_EXPORT )
5858 {
5859 ASSERT_ALLOC( first_export, export_size );
5860 ASSERT_ALLOC( second_export, export_size );
5861 }
Darryl Greend49a4992018-06-18 17:27:26 +01005862
Gilles Peskine8817f612018-12-18 00:18:46 +01005863 PSA_ASSERT( psa_crypto_init() );
Darryl Greend49a4992018-06-18 17:27:26 +01005864
Gilles Peskinec87af662019-05-15 16:12:22 +02005865 psa_set_key_id( &attributes, key_id );
Gilles Peskine5c648ab2019-04-19 14:06:53 +02005866 psa_set_key_usage_flags( &attributes, usage_flags );
5867 psa_set_key_algorithm( &attributes, alg );
5868 psa_set_key_type( &attributes, type );
Gilles Peskine3a4f1f82019-04-26 13:49:28 +02005869 psa_set_key_bits( &attributes, bits );
Darryl Greend49a4992018-06-18 17:27:26 +01005870
Darryl Green0c6575a2018-11-07 16:05:30 +00005871 switch( generation_method )
5872 {
5873 case IMPORT_KEY:
5874 /* Import the key */
Gilles Peskine049c7532019-05-15 20:22:09 +02005875 PSA_ASSERT( psa_import_key( &attributes, data->x, data->len,
Ronald Cron5425a212020-08-04 14:58:35 +02005876 &key ) );
Darryl Green0c6575a2018-11-07 16:05:30 +00005877 break;
Darryl Greend49a4992018-06-18 17:27:26 +01005878
Darryl Green0c6575a2018-11-07 16:05:30 +00005879 case GENERATE_KEY:
5880 /* Generate a key */
Ronald Cron5425a212020-08-04 14:58:35 +02005881 PSA_ASSERT( psa_generate_key( &attributes, &key ) );
Darryl Green0c6575a2018-11-07 16:05:30 +00005882 break;
5883
5884 case DERIVE_KEY:
Steven Cooreman70f654a2021-02-15 10:51:43 +01005885#if defined(PSA_WANT_ALG_HKDF) && defined(PSA_WANT_ALG_SHA_256)
Gilles Peskine5c648ab2019-04-19 14:06:53 +02005886 {
5887 /* Create base key */
5888 psa_algorithm_t derive_alg = PSA_ALG_HKDF( PSA_ALG_SHA_256 );
5889 psa_key_attributes_t base_attributes = PSA_KEY_ATTRIBUTES_INIT;
5890 psa_set_key_usage_flags( &base_attributes,
5891 PSA_KEY_USAGE_DERIVE );
5892 psa_set_key_algorithm( &base_attributes, derive_alg );
5893 psa_set_key_type( &base_attributes, PSA_KEY_TYPE_DERIVE );
Gilles Peskine049c7532019-05-15 20:22:09 +02005894 PSA_ASSERT( psa_import_key( &base_attributes,
5895 data->x, data->len,
5896 &base_key ) );
Gilles Peskine5c648ab2019-04-19 14:06:53 +02005897 /* Derive a key. */
Gilles Peskine51ae0e42019-05-16 17:31:03 +02005898 PSA_ASSERT( psa_key_derivation_setup( &operation, derive_alg ) );
Gilles Peskinecf7292e2019-05-16 17:53:40 +02005899 PSA_ASSERT( psa_key_derivation_input_key(
5900 &operation,
5901 PSA_KEY_DERIVATION_INPUT_SECRET, base_key ) );
Gilles Peskine5c648ab2019-04-19 14:06:53 +02005902 PSA_ASSERT( psa_key_derivation_input_bytes(
Gilles Peskine51ae0e42019-05-16 17:31:03 +02005903 &operation, PSA_KEY_DERIVATION_INPUT_INFO,
Gilles Peskine5c648ab2019-04-19 14:06:53 +02005904 NULL, 0 ) );
Gilles Peskinecf7292e2019-05-16 17:53:40 +02005905 PSA_ASSERT( psa_key_derivation_output_key( &attributes,
5906 &operation,
Ronald Cron5425a212020-08-04 14:58:35 +02005907 &key ) );
Gilles Peskine51ae0e42019-05-16 17:31:03 +02005908 PSA_ASSERT( psa_key_derivation_abort( &operation ) );
Gilles Peskine5c648ab2019-04-19 14:06:53 +02005909 PSA_ASSERT( psa_destroy_key( base_key ) );
Ronald Cron5425a212020-08-04 14:58:35 +02005910 base_key = MBEDTLS_SVC_KEY_ID_INIT;
Gilles Peskine5c648ab2019-04-19 14:06:53 +02005911 }
Gilles Peskine6fea21d2021-01-12 00:02:15 +01005912#else
5913 TEST_ASSUME( ! "KDF not supported in this configuration" );
5914#endif
5915 break;
5916
5917 default:
5918 TEST_ASSERT( ! "generation_method not implemented in test" );
5919 break;
Darryl Green0c6575a2018-11-07 16:05:30 +00005920 }
Gilles Peskine5c648ab2019-04-19 14:06:53 +02005921 psa_reset_key_attributes( &attributes );
Darryl Greend49a4992018-06-18 17:27:26 +01005922
Gilles Peskine5c648ab2019-04-19 14:06:53 +02005923 /* Export the key if permitted by the key policy. */
5924 if( usage_flags & PSA_KEY_USAGE_EXPORT )
5925 {
Ronald Cron5425a212020-08-04 14:58:35 +02005926 PSA_ASSERT( psa_export_key( key,
Gilles Peskine5c648ab2019-04-19 14:06:53 +02005927 first_export, export_size,
5928 &first_exported_length ) );
5929 if( generation_method == IMPORT_KEY )
5930 ASSERT_COMPARE( data->x, data->len,
5931 first_export, first_exported_length );
5932 }
Darryl Greend49a4992018-06-18 17:27:26 +01005933
5934 /* Shutdown and restart */
Ronald Cron5425a212020-08-04 14:58:35 +02005935 PSA_ASSERT( psa_purge_key( key ) );
Gilles Peskine1153e7b2019-05-28 15:10:21 +02005936 PSA_DONE();
Gilles Peskine8817f612018-12-18 00:18:46 +01005937 PSA_ASSERT( psa_crypto_init() );
Darryl Greend49a4992018-06-18 17:27:26 +01005938
Darryl Greend49a4992018-06-18 17:27:26 +01005939 /* Check key slot still contains key data */
Ronald Cron5425a212020-08-04 14:58:35 +02005940 PSA_ASSERT( psa_get_key_attributes( key, &attributes ) );
Ronald Cronecfb2372020-07-23 17:13:42 +02005941 TEST_ASSERT( mbedtls_svc_key_id_equal(
5942 psa_get_key_id( &attributes ), key_id ) );
Gilles Peskine5c648ab2019-04-19 14:06:53 +02005943 TEST_EQUAL( psa_get_key_lifetime( &attributes ),
5944 PSA_KEY_LIFETIME_PERSISTENT );
5945 TEST_EQUAL( psa_get_key_type( &attributes ), type );
5946 TEST_EQUAL( psa_get_key_bits( &attributes ), bits );
5947 TEST_EQUAL( psa_get_key_usage_flags( &attributes ), usage_flags );
5948 TEST_EQUAL( psa_get_key_algorithm( &attributes ), alg );
Darryl Greend49a4992018-06-18 17:27:26 +01005949
Gilles Peskine5c648ab2019-04-19 14:06:53 +02005950 /* Export the key again if permitted by the key policy. */
5951 if( usage_flags & PSA_KEY_USAGE_EXPORT )
Darryl Green0c6575a2018-11-07 16:05:30 +00005952 {
Ronald Cron5425a212020-08-04 14:58:35 +02005953 PSA_ASSERT( psa_export_key( key,
Gilles Peskine5c648ab2019-04-19 14:06:53 +02005954 second_export, export_size,
5955 &second_exported_length ) );
Darryl Green0c6575a2018-11-07 16:05:30 +00005956 ASSERT_COMPARE( first_export, first_exported_length,
5957 second_export, second_exported_length );
Darryl Green0c6575a2018-11-07 16:05:30 +00005958 }
5959
5960 /* Do something with the key according to its type and permitted usage. */
Gilles Peskinec18e25f2021-02-12 23:48:20 +01005961 if( ! mbedtls_test_psa_exercise_key( key, usage_flags, alg ) )
Darryl Green0c6575a2018-11-07 16:05:30 +00005962 goto exit;
Darryl Greend49a4992018-06-18 17:27:26 +01005963
5964exit:
Ronald Cron3a4f0e32020-11-19 17:55:23 +01005965 /*
5966 * Key attributes may have been returned by psa_get_key_attributes()
5967 * thus reset them as required.
5968 */
Gilles Peskinea1ace9c2019-04-26 16:03:33 +02005969 psa_reset_key_attributes( &attributes );
Ronald Cron3a4f0e32020-11-19 17:55:23 +01005970
Darryl Greend49a4992018-06-18 17:27:26 +01005971 mbedtls_free( first_export );
5972 mbedtls_free( second_export );
Gilles Peskine51ae0e42019-05-16 17:31:03 +02005973 psa_key_derivation_abort( &operation );
Gilles Peskine5c648ab2019-04-19 14:06:53 +02005974 psa_destroy_key( base_key );
Ronald Cron5425a212020-08-04 14:58:35 +02005975 psa_destroy_key( key );
Gilles Peskine1153e7b2019-05-28 15:10:21 +02005976 PSA_DONE();
Darryl Greend49a4992018-06-18 17:27:26 +01005977}
5978/* END_CASE */