blob: d28de0c206edc618e780e0488fdeca3d9aced05b [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"
Archana4d7ae1d2021-07-07 02:50:22 +053018#if defined(PSA_CRYPTO_DRIVER_TEST)
19#include "test/drivers/test_driver.h"
Archana8a180362021-07-05 02:18:48 +053020#define TEST_DRIVER_LOCATION PSA_CRYPTO_TEST_DRIVER_LOCATION
21#else
22#define TEST_DRIVER_LOCATION 0x7fffff
Archana4d7ae1d2021-07-07 02:50:22 +053023#endif
Ronald Cron28a45ed2021-02-09 20:35:42 +010024
Gilles Peskine4023c012021-05-27 13:21:20 +020025/* If this comes up, it's a bug in the test code or in the test data. */
26#define UNUSED 0xdeadbeef
27
Dave Rodgman647791d2021-06-23 12:49:59 +010028/* Assert that an operation is (not) active.
29 * This serves as a proxy for checking if the operation is aborted. */
30#define ASSERT_OPERATION_IS_ACTIVE( operation ) TEST_ASSERT( operation.id != 0 )
31#define ASSERT_OPERATION_IS_INACTIVE( operation ) TEST_ASSERT( operation.id == 0 )
Gilles Peskinef426e0f2019-02-25 17:42:03 +010032
33/** An invalid export length that will never be set by psa_export_key(). */
34static const size_t INVALID_EXPORT_LENGTH = ~0U;
35
Gilles Peskinea7aa4422018-08-14 15:17:54 +020036/** Test if a buffer contains a constant byte value.
37 *
38 * `mem_is_char(buffer, c, size)` is true after `memset(buffer, c, size)`.
Gilles Peskinee66ca3b2018-06-20 00:11:45 +020039 *
40 * \param buffer Pointer to the beginning of the buffer.
Gilles Peskinea7aa4422018-08-14 15:17:54 +020041 * \param c Expected value of every byte.
Gilles Peskinee66ca3b2018-06-20 00:11:45 +020042 * \param size Size of the buffer in bytes.
43 *
Gilles Peskine3f669c32018-06-21 09:21:51 +020044 * \return 1 if the buffer is all-bits-zero.
45 * \return 0 if there is at least one nonzero byte.
Gilles Peskinee66ca3b2018-06-20 00:11:45 +020046 */
Gilles Peskinea7aa4422018-08-14 15:17:54 +020047static int mem_is_char( void *buffer, unsigned char c, size_t size )
Gilles Peskinee66ca3b2018-06-20 00:11:45 +020048{
49 size_t i;
50 for( i = 0; i < size; i++ )
51 {
Gilles Peskinea7aa4422018-08-14 15:17:54 +020052 if( ( (unsigned char *) buffer )[i] != c )
Gilles Peskine3f669c32018-06-21 09:21:51 +020053 return( 0 );
Gilles Peskinee66ca3b2018-06-20 00:11:45 +020054 }
Gilles Peskine3f669c32018-06-21 09:21:51 +020055 return( 1 );
Gilles Peskinee66ca3b2018-06-20 00:11:45 +020056}
Gilles Peskine818ca122018-06-20 18:16:48 +020057
Gilles Peskine0b352bc2018-06-28 00:16:11 +020058/* Write the ASN.1 INTEGER with the value 2^(bits-1)+x backwards from *p. */
59static int asn1_write_10x( unsigned char **p,
60 unsigned char *start,
61 size_t bits,
62 unsigned char x )
63{
64 int ret;
65 int len = bits / 8 + 1;
Gilles Peskine480416a2018-06-28 19:04:07 +020066 if( bits == 0 )
67 return( MBEDTLS_ERR_ASN1_INVALID_DATA );
68 if( bits <= 8 && x >= 1 << ( bits - 1 ) )
Gilles Peskine0b352bc2018-06-28 00:16:11 +020069 return( MBEDTLS_ERR_ASN1_INVALID_DATA );
Moran Pekercb088e72018-07-17 17:36:59 +030070 if( *p < start || *p - start < (ptrdiff_t) len )
Gilles Peskine0b352bc2018-06-28 00:16:11 +020071 return( MBEDTLS_ERR_ASN1_BUF_TOO_SMALL );
72 *p -= len;
73 ( *p )[len-1] = x;
74 if( bits % 8 == 0 )
75 ( *p )[1] |= 1;
76 else
77 ( *p )[0] |= 1 << ( bits % 8 );
78 MBEDTLS_ASN1_CHK_ADD( len, mbedtls_asn1_write_len( p, start, len ) );
79 MBEDTLS_ASN1_CHK_ADD( len, mbedtls_asn1_write_tag( p, start,
80 MBEDTLS_ASN1_INTEGER ) );
81 return( len );
82}
83
84static int construct_fake_rsa_key( unsigned char *buffer,
85 size_t buffer_size,
86 unsigned char **p,
87 size_t bits,
88 int keypair )
89{
90 size_t half_bits = ( bits + 1 ) / 2;
91 int ret;
92 int len = 0;
93 /* Construct something that looks like a DER encoding of
94 * as defined by PKCS#1 v2.2 (RFC 8017) section A.1.2:
95 * RSAPrivateKey ::= SEQUENCE {
96 * version Version,
97 * modulus INTEGER, -- n
98 * publicExponent INTEGER, -- e
99 * privateExponent INTEGER, -- d
100 * prime1 INTEGER, -- p
101 * prime2 INTEGER, -- q
102 * exponent1 INTEGER, -- d mod (p-1)
103 * exponent2 INTEGER, -- d mod (q-1)
104 * coefficient INTEGER, -- (inverse of q) mod p
105 * otherPrimeInfos OtherPrimeInfos OPTIONAL
106 * }
107 * Or, for a public key, the same structure with only
108 * version, modulus and publicExponent.
109 */
110 *p = buffer + buffer_size;
111 if( keypair )
112 {
113 MBEDTLS_ASN1_CHK_ADD( len, /* pq */
114 asn1_write_10x( p, buffer, half_bits, 1 ) );
115 MBEDTLS_ASN1_CHK_ADD( len, /* dq */
116 asn1_write_10x( p, buffer, half_bits, 1 ) );
117 MBEDTLS_ASN1_CHK_ADD( len, /* dp */
118 asn1_write_10x( p, buffer, half_bits, 1 ) );
119 MBEDTLS_ASN1_CHK_ADD( len, /* q */
120 asn1_write_10x( p, buffer, half_bits, 1 ) );
121 MBEDTLS_ASN1_CHK_ADD( len, /* p != q to pass mbedtls sanity checks */
122 asn1_write_10x( p, buffer, half_bits, 3 ) );
123 MBEDTLS_ASN1_CHK_ADD( len, /* d */
124 asn1_write_10x( p, buffer, bits, 1 ) );
125 }
126 MBEDTLS_ASN1_CHK_ADD( len, /* e = 65537 */
127 asn1_write_10x( p, buffer, 17, 1 ) );
128 MBEDTLS_ASN1_CHK_ADD( len, /* n */
129 asn1_write_10x( p, buffer, bits, 1 ) );
130 if( keypair )
131 MBEDTLS_ASN1_CHK_ADD( len, /* version = 0 */
132 mbedtls_asn1_write_int( p, buffer, 0 ) );
133 MBEDTLS_ASN1_CHK_ADD( len, mbedtls_asn1_write_len( p, buffer, len ) );
134 {
135 const unsigned char tag =
136 MBEDTLS_ASN1_CONSTRUCTED | MBEDTLS_ASN1_SEQUENCE;
137 MBEDTLS_ASN1_CHK_ADD( len, mbedtls_asn1_write_tag( p, buffer, tag ) );
138 }
139 return( len );
140}
141
Gilles Peskinef426e0f2019-02-25 17:42:03 +0100142int exercise_mac_setup( psa_key_type_t key_type,
143 const unsigned char *key_bytes,
144 size_t key_length,
145 psa_algorithm_t alg,
146 psa_mac_operation_t *operation,
147 psa_status_t *status )
148{
Ronald Cron5425a212020-08-04 14:58:35 +0200149 mbedtls_svc_key_id_t key = MBEDTLS_SVC_KEY_ID_INIT;
Gilles Peskine2c2cf0e2019-04-19 19:58:20 +0200150 psa_key_attributes_t attributes = PSA_KEY_ATTRIBUTES_INIT;
Gilles Peskinef426e0f2019-02-25 17:42:03 +0100151
Gilles Peskine89d8c5c2019-11-26 17:01:59 +0100152 psa_set_key_usage_flags( &attributes, PSA_KEY_USAGE_SIGN_HASH );
Gilles Peskine2c2cf0e2019-04-19 19:58:20 +0200153 psa_set_key_algorithm( &attributes, alg );
154 psa_set_key_type( &attributes, key_type );
Ronald Cron5425a212020-08-04 14:58:35 +0200155 PSA_ASSERT( psa_import_key( &attributes, key_bytes, key_length, &key ) );
Gilles Peskinef426e0f2019-02-25 17:42:03 +0100156
Ronald Cron5425a212020-08-04 14:58:35 +0200157 *status = psa_mac_sign_setup( operation, key, alg );
Gilles Peskine9e0a4a52019-02-25 22:11:18 +0100158 /* Whether setup succeeded or failed, abort must succeed. */
159 PSA_ASSERT( psa_mac_abort( operation ) );
160 /* If setup failed, reproduce the failure, so that the caller can
161 * test the resulting state of the operation object. */
162 if( *status != PSA_SUCCESS )
Gilles Peskinef426e0f2019-02-25 17:42:03 +0100163 {
Ronald Cron5425a212020-08-04 14:58:35 +0200164 TEST_EQUAL( psa_mac_sign_setup( operation, key, alg ), *status );
Gilles Peskinef426e0f2019-02-25 17:42:03 +0100165 }
166
Ronald Cron5425a212020-08-04 14:58:35 +0200167 psa_destroy_key( key );
Gilles Peskinef426e0f2019-02-25 17:42:03 +0100168 return( 1 );
169
170exit:
Ronald Cron5425a212020-08-04 14:58:35 +0200171 psa_destroy_key( key );
Gilles Peskinef426e0f2019-02-25 17:42:03 +0100172 return( 0 );
173}
174
175int exercise_cipher_setup( psa_key_type_t key_type,
176 const unsigned char *key_bytes,
177 size_t key_length,
178 psa_algorithm_t alg,
179 psa_cipher_operation_t *operation,
180 psa_status_t *status )
181{
Ronald Cron5425a212020-08-04 14:58:35 +0200182 mbedtls_svc_key_id_t key = MBEDTLS_SVC_KEY_ID_INIT;
Gilles Peskine2c2cf0e2019-04-19 19:58:20 +0200183 psa_key_attributes_t attributes = PSA_KEY_ATTRIBUTES_INIT;
Gilles Peskinef426e0f2019-02-25 17:42:03 +0100184
Gilles Peskine2c2cf0e2019-04-19 19:58:20 +0200185 psa_set_key_usage_flags( &attributes, PSA_KEY_USAGE_ENCRYPT );
186 psa_set_key_algorithm( &attributes, alg );
187 psa_set_key_type( &attributes, key_type );
Ronald Cron5425a212020-08-04 14:58:35 +0200188 PSA_ASSERT( psa_import_key( &attributes, key_bytes, key_length, &key ) );
Gilles Peskinef426e0f2019-02-25 17:42:03 +0100189
Ronald Cron5425a212020-08-04 14:58:35 +0200190 *status = psa_cipher_encrypt_setup( operation, key, alg );
Gilles Peskine9e0a4a52019-02-25 22:11:18 +0100191 /* Whether setup succeeded or failed, abort must succeed. */
192 PSA_ASSERT( psa_cipher_abort( operation ) );
193 /* If setup failed, reproduce the failure, so that the caller can
194 * test the resulting state of the operation object. */
195 if( *status != PSA_SUCCESS )
Gilles Peskinef426e0f2019-02-25 17:42:03 +0100196 {
Ronald Cron5425a212020-08-04 14:58:35 +0200197 TEST_EQUAL( psa_cipher_encrypt_setup( operation, key, alg ),
Gilles Peskine9e0a4a52019-02-25 22:11:18 +0100198 *status );
Gilles Peskinef426e0f2019-02-25 17:42:03 +0100199 }
200
Ronald Cron5425a212020-08-04 14:58:35 +0200201 psa_destroy_key( key );
Gilles Peskinef426e0f2019-02-25 17:42:03 +0100202 return( 1 );
203
204exit:
Ronald Cron5425a212020-08-04 14:58:35 +0200205 psa_destroy_key( key );
Gilles Peskinef426e0f2019-02-25 17:42:03 +0100206 return( 0 );
207}
208
Ronald Cron5425a212020-08-04 14:58:35 +0200209static int test_operations_on_invalid_key( mbedtls_svc_key_id_t key )
Gilles Peskine4cf3a432019-04-18 22:28:52 +0200210{
211 psa_key_attributes_t attributes = PSA_KEY_ATTRIBUTES_INIT;
Ronald Cronecfb2372020-07-23 17:13:42 +0200212 mbedtls_svc_key_id_t key_id = mbedtls_svc_key_id_make( 1, 0x6964 );
Gilles Peskine4cf3a432019-04-18 22:28:52 +0200213 uint8_t buffer[1];
214 size_t length;
215 int ok = 0;
216
Ronald Cronecfb2372020-07-23 17:13:42 +0200217 psa_set_key_id( &attributes, key_id );
Gilles Peskine4cf3a432019-04-18 22:28:52 +0200218 psa_set_key_usage_flags( &attributes, PSA_KEY_USAGE_ENCRYPT );
219 psa_set_key_algorithm( &attributes, PSA_ALG_CTR );
220 psa_set_key_type( &attributes, PSA_KEY_TYPE_AES );
Ronald Cron5425a212020-08-04 14:58:35 +0200221 TEST_EQUAL( psa_get_key_attributes( key, &attributes ),
Maulik Patel3240c9d2021-03-17 16:11:05 +0000222 PSA_ERROR_INVALID_HANDLE );
Ronald Cronecfb2372020-07-23 17:13:42 +0200223 TEST_EQUAL(
224 MBEDTLS_SVC_KEY_ID_GET_KEY_ID( psa_get_key_id( &attributes ) ), 0 );
225 TEST_EQUAL(
226 MBEDTLS_SVC_KEY_ID_GET_OWNER_ID( psa_get_key_id( &attributes ) ), 0 );
Gilles Peskine5c648ab2019-04-19 14:06:53 +0200227 TEST_EQUAL( psa_get_key_lifetime( &attributes ), 0 );
Gilles Peskine4cf3a432019-04-18 22:28:52 +0200228 TEST_EQUAL( psa_get_key_usage_flags( &attributes ), 0 );
229 TEST_EQUAL( psa_get_key_algorithm( &attributes ), 0 );
230 TEST_EQUAL( psa_get_key_type( &attributes ), 0 );
231 TEST_EQUAL( psa_get_key_bits( &attributes ), 0 );
232
Ronald Cron5425a212020-08-04 14:58:35 +0200233 TEST_EQUAL( psa_export_key( key, buffer, sizeof( buffer ), &length ),
Maulik Patel3240c9d2021-03-17 16:11:05 +0000234 PSA_ERROR_INVALID_HANDLE );
Ronald Cron5425a212020-08-04 14:58:35 +0200235 TEST_EQUAL( psa_export_public_key( key,
Gilles Peskine4cf3a432019-04-18 22:28:52 +0200236 buffer, sizeof( buffer ), &length ),
Maulik Patel3240c9d2021-03-17 16:11:05 +0000237 PSA_ERROR_INVALID_HANDLE );
Gilles Peskine4cf3a432019-04-18 22:28:52 +0200238
Gilles Peskine4cf3a432019-04-18 22:28:52 +0200239 ok = 1;
240
241exit:
Ronald Cron3a4f0e32020-11-19 17:55:23 +0100242 /*
243 * Key attributes may have been returned by psa_get_key_attributes()
244 * thus reset them as required.
245 */
Gilles Peskine4cf3a432019-04-18 22:28:52 +0200246 psa_reset_key_attributes( &attributes );
Ronald Cron3a4f0e32020-11-19 17:55:23 +0100247
Gilles Peskine4cf3a432019-04-18 22:28:52 +0200248 return( ok );
249}
250
Gilles Peskine5fe5e272019-08-02 20:30:01 +0200251/* Assert that a key isn't reported as having a slot number. */
252#if defined(MBEDTLS_PSA_CRYPTO_SE_C)
253#define ASSERT_NO_SLOT_NUMBER( attributes ) \
254 do \
255 { \
256 psa_key_slot_number_t ASSERT_NO_SLOT_NUMBER_slot_number; \
257 TEST_EQUAL( psa_get_key_slot_number( \
258 attributes, \
259 &ASSERT_NO_SLOT_NUMBER_slot_number ), \
260 PSA_ERROR_INVALID_ARGUMENT ); \
261 } \
262 while( 0 )
263#else /* MBEDTLS_PSA_CRYPTO_SE_C */
264#define ASSERT_NO_SLOT_NUMBER( attributes ) \
265 ( (void) 0 )
266#endif /* MBEDTLS_PSA_CRYPTO_SE_C */
267
Gilles Peskinebdf309c2018-12-03 15:36:32 +0100268/* An overapproximation of the amount of storage needed for a key of the
269 * given type and with the given content. The API doesn't make it easy
270 * to find a good value for the size. The current implementation doesn't
271 * care about the value anyway. */
272#define KEY_BITS_FROM_DATA( type, data ) \
273 ( data )->len
274
Darryl Green0c6575a2018-11-07 16:05:30 +0000275typedef enum {
276 IMPORT_KEY = 0,
277 GENERATE_KEY = 1,
278 DERIVE_KEY = 2
279} generate_method;
280
Paul Elliott33746aa2021-09-15 16:40:40 +0100281typedef enum
282{
283 DO_NOT_SET_LENGTHS = 0,
284 SET_LENGTHS_BEFORE_NONCE = 1,
285 SET_LENGTHS_AFTER_NONCE = 2
Paul Elliottbb979e72021-09-22 12:54:42 +0100286} set_lengths_method_t;
Paul Elliott33746aa2021-09-15 16:40:40 +0100287
Paul Elliott1c67e0b2021-09-19 13:11:50 +0100288typedef enum
289{
290 USE_NULL_TAG = 0,
291 USE_GIVEN_TAG = 1,
Paul Elliottbb979e72021-09-22 12:54:42 +0100292} tag_usage_method_t;
Paul Elliott1c67e0b2021-09-19 13:11:50 +0100293
Paul Elliott97fd1ba2021-07-21 18:46:06 +0100294/*!
295 * \brief Internal Function for AEAD multipart tests.
Paul Elliott97fd1ba2021-07-21 18:46:06 +0100296 * \param key_type_arg Type of key passed in
297 * \param key_data The encryption / decryption key data
298 * \param alg_arg The type of algorithm used
299 * \param nonce Nonce data
300 * \param additional_data Additional data
Paul Elliott8eec8d42021-09-19 22:38:27 +0100301 * \param ad_part_len_arg If not -1, the length of chunks to
Paul Elliott97fd1ba2021-07-21 18:46:06 +0100302 * feed additional data in to be encrypted /
303 * decrypted. If -1, no chunking.
304 * \param input_data Data to encrypt / decrypt
Paul Elliott8eec8d42021-09-19 22:38:27 +0100305 * \param data_part_len_arg If not -1, the length of chunks to feed
306 * the data in to be encrypted / decrypted. If
307 * -1, no chunking
Paul Elliottbb979e72021-09-22 12:54:42 +0100308 * \param set_lengths_method A member of the set_lengths_method_t enum is
Paul Elliott8eec8d42021-09-19 22:38:27 +0100309 * expected here, this controls whether or not
310 * to set lengths, and in what order with
311 * respect to set nonce.
Paul Elliott97fd1ba2021-07-21 18:46:06 +0100312 * \param expected_output Expected output
Paul Elliott97fd1ba2021-07-21 18:46:06 +0100313 * \param is_encrypt If non-zero this is an encryption operation.
Paul Elliott41ffae12021-07-22 21:52:01 +0100314 * \param do_zero_parts If non-zero, interleave zero length chunks
Paul Elliott8eec8d42021-09-19 22:38:27 +0100315 * with normal length chunks.
Paul Elliott97fd1ba2021-07-21 18:46:06 +0100316 * \return int Zero on failure, non-zero on success.
Paul Elliott97fd1ba2021-07-21 18:46:06 +0100317 */
318static int aead_multipart_internal_func( int key_type_arg, data_t *key_data,
319 int alg_arg,
320 data_t *nonce,
321 data_t *additional_data,
Paul Elliott6bfd0fb2021-09-15 14:15:55 +0100322 int ad_part_len_arg,
Paul Elliott97fd1ba2021-07-21 18:46:06 +0100323 data_t *input_data,
Paul Elliott6bfd0fb2021-09-15 14:15:55 +0100324 int data_part_len_arg,
Paul Elliottbb979e72021-09-22 12:54:42 +0100325 set_lengths_method_t set_lengths_method,
Paul Elliott97fd1ba2021-07-21 18:46:06 +0100326 data_t *expected_output,
Paul Elliott329d5382021-07-22 17:10:45 +0100327 int is_encrypt,
Paul Elliott33746aa2021-09-15 16:40:40 +0100328 int do_zero_parts )
Paul Elliottd3f82412021-06-16 16:52:21 +0100329{
330 mbedtls_svc_key_id_t key = MBEDTLS_SVC_KEY_ID_INIT;
331 psa_key_type_t key_type = key_type_arg;
332 psa_algorithm_t alg = alg_arg;
Paul Elliottfbb4c6d2021-09-22 16:44:21 +0100333 psa_aead_operation_t operation = PSA_AEAD_OPERATION_INIT;
Paul Elliottd3f82412021-06-16 16:52:21 +0100334 unsigned char *output_data = NULL;
335 unsigned char *part_data = NULL;
336 unsigned char *final_data = NULL;
Paul Elliott97fd1ba2021-07-21 18:46:06 +0100337 size_t data_true_size = 0;
Paul Elliottd3f82412021-06-16 16:52:21 +0100338 size_t part_data_size = 0;
Paul Elliott97fd1ba2021-07-21 18:46:06 +0100339 size_t output_size = 0;
340 size_t final_output_size = 0;
Paul Elliottd3f82412021-06-16 16:52:21 +0100341 size_t output_length = 0;
342 size_t key_bits = 0;
343 size_t tag_length = 0;
Paul Elliott6bfd0fb2021-09-15 14:15:55 +0100344 size_t part_offset = 0;
Paul Elliottd3f82412021-06-16 16:52:21 +0100345 size_t part_length = 0;
346 size_t output_part_length = 0;
Paul Elliott97fd1ba2021-07-21 18:46:06 +0100347 size_t tag_size = 0;
Paul Elliott6bfd0fb2021-09-15 14:15:55 +0100348 size_t ad_part_len = 0;
349 size_t data_part_len = 0;
Paul Elliott97fd1ba2021-07-21 18:46:06 +0100350 uint8_t tag_buffer[PSA_AEAD_TAG_MAX_SIZE];
Paul Elliottd3f82412021-06-16 16:52:21 +0100351 psa_key_attributes_t attributes = PSA_KEY_ATTRIBUTES_INIT;
352 psa_status_t status = PSA_ERROR_GENERIC_ERROR;
353
Paul Elliott97fd1ba2021-07-21 18:46:06 +0100354 int test_ok = 0;
Paul Elliott6bfd0fb2021-09-15 14:15:55 +0100355 size_t part_count = 0;
Paul Elliott97fd1ba2021-07-21 18:46:06 +0100356
Paul Elliottd3f82412021-06-16 16:52:21 +0100357 PSA_ASSERT( psa_crypto_init( ) );
358
Paul Elliott97fd1ba2021-07-21 18:46:06 +0100359 if( is_encrypt )
360 psa_set_key_usage_flags( &attributes, PSA_KEY_USAGE_ENCRYPT );
361 else
362 psa_set_key_usage_flags( &attributes, PSA_KEY_USAGE_DECRYPT );
363
Paul Elliottd3f82412021-06-16 16:52:21 +0100364 psa_set_key_algorithm( &attributes, alg );
365 psa_set_key_type( &attributes, key_type );
366
367 PSA_ASSERT( psa_import_key( &attributes, key_data->x, key_data->len,
368 &key ) );
369
370 PSA_ASSERT( psa_get_key_attributes( key, &attributes ) );
371 key_bits = psa_get_key_bits( &attributes );
372
373 tag_length = PSA_AEAD_TAG_LENGTH( key_type, key_bits, alg );
374
Paul Elliott97fd1ba2021-07-21 18:46:06 +0100375 if( is_encrypt )
376 {
377 /* Tag gets written at end of buffer. */
378 output_size = PSA_AEAD_UPDATE_OUTPUT_SIZE( key_type, alg,
379 ( input_data->len +
380 tag_length ) );
381 data_true_size = input_data->len;
382 }
383 else
384 {
385 output_size = PSA_AEAD_UPDATE_OUTPUT_SIZE( key_type, alg,
386 ( input_data->len -
387 tag_length ) );
Paul Elliottd3f82412021-06-16 16:52:21 +0100388
Paul Elliott97fd1ba2021-07-21 18:46:06 +0100389 /* Do not want to attempt to decrypt tag. */
390 data_true_size = input_data->len - tag_length;
391 }
Paul Elliottd3f82412021-06-16 16:52:21 +0100392
393 ASSERT_ALLOC( output_data, output_size );
394
Paul Elliott97fd1ba2021-07-21 18:46:06 +0100395 if( is_encrypt )
396 {
Paul Elliott5a9642f2021-09-13 19:13:22 +0100397 final_output_size = PSA_AEAD_FINISH_OUTPUT_SIZE( key_type, alg );
398 TEST_ASSERT( final_output_size <= PSA_AEAD_FINISH_OUTPUT_MAX_SIZE );
Paul Elliott97fd1ba2021-07-21 18:46:06 +0100399 }
400 else
401 {
Paul Elliott5a9642f2021-09-13 19:13:22 +0100402 final_output_size = PSA_AEAD_VERIFY_OUTPUT_SIZE( key_type, alg );
403 TEST_ASSERT( final_output_size <= PSA_AEAD_VERIFY_OUTPUT_MAX_SIZE );
Paul Elliott97fd1ba2021-07-21 18:46:06 +0100404 }
Paul Elliottd3f82412021-06-16 16:52:21 +0100405
Paul Elliott97fd1ba2021-07-21 18:46:06 +0100406 ASSERT_ALLOC( final_data, final_output_size );
Paul Elliottd3f82412021-06-16 16:52:21 +0100407
Paul Elliott97fd1ba2021-07-21 18:46:06 +0100408 if( is_encrypt )
409 status = psa_aead_encrypt_setup( &operation, key, alg );
410 else
411 status = psa_aead_decrypt_setup( &operation, key, alg );
Paul Elliottd3f82412021-06-16 16:52:21 +0100412
413 /* If the operation is not supported, just skip and not fail in case the
414 * encryption involves a common limitation of cryptography hardwares and
415 * an alternative implementation. */
416 if( status == PSA_ERROR_NOT_SUPPORTED )
417 {
418 MBEDTLS_TEST_PSA_SKIP_IF_ALT_AES_192( key_type, key_data->len * 8 );
419 MBEDTLS_TEST_PSA_SKIP_IF_ALT_GCM_NOT_12BYTES_NONCE( alg, nonce->len );
420 }
421
422 PSA_ASSERT( status );
423
Paul Elliott33746aa2021-09-15 16:40:40 +0100424 if( set_lengths_method == DO_NOT_SET_LENGTHS )
425 PSA_ASSERT( psa_aead_set_nonce( &operation, nonce->x, nonce->len ) );
426 else if( set_lengths_method == SET_LENGTHS_BEFORE_NONCE )
Paul Elliottd3f82412021-06-16 16:52:21 +0100427 {
Paul Elliott33746aa2021-09-15 16:40:40 +0100428 PSA_ASSERT( psa_aead_set_lengths( &operation, additional_data->len,
429 data_true_size ) );
Paul Elliottebf91632021-07-22 17:54:42 +0100430 PSA_ASSERT( psa_aead_set_nonce( &operation, nonce->x, nonce->len ) );
431 }
Paul Elliott33746aa2021-09-15 16:40:40 +0100432 else if( set_lengths_method == SET_LENGTHS_AFTER_NONCE )
Paul Elliottebf91632021-07-22 17:54:42 +0100433 {
434 PSA_ASSERT( psa_aead_set_nonce( &operation, nonce->x, nonce->len ) );
435
Paul Elliott33746aa2021-09-15 16:40:40 +0100436 PSA_ASSERT( psa_aead_set_lengths( &operation, additional_data->len,
437 data_true_size ) );
Paul Elliottd3f82412021-06-16 16:52:21 +0100438 }
Paul Elliottd3f82412021-06-16 16:52:21 +0100439
Paul Elliott6bfd0fb2021-09-15 14:15:55 +0100440 if( ad_part_len_arg != -1 )
Paul Elliottd3f82412021-06-16 16:52:21 +0100441 {
442 /* Pass additional data in parts */
Paul Elliott6bfd0fb2021-09-15 14:15:55 +0100443 ad_part_len = (size_t) ad_part_len_arg;
Paul Elliottd3f82412021-06-16 16:52:21 +0100444
Paul Elliott4e4d71a2021-09-15 16:50:01 +0100445 for( part_offset = 0, part_count = 0;
446 part_offset < additional_data->len;
447 part_offset += part_length, part_count++ )
Paul Elliottd3f82412021-06-16 16:52:21 +0100448 {
Paul Elliott4e4d71a2021-09-15 16:50:01 +0100449 if( do_zero_parts && ( part_count & 0x01 ) )
Paul Elliottd3f82412021-06-16 16:52:21 +0100450 {
Paul Elliott329d5382021-07-22 17:10:45 +0100451 part_length = 0;
Paul Elliottd3f82412021-06-16 16:52:21 +0100452 }
Paul Elliotte49fe452021-09-15 16:52:11 +0100453 else if( additional_data->len - part_offset < ad_part_len )
454 {
455 part_length = additional_data->len - part_offset;
456 }
Paul Elliottd3f82412021-06-16 16:52:21 +0100457 else
458 {
Paul Elliotte49fe452021-09-15 16:52:11 +0100459 part_length = ad_part_len;
Paul Elliottd3f82412021-06-16 16:52:21 +0100460 }
461
462 PSA_ASSERT( psa_aead_update_ad( &operation,
463 additional_data->x + part_offset,
464 part_length ) );
465
Paul Elliottd3f82412021-06-16 16:52:21 +0100466 }
467 }
468 else
469 {
470 /* Pass additional data in one go. */
471 PSA_ASSERT( psa_aead_update_ad( &operation, additional_data->x,
472 additional_data->len ) );
473 }
474
Paul Elliott6bfd0fb2021-09-15 14:15:55 +0100475 if( data_part_len_arg != -1 )
Paul Elliottd3f82412021-06-16 16:52:21 +0100476 {
477 /* Pass data in parts */
Paul Elliott6bfd0fb2021-09-15 14:15:55 +0100478 data_part_len = ( size_t ) data_part_len_arg;
Paul Elliottd3f82412021-06-16 16:52:21 +0100479 part_data_size = PSA_AEAD_UPDATE_OUTPUT_SIZE( key_type, alg,
Paul Elliott97fd1ba2021-07-21 18:46:06 +0100480 ( size_t ) data_part_len );
Paul Elliottd3f82412021-06-16 16:52:21 +0100481
482 ASSERT_ALLOC( part_data, part_data_size );
483
Paul Elliott4e4d71a2021-09-15 16:50:01 +0100484 for( part_offset = 0, part_count = 0;
485 part_offset < data_true_size;
486 part_offset += part_length, part_count++ )
Paul Elliottd3f82412021-06-16 16:52:21 +0100487 {
Paul Elliott4e4d71a2021-09-15 16:50:01 +0100488 if( do_zero_parts && ( part_count & 0x01 ) )
Paul Elliottd3f82412021-06-16 16:52:21 +0100489 {
Paul Elliott329d5382021-07-22 17:10:45 +0100490 part_length = 0;
Paul Elliottd3f82412021-06-16 16:52:21 +0100491 }
Paul Elliotte49fe452021-09-15 16:52:11 +0100492 else if( ( data_true_size - part_offset ) < data_part_len )
493 {
494 part_length = ( data_true_size - part_offset );
495 }
Paul Elliottd3f82412021-06-16 16:52:21 +0100496 else
497 {
Paul Elliotte49fe452021-09-15 16:52:11 +0100498 part_length = data_part_len;
Paul Elliottd3f82412021-06-16 16:52:21 +0100499 }
500
501 PSA_ASSERT( psa_aead_update( &operation,
502 ( input_data->x + part_offset ),
503 part_length, part_data,
504 part_data_size,
505 &output_part_length ) );
506
507 if( output_data && output_part_length )
508 {
509 memcpy( ( output_data + part_offset ), part_data,
510 output_part_length );
511 }
512
Paul Elliottd3f82412021-06-16 16:52:21 +0100513 output_length += output_part_length;
514 }
515 }
516 else
517 {
Paul Elliott97fd1ba2021-07-21 18:46:06 +0100518 /* Pass all data in one go. */
Paul Elliottd3f82412021-06-16 16:52:21 +0100519 PSA_ASSERT( psa_aead_update( &operation, input_data->x,
Paul Elliott97fd1ba2021-07-21 18:46:06 +0100520 data_true_size, output_data,
Paul Elliottd3f82412021-06-16 16:52:21 +0100521 output_size, &output_length ) );
522 }
523
Paul Elliott97fd1ba2021-07-21 18:46:06 +0100524 if( is_encrypt )
525 PSA_ASSERT( psa_aead_finish( &operation, final_data,
526 final_output_size,
527 &output_part_length,
528 tag_buffer, tag_length,
529 &tag_size ) );
530 else
Paul Elliottd3f82412021-06-16 16:52:21 +0100531 {
Paul Elliott9961a662021-09-17 19:19:02 +0100532 PSA_ASSERT( psa_aead_verify( &operation, final_data,
Paul Elliott97fd1ba2021-07-21 18:46:06 +0100533 final_output_size,
534 &output_part_length,
535 ( input_data->x + data_true_size ),
Paul Elliott9961a662021-09-17 19:19:02 +0100536 tag_length ) );
Paul Elliottd3f82412021-06-16 16:52:21 +0100537 }
538
Paul Elliott97fd1ba2021-07-21 18:46:06 +0100539 if( output_data && output_part_length )
540 memcpy( ( output_data + output_length ), final_data,
541 output_part_length );
Paul Elliottd3f82412021-06-16 16:52:21 +0100542
543 output_length += output_part_length;
544
Paul Elliott97fd1ba2021-07-21 18:46:06 +0100545
546 /* For all currently defined algorithms, PSA_AEAD_xxx_OUTPUT_SIZE
547 * should be exact.*/
548 if( is_encrypt )
Paul Elliottd3f82412021-06-16 16:52:21 +0100549 {
Paul Elliott97fd1ba2021-07-21 18:46:06 +0100550 TEST_EQUAL( tag_length, tag_size );
551
552 if( output_data && tag_length )
553 memcpy( ( output_data + output_length ), tag_buffer,
554 tag_length );
555
556 output_length += tag_length;
557
558 TEST_EQUAL( output_length,
559 PSA_AEAD_ENCRYPT_OUTPUT_SIZE( key_type, alg,
560 input_data->len ) );
561 TEST_ASSERT( output_length <=
562 PSA_AEAD_ENCRYPT_OUTPUT_MAX_SIZE( input_data->len ) );
563 }
564 else
565 {
566 TEST_EQUAL( output_length,
567 PSA_AEAD_DECRYPT_OUTPUT_SIZE( key_type, alg,
568 input_data->len ) );
569 TEST_ASSERT( output_length <=
570 PSA_AEAD_DECRYPT_OUTPUT_MAX_SIZE( input_data->len ) );
Paul Elliottd3f82412021-06-16 16:52:21 +0100571 }
572
Paul Elliottd3f82412021-06-16 16:52:21 +0100573
Paul Elliott97fd1ba2021-07-21 18:46:06 +0100574 ASSERT_COMPARE( expected_output->x, expected_output->len,
Paul Elliottd3f82412021-06-16 16:52:21 +0100575 output_data, output_length );
576
Paul Elliottd3f82412021-06-16 16:52:21 +0100577
Paul Elliott97fd1ba2021-07-21 18:46:06 +0100578 test_ok = 1;
Paul Elliottd3f82412021-06-16 16:52:21 +0100579
580exit:
581 psa_destroy_key( key );
582 psa_aead_abort( &operation );
583 mbedtls_free( output_data );
584 mbedtls_free( part_data );
585 mbedtls_free( final_data );
586 PSA_DONE( );
Paul Elliott97fd1ba2021-07-21 18:46:06 +0100587
588 return( test_ok );
Paul Elliottd3f82412021-06-16 16:52:21 +0100589}
590
Gilles Peskinee59236f2018-01-27 23:32:46 +0100591/* END_HEADER */
592
593/* BEGIN_DEPENDENCIES
594 * depends_on:MBEDTLS_PSA_CRYPTO_C
595 * END_DEPENDENCIES
596 */
597
598/* BEGIN_CASE */
Gilles Peskinee1f2d7d2018-08-21 14:54:54 +0200599void static_checks( )
600{
601 size_t max_truncated_mac_size =
602 PSA_ALG_MAC_TRUNCATION_MASK >> PSA_MAC_TRUNCATION_OFFSET;
603
604 /* Check that the length for a truncated MAC always fits in the algorithm
605 * encoding. The shifted mask is the maximum truncated value. The
606 * untruncated algorithm may be one byte larger. */
607 TEST_ASSERT( PSA_MAC_MAX_SIZE <= 1 + max_truncated_mac_size );
608}
609/* END_CASE */
610
611/* BEGIN_CASE */
Gilles Peskine6edfa292019-07-31 15:53:45 +0200612void import_with_policy( int type_arg,
613 int usage_arg, int alg_arg,
614 int expected_status_arg )
615{
616 psa_key_attributes_t attributes = PSA_KEY_ATTRIBUTES_INIT;
617 psa_key_attributes_t got_attributes = PSA_KEY_ATTRIBUTES_INIT;
Ronald Cron5425a212020-08-04 14:58:35 +0200618 mbedtls_svc_key_id_t key = MBEDTLS_SVC_KEY_ID_INIT;
Gilles Peskine6edfa292019-07-31 15:53:45 +0200619 psa_key_type_t type = type_arg;
620 psa_key_usage_t usage = usage_arg;
621 psa_algorithm_t alg = alg_arg;
622 psa_status_t expected_status = expected_status_arg;
623 const uint8_t key_material[16] = {0};
624 psa_status_t status;
625
626 PSA_ASSERT( psa_crypto_init( ) );
627
628 psa_set_key_type( &attributes, type );
629 psa_set_key_usage_flags( &attributes, usage );
630 psa_set_key_algorithm( &attributes, alg );
631
632 status = psa_import_key( &attributes,
633 key_material, sizeof( key_material ),
Ronald Cron5425a212020-08-04 14:58:35 +0200634 &key );
Gilles Peskine6edfa292019-07-31 15:53:45 +0200635 TEST_EQUAL( status, expected_status );
636 if( status != PSA_SUCCESS )
637 goto exit;
638
Ronald Cron5425a212020-08-04 14:58:35 +0200639 PSA_ASSERT( psa_get_key_attributes( key, &got_attributes ) );
Gilles Peskine6edfa292019-07-31 15:53:45 +0200640 TEST_EQUAL( psa_get_key_type( &got_attributes ), type );
gabor-mezei-arm4ff73032021-05-13 12:05:01 +0200641 TEST_EQUAL( psa_get_key_usage_flags( &got_attributes ),
gabor-mezei-arm98a34352021-06-28 14:05:00 +0200642 mbedtls_test_update_key_usage_flags( usage ) );
Gilles Peskine6edfa292019-07-31 15:53:45 +0200643 TEST_EQUAL( psa_get_key_algorithm( &got_attributes ), alg );
Gilles Peskine5fe5e272019-08-02 20:30:01 +0200644 ASSERT_NO_SLOT_NUMBER( &got_attributes );
Gilles Peskine6edfa292019-07-31 15:53:45 +0200645
Ronald Cron5425a212020-08-04 14:58:35 +0200646 PSA_ASSERT( psa_destroy_key( key ) );
647 test_operations_on_invalid_key( key );
Gilles Peskine6edfa292019-07-31 15:53:45 +0200648
649exit:
Ronald Cron3a4f0e32020-11-19 17:55:23 +0100650 /*
651 * Key attributes may have been returned by psa_get_key_attributes()
652 * thus reset them as required.
653 */
Gilles Peskine6edfa292019-07-31 15:53:45 +0200654 psa_reset_key_attributes( &got_attributes );
Ronald Cron3a4f0e32020-11-19 17:55:23 +0100655
656 psa_destroy_key( key );
Gilles Peskine6edfa292019-07-31 15:53:45 +0200657 PSA_DONE( );
658}
659/* END_CASE */
660
661/* BEGIN_CASE */
662void import_with_data( data_t *data, int type_arg,
663 int attr_bits_arg,
664 int expected_status_arg )
Gilles Peskine8c8f2ab2019-04-18 21:44:46 +0200665{
666 psa_key_attributes_t attributes = PSA_KEY_ATTRIBUTES_INIT;
667 psa_key_attributes_t got_attributes = PSA_KEY_ATTRIBUTES_INIT;
Ronald Cron5425a212020-08-04 14:58:35 +0200668 mbedtls_svc_key_id_t key = MBEDTLS_SVC_KEY_ID_INIT;
Gilles Peskine8c8f2ab2019-04-18 21:44:46 +0200669 psa_key_type_t type = type_arg;
Gilles Peskine8fb3a9e2019-05-03 16:59:21 +0200670 size_t attr_bits = attr_bits_arg;
Gilles Peskineb866e2b2018-06-21 09:25:10 +0200671 psa_status_t expected_status = expected_status_arg;
Gilles Peskine2f9c4dc2018-01-28 13:16:24 +0100672 psa_status_t status;
Gilles Peskine2f9c4dc2018-01-28 13:16:24 +0100673
Gilles Peskine8817f612018-12-18 00:18:46 +0100674 PSA_ASSERT( psa_crypto_init( ) );
Gilles Peskine2f9c4dc2018-01-28 13:16:24 +0100675
Gilles Peskine4747d192019-04-17 15:05:45 +0200676 psa_set_key_type( &attributes, type );
Gilles Peskine8fb3a9e2019-05-03 16:59:21 +0200677 psa_set_key_bits( &attributes, attr_bits );
Gilles Peskine6edfa292019-07-31 15:53:45 +0200678
Ronald Cron5425a212020-08-04 14:58:35 +0200679 status = psa_import_key( &attributes, data->x, data->len, &key );
Gilles Peskinefe11b722018-12-18 00:24:04 +0100680 TEST_EQUAL( status, expected_status );
Gilles Peskine8c8f2ab2019-04-18 21:44:46 +0200681 if( status != PSA_SUCCESS )
682 goto exit;
683
Ronald Cron5425a212020-08-04 14:58:35 +0200684 PSA_ASSERT( psa_get_key_attributes( key, &got_attributes ) );
Gilles Peskine8c8f2ab2019-04-18 21:44:46 +0200685 TEST_EQUAL( psa_get_key_type( &got_attributes ), type );
Gilles Peskine8fb3a9e2019-05-03 16:59:21 +0200686 if( attr_bits != 0 )
Gilles Peskine7e0cff92019-07-30 13:48:52 +0200687 TEST_EQUAL( attr_bits, psa_get_key_bits( &got_attributes ) );
Gilles Peskine5fe5e272019-08-02 20:30:01 +0200688 ASSERT_NO_SLOT_NUMBER( &got_attributes );
Gilles Peskine8c8f2ab2019-04-18 21:44:46 +0200689
Ronald Cron5425a212020-08-04 14:58:35 +0200690 PSA_ASSERT( psa_destroy_key( key ) );
691 test_operations_on_invalid_key( key );
Gilles Peskine2f9c4dc2018-01-28 13:16:24 +0100692
693exit:
Ronald Cron3a4f0e32020-11-19 17:55:23 +0100694 /*
695 * Key attributes may have been returned by psa_get_key_attributes()
696 * thus reset them as required.
697 */
Gilles Peskinea1ace9c2019-04-26 16:03:33 +0200698 psa_reset_key_attributes( &got_attributes );
Ronald Cron3a4f0e32020-11-19 17:55:23 +0100699
700 psa_destroy_key( key );
Gilles Peskine1153e7b2019-05-28 15:10:21 +0200701 PSA_DONE( );
Gilles Peskine2f9c4dc2018-01-28 13:16:24 +0100702}
703/* END_CASE */
704
705/* BEGIN_CASE */
Gilles Peskinec744d992019-07-30 17:26:54 +0200706void import_large_key( int type_arg, int byte_size_arg,
707 int expected_status_arg )
708{
709 psa_key_type_t type = type_arg;
710 size_t byte_size = byte_size_arg;
711 psa_key_attributes_t attributes = PSA_KEY_ATTRIBUTES_INIT;
712 psa_status_t expected_status = expected_status_arg;
Ronald Cron5425a212020-08-04 14:58:35 +0200713 mbedtls_svc_key_id_t key = MBEDTLS_SVC_KEY_ID_INIT;
Gilles Peskinec744d992019-07-30 17:26:54 +0200714 psa_status_t status;
715 uint8_t *buffer = NULL;
716 size_t buffer_size = byte_size + 1;
717 size_t n;
718
Steven Cooreman69967ce2021-01-18 18:01:08 +0100719 /* Skip the test case if the target running the test cannot
720 * accomodate large keys due to heap size constraints */
721 ASSERT_ALLOC_WEAK( buffer, buffer_size );
Gilles Peskinec744d992019-07-30 17:26:54 +0200722 memset( buffer, 'K', byte_size );
723
724 PSA_ASSERT( psa_crypto_init( ) );
725
726 /* Try importing the key */
727 psa_set_key_usage_flags( &attributes, PSA_KEY_USAGE_EXPORT );
728 psa_set_key_type( &attributes, type );
Ronald Cron5425a212020-08-04 14:58:35 +0200729 status = psa_import_key( &attributes, buffer, byte_size, &key );
Steven Cooreman83fdb702021-01-21 14:24:39 +0100730 TEST_ASSUME( status != PSA_ERROR_INSUFFICIENT_MEMORY );
Gilles Peskinec744d992019-07-30 17:26:54 +0200731 TEST_EQUAL( status, expected_status );
732
733 if( status == PSA_SUCCESS )
734 {
Ronald Cron5425a212020-08-04 14:58:35 +0200735 PSA_ASSERT( psa_get_key_attributes( key, &attributes ) );
Gilles Peskinec744d992019-07-30 17:26:54 +0200736 TEST_EQUAL( psa_get_key_type( &attributes ), type );
737 TEST_EQUAL( psa_get_key_bits( &attributes ),
738 PSA_BYTES_TO_BITS( byte_size ) );
Gilles Peskine5fe5e272019-08-02 20:30:01 +0200739 ASSERT_NO_SLOT_NUMBER( &attributes );
Gilles Peskinec744d992019-07-30 17:26:54 +0200740 memset( buffer, 0, byte_size + 1 );
Ronald Cron5425a212020-08-04 14:58:35 +0200741 PSA_ASSERT( psa_export_key( key, buffer, byte_size, &n ) );
Gilles Peskinec744d992019-07-30 17:26:54 +0200742 for( n = 0; n < byte_size; n++ )
743 TEST_EQUAL( buffer[n], 'K' );
744 for( n = byte_size; n < buffer_size; n++ )
745 TEST_EQUAL( buffer[n], 0 );
746 }
747
748exit:
Ronald Cron3a4f0e32020-11-19 17:55:23 +0100749 /*
750 * Key attributes may have been returned by psa_get_key_attributes()
751 * thus reset them as required.
752 */
753 psa_reset_key_attributes( &attributes );
754
Ronald Cron5425a212020-08-04 14:58:35 +0200755 psa_destroy_key( key );
Gilles Peskinec744d992019-07-30 17:26:54 +0200756 PSA_DONE( );
757 mbedtls_free( buffer );
758}
759/* END_CASE */
760
761/* BEGIN_CASE */
Gilles Peskine0b352bc2018-06-28 00:16:11 +0200762void import_rsa_made_up( int bits_arg, int keypair, int expected_status_arg )
763{
Ronald Cron5425a212020-08-04 14:58:35 +0200764 mbedtls_svc_key_id_t key = MBEDTLS_SVC_KEY_ID_INIT;
Gilles Peskine0b352bc2018-06-28 00:16:11 +0200765 size_t bits = bits_arg;
766 psa_status_t expected_status = expected_status_arg;
767 psa_status_t status;
768 psa_key_type_t type =
Gilles Peskinec93b80c2019-05-16 19:39:54 +0200769 keypair ? PSA_KEY_TYPE_RSA_KEY_PAIR : PSA_KEY_TYPE_RSA_PUBLIC_KEY;
Gilles Peskine0b352bc2018-06-28 00:16:11 +0200770 size_t buffer_size = /* Slight overapproximations */
771 keypair ? bits * 9 / 16 + 80 : bits / 8 + 20;
Gilles Peskine8cebbba2018-09-27 13:54:18 +0200772 unsigned char *buffer = NULL;
Gilles Peskine0b352bc2018-06-28 00:16:11 +0200773 unsigned char *p;
774 int ret;
775 size_t length;
Gilles Peskine2c2cf0e2019-04-19 19:58:20 +0200776 psa_key_attributes_t attributes = PSA_KEY_ATTRIBUTES_INIT;
Gilles Peskine0b352bc2018-06-28 00:16:11 +0200777
Gilles Peskine8817f612018-12-18 00:18:46 +0100778 PSA_ASSERT( psa_crypto_init( ) );
Gilles Peskine8cebbba2018-09-27 13:54:18 +0200779 ASSERT_ALLOC( buffer, buffer_size );
Gilles Peskine0b352bc2018-06-28 00:16:11 +0200780
781 TEST_ASSERT( ( ret = construct_fake_rsa_key( buffer, buffer_size, &p,
782 bits, keypair ) ) >= 0 );
783 length = ret;
784
785 /* Try importing the key */
Gilles Peskine2c2cf0e2019-04-19 19:58:20 +0200786 psa_set_key_type( &attributes, type );
Ronald Cron5425a212020-08-04 14:58:35 +0200787 status = psa_import_key( &attributes, p, length, &key );
Gilles Peskinefe11b722018-12-18 00:24:04 +0100788 TEST_EQUAL( status, expected_status );
Gilles Peskine76b29a72019-05-28 14:08:50 +0200789
Gilles Peskine0b352bc2018-06-28 00:16:11 +0200790 if( status == PSA_SUCCESS )
Ronald Cron5425a212020-08-04 14:58:35 +0200791 PSA_ASSERT( psa_destroy_key( key ) );
Gilles Peskine0b352bc2018-06-28 00:16:11 +0200792
793exit:
794 mbedtls_free( buffer );
Gilles Peskine1153e7b2019-05-28 15:10:21 +0200795 PSA_DONE( );
Gilles Peskine0b352bc2018-06-28 00:16:11 +0200796}
797/* END_CASE */
798
799/* BEGIN_CASE */
itayzafrir3e02b3b2018-06-12 17:06:52 +0300800void import_export( data_t *data,
Moran Pekera964a8f2018-06-04 18:42:36 +0300801 int type_arg,
Gilles Peskine1ecf92c22019-05-24 15:00:06 +0200802 int usage_arg, int alg_arg,
Archana4d7ae1d2021-07-07 02:50:22 +0530803 int lifetime_arg,
Gilles Peskine2f9c4dc2018-01-28 13:16:24 +0100804 int expected_bits,
805 int export_size_delta,
Gilles Peskineb866e2b2018-06-21 09:25:10 +0200806 int expected_export_status_arg,
Gilles Peskine2f9c4dc2018-01-28 13:16:24 +0100807 int canonical_input )
808{
Ronald Cron5425a212020-08-04 14:58:35 +0200809 mbedtls_svc_key_id_t key = MBEDTLS_SVC_KEY_ID_INIT;
Gilles Peskine2f9c4dc2018-01-28 13:16:24 +0100810 psa_key_type_t type = type_arg;
Gilles Peskine4abf7412018-06-18 16:35:34 +0200811 psa_algorithm_t alg = alg_arg;
Gilles Peskineb866e2b2018-06-21 09:25:10 +0200812 psa_status_t expected_export_status = expected_export_status_arg;
Gilles Peskine2f9c4dc2018-01-28 13:16:24 +0100813 psa_status_t status;
Archana4d7ae1d2021-07-07 02:50:22 +0530814 psa_key_lifetime_t lifetime = lifetime_arg;
Gilles Peskine2f9c4dc2018-01-28 13:16:24 +0100815 unsigned char *exported = NULL;
816 unsigned char *reexported = NULL;
Gilles Peskine2f9c4dc2018-01-28 13:16:24 +0100817 size_t export_size;
Jaeden Amerof24c7f82018-06-27 17:20:43 +0100818 size_t exported_length = INVALID_EXPORT_LENGTH;
Gilles Peskine2f9c4dc2018-01-28 13:16:24 +0100819 size_t reexported_length;
Gilles Peskine4747d192019-04-17 15:05:45 +0200820 psa_key_attributes_t attributes = PSA_KEY_ATTRIBUTES_INIT;
Gilles Peskine8c8f2ab2019-04-18 21:44:46 +0200821 psa_key_attributes_t got_attributes = PSA_KEY_ATTRIBUTES_INIT;
Gilles Peskine2f9c4dc2018-01-28 13:16:24 +0100822
Moran Pekercb088e72018-07-17 17:36:59 +0300823 export_size = (ptrdiff_t) data->len + export_size_delta;
Gilles Peskine8cebbba2018-09-27 13:54:18 +0200824 ASSERT_ALLOC( exported, export_size );
Gilles Peskine2f9c4dc2018-01-28 13:16:24 +0100825 if( ! canonical_input )
Gilles Peskine8cebbba2018-09-27 13:54:18 +0200826 ASSERT_ALLOC( reexported, export_size );
Gilles Peskine8817f612018-12-18 00:18:46 +0100827 PSA_ASSERT( psa_crypto_init( ) );
Gilles Peskine2f9c4dc2018-01-28 13:16:24 +0100828
Archana4d7ae1d2021-07-07 02:50:22 +0530829 psa_set_key_lifetime( &attributes, lifetime );
Gilles Peskine4747d192019-04-17 15:05:45 +0200830 psa_set_key_usage_flags( &attributes, usage_arg );
831 psa_set_key_algorithm( &attributes, alg );
832 psa_set_key_type( &attributes, type );
mohammad1603a97cb8c2018-03-28 03:46:26 -0700833
Gilles Peskine2f9c4dc2018-01-28 13:16:24 +0100834 /* Import the key */
Ronald Cron5425a212020-08-04 14:58:35 +0200835 PSA_ASSERT( psa_import_key( &attributes, data->x, data->len, &key ) );
Gilles Peskine2f9c4dc2018-01-28 13:16:24 +0100836
837 /* Test the key information */
Ronald Cron5425a212020-08-04 14:58:35 +0200838 PSA_ASSERT( psa_get_key_attributes( key, &got_attributes ) );
Gilles Peskine8c8f2ab2019-04-18 21:44:46 +0200839 TEST_EQUAL( psa_get_key_type( &got_attributes ), type );
840 TEST_EQUAL( psa_get_key_bits( &got_attributes ), (size_t) expected_bits );
Gilles Peskine5fe5e272019-08-02 20:30:01 +0200841 ASSERT_NO_SLOT_NUMBER( &got_attributes );
Gilles Peskine2f9c4dc2018-01-28 13:16:24 +0100842
843 /* Export the key */
Ronald Cron5425a212020-08-04 14:58:35 +0200844 status = psa_export_key( key, exported, export_size, &exported_length );
Gilles Peskinefe11b722018-12-18 00:24:04 +0100845 TEST_EQUAL( status, expected_export_status );
Jaeden Amerof24c7f82018-06-27 17:20:43 +0100846
847 /* The exported length must be set by psa_export_key() to a value between 0
848 * and export_size. On errors, the exported length must be 0. */
849 TEST_ASSERT( exported_length != INVALID_EXPORT_LENGTH );
850 TEST_ASSERT( status == PSA_SUCCESS || exported_length == 0 );
851 TEST_ASSERT( exported_length <= export_size );
852
Gilles Peskinea7aa4422018-08-14 15:17:54 +0200853 TEST_ASSERT( mem_is_char( exported + exported_length, 0,
Gilles Peskine3f669c32018-06-21 09:21:51 +0200854 export_size - exported_length ) );
Gilles Peskine2f9c4dc2018-01-28 13:16:24 +0100855 if( status != PSA_SUCCESS )
Gilles Peskinee66ca3b2018-06-20 00:11:45 +0200856 {
Gilles Peskinefe11b722018-12-18 00:24:04 +0100857 TEST_EQUAL( exported_length, 0 );
Gilles Peskine2f9c4dc2018-01-28 13:16:24 +0100858 goto destroy;
Gilles Peskinee66ca3b2018-06-20 00:11:45 +0200859 }
Gilles Peskine2f9c4dc2018-01-28 13:16:24 +0100860
Gilles Peskineea38a922021-02-13 00:05:16 +0100861 /* Run sanity checks on the exported key. For non-canonical inputs,
862 * this validates the canonical representations. For canonical inputs,
863 * this doesn't directly validate the implementation, but it still helps
864 * by cross-validating the test data with the sanity check code. */
Archana4d7ae1d2021-07-07 02:50:22 +0530865 if( !psa_key_lifetime_is_external( lifetime ) )
866 {
867 if( ! mbedtls_test_psa_exercise_key( key, usage_arg, 0 ) )
868 goto exit;
869 }
Gilles Peskine8f609232018-08-11 01:24:55 +0200870
Gilles Peskine2f9c4dc2018-01-28 13:16:24 +0100871 if( canonical_input )
Gilles Peskinebd7dea92018-09-27 13:57:19 +0200872 ASSERT_COMPARE( data->x, data->len, exported, exported_length );
Gilles Peskine2f9c4dc2018-01-28 13:16:24 +0100873 else
874 {
Ronald Cron5425a212020-08-04 14:58:35 +0200875 mbedtls_svc_key_id_t key2 = MBEDTLS_SVC_KEY_ID_INIT;
Gilles Peskine049c7532019-05-15 20:22:09 +0200876 PSA_ASSERT( psa_import_key( &attributes, exported, exported_length,
Ronald Cron5425a212020-08-04 14:58:35 +0200877 &key2 ) );
878 PSA_ASSERT( psa_export_key( key2,
Gilles Peskine8817f612018-12-18 00:18:46 +0100879 reexported,
880 export_size,
881 &reexported_length ) );
Gilles Peskinebd7dea92018-09-27 13:57:19 +0200882 ASSERT_COMPARE( exported, exported_length,
Archana4d7ae1d2021-07-07 02:50:22 +0530883 reexported, reexported_length );
Ronald Cron5425a212020-08-04 14:58:35 +0200884 PSA_ASSERT( psa_destroy_key( key2 ) );
Gilles Peskine2f9c4dc2018-01-28 13:16:24 +0100885 }
gabor-mezei-armceface22021-01-21 12:26:17 +0100886 TEST_ASSERT( exported_length <=
Archana4d7ae1d2021-07-07 02:50:22 +0530887 PSA_EXPORT_KEY_OUTPUT_SIZE( type,
Archana9d17bf42021-09-10 06:22:44 +0530888 psa_get_key_bits( &got_attributes ) ) );
gabor-mezei-armceface22021-01-21 12:26:17 +0100889 TEST_ASSERT( exported_length <= PSA_EXPORT_KEY_PAIR_MAX_SIZE );
Gilles Peskine2f9c4dc2018-01-28 13:16:24 +0100890
891destroy:
892 /* Destroy the key */
Ronald Cron5425a212020-08-04 14:58:35 +0200893 PSA_ASSERT( psa_destroy_key( key ) );
894 test_operations_on_invalid_key( key );
Gilles Peskine2f9c4dc2018-01-28 13:16:24 +0100895
896exit:
Ronald Cron3a4f0e32020-11-19 17:55:23 +0100897 /*
898 * Key attributes may have been returned by psa_get_key_attributes()
899 * thus reset them as required.
900 */
901 psa_reset_key_attributes( &got_attributes );
Archana4d7ae1d2021-07-07 02:50:22 +0530902 psa_destroy_key( key ) ;
itayzafrir3e02b3b2018-06-12 17:06:52 +0300903 mbedtls_free( exported );
904 mbedtls_free( reexported );
Gilles Peskine1153e7b2019-05-28 15:10:21 +0200905 PSA_DONE( );
Gilles Peskine2f9c4dc2018-01-28 13:16:24 +0100906}
907/* END_CASE */
Gilles Peskine20035e32018-02-03 22:44:14 +0100908
Moran Pekerf709f4a2018-06-06 17:26:04 +0300909/* BEGIN_CASE */
itayzafrir3e02b3b2018-06-12 17:06:52 +0300910void import_export_public_key( data_t *data,
Gilles Peskine2d277862018-06-18 15:41:12 +0200911 int type_arg,
912 int alg_arg,
Archana4d7ae1d2021-07-07 02:50:22 +0530913 int lifetime_arg,
Gilles Peskine49c25912018-10-29 15:15:31 +0100914 int export_size_delta,
915 int expected_export_status_arg,
916 data_t *expected_public_key )
Moran Pekerf709f4a2018-06-06 17:26:04 +0300917{
Ronald Cron5425a212020-08-04 14:58:35 +0200918 mbedtls_svc_key_id_t key = MBEDTLS_SVC_KEY_ID_INIT;
Moran Pekerf709f4a2018-06-06 17:26:04 +0300919 psa_key_type_t type = type_arg;
Gilles Peskine4abf7412018-06-18 16:35:34 +0200920 psa_algorithm_t alg = alg_arg;
Gilles Peskineb866e2b2018-06-21 09:25:10 +0200921 psa_status_t expected_export_status = expected_export_status_arg;
Moran Pekerf709f4a2018-06-06 17:26:04 +0300922 psa_status_t status;
Archana4d7ae1d2021-07-07 02:50:22 +0530923 psa_key_lifetime_t lifetime = lifetime_arg;
Moran Pekerf709f4a2018-06-06 17:26:04 +0300924 unsigned char *exported = NULL;
Gilles Peskine49c25912018-10-29 15:15:31 +0100925 size_t export_size = expected_public_key->len + export_size_delta;
Jaeden Amero2a671e92018-06-27 17:47:40 +0100926 size_t exported_length = INVALID_EXPORT_LENGTH;
Gilles Peskine4747d192019-04-17 15:05:45 +0200927 psa_key_attributes_t attributes = PSA_KEY_ATTRIBUTES_INIT;
Moran Pekerf709f4a2018-06-06 17:26:04 +0300928
Gilles Peskine8817f612018-12-18 00:18:46 +0100929 PSA_ASSERT( psa_crypto_init( ) );
Moran Pekerf709f4a2018-06-06 17:26:04 +0300930
Archana4d7ae1d2021-07-07 02:50:22 +0530931 psa_set_key_lifetime( &attributes, lifetime );
Gilles Peskine4747d192019-04-17 15:05:45 +0200932 psa_set_key_usage_flags( &attributes, PSA_KEY_USAGE_EXPORT );
933 psa_set_key_algorithm( &attributes, alg );
934 psa_set_key_type( &attributes, type );
Moran Pekerf709f4a2018-06-06 17:26:04 +0300935
936 /* Import the key */
Ronald Cron5425a212020-08-04 14:58:35 +0200937 PSA_ASSERT( psa_import_key( &attributes, data->x, data->len, &key ) );
Moran Pekerf709f4a2018-06-06 17:26:04 +0300938
Gilles Peskine49c25912018-10-29 15:15:31 +0100939 /* Export the public key */
940 ASSERT_ALLOC( exported, export_size );
Ronald Cron5425a212020-08-04 14:58:35 +0200941 status = psa_export_public_key( key,
Gilles Peskine2d277862018-06-18 15:41:12 +0200942 exported, export_size,
943 &exported_length );
Gilles Peskinefe11b722018-12-18 00:24:04 +0100944 TEST_EQUAL( status, expected_export_status );
Gilles Peskine49c25912018-10-29 15:15:31 +0100945 if( status == PSA_SUCCESS )
Gilles Peskined8b7d4f2018-10-29 15:18:41 +0100946 {
Gilles Peskinec93b80c2019-05-16 19:39:54 +0200947 psa_key_type_t public_type = PSA_KEY_TYPE_PUBLIC_KEY_OF_KEY_PAIR( type );
Gilles Peskined8b7d4f2018-10-29 15:18:41 +0100948 size_t bits;
Ronald Cron5425a212020-08-04 14:58:35 +0200949 PSA_ASSERT( psa_get_key_attributes( key, &attributes ) );
Gilles Peskine8c8f2ab2019-04-18 21:44:46 +0200950 bits = psa_get_key_bits( &attributes );
Gilles Peskined8b7d4f2018-10-29 15:18:41 +0100951 TEST_ASSERT( expected_public_key->len <=
gabor-mezei-armcbcec212020-12-18 14:23:51 +0100952 PSA_EXPORT_KEY_OUTPUT_SIZE( public_type, bits ) );
gabor-mezei-armceface22021-01-21 12:26:17 +0100953 TEST_ASSERT( expected_public_key->len <=
954 PSA_EXPORT_PUBLIC_KEY_OUTPUT_SIZE( public_type, bits ) );
955 TEST_ASSERT( expected_public_key->len <=
956 PSA_EXPORT_PUBLIC_KEY_MAX_SIZE );
Gilles Peskine49c25912018-10-29 15:15:31 +0100957 ASSERT_COMPARE( expected_public_key->x, expected_public_key->len,
958 exported, exported_length );
Gilles Peskined8b7d4f2018-10-29 15:18:41 +0100959 }
Moran Pekerf709f4a2018-06-06 17:26:04 +0300960exit:
Ronald Cron3a4f0e32020-11-19 17:55:23 +0100961 /*
962 * Key attributes may have been returned by psa_get_key_attributes()
963 * thus reset them as required.
964 */
965 psa_reset_key_attributes( &attributes );
966
itayzafrir3e02b3b2018-06-12 17:06:52 +0300967 mbedtls_free( exported );
Ronald Cron5425a212020-08-04 14:58:35 +0200968 psa_destroy_key( key );
Gilles Peskine1153e7b2019-05-28 15:10:21 +0200969 PSA_DONE( );
Moran Pekerf709f4a2018-06-06 17:26:04 +0300970}
971/* END_CASE */
972
Gilles Peskine20035e32018-02-03 22:44:14 +0100973/* BEGIN_CASE */
Gilles Peskinea680c7a2018-06-26 16:12:43 +0200974void import_and_exercise_key( data_t *data,
975 int type_arg,
976 int bits_arg,
977 int alg_arg )
978{
Ronald Cron5425a212020-08-04 14:58:35 +0200979 mbedtls_svc_key_id_t key = MBEDTLS_SVC_KEY_ID_INIT;
Gilles Peskinea680c7a2018-06-26 16:12:43 +0200980 psa_key_type_t type = type_arg;
981 size_t bits = bits_arg;
982 psa_algorithm_t alg = alg_arg;
Gilles Peskinec18e25f2021-02-12 23:48:20 +0100983 psa_key_usage_t usage = mbedtls_test_psa_usage_to_exercise( type, alg );
Gilles Peskine4747d192019-04-17 15:05:45 +0200984 psa_key_attributes_t attributes = PSA_KEY_ATTRIBUTES_INIT;
Gilles Peskine8c8f2ab2019-04-18 21:44:46 +0200985 psa_key_attributes_t got_attributes = PSA_KEY_ATTRIBUTES_INIT;
Gilles Peskinea680c7a2018-06-26 16:12:43 +0200986
Gilles Peskine8817f612018-12-18 00:18:46 +0100987 PSA_ASSERT( psa_crypto_init( ) );
Gilles Peskinea680c7a2018-06-26 16:12:43 +0200988
Gilles Peskine4747d192019-04-17 15:05:45 +0200989 psa_set_key_usage_flags( &attributes, usage );
990 psa_set_key_algorithm( &attributes, alg );
991 psa_set_key_type( &attributes, type );
Gilles Peskinea680c7a2018-06-26 16:12:43 +0200992
993 /* Import the key */
Ronald Cron5425a212020-08-04 14:58:35 +0200994 PSA_ASSERT( psa_import_key( &attributes, data->x, data->len, &key ) );
Gilles Peskinea680c7a2018-06-26 16:12:43 +0200995
996 /* Test the key information */
Ronald Cron5425a212020-08-04 14:58:35 +0200997 PSA_ASSERT( psa_get_key_attributes( key, &got_attributes ) );
Gilles Peskine8c8f2ab2019-04-18 21:44:46 +0200998 TEST_EQUAL( psa_get_key_type( &got_attributes ), type );
999 TEST_EQUAL( psa_get_key_bits( &got_attributes ), bits );
Gilles Peskinea680c7a2018-06-26 16:12:43 +02001000
1001 /* Do something with the key according to its type and permitted usage. */
Gilles Peskinec18e25f2021-02-12 23:48:20 +01001002 if( ! mbedtls_test_psa_exercise_key( key, usage, alg ) )
Gilles Peskine02b75072018-07-01 22:31:34 +02001003 goto exit;
Gilles Peskinea680c7a2018-06-26 16:12:43 +02001004
Ronald Cron5425a212020-08-04 14:58:35 +02001005 PSA_ASSERT( psa_destroy_key( key ) );
1006 test_operations_on_invalid_key( key );
Gilles Peskine4cf3a432019-04-18 22:28:52 +02001007
Gilles Peskinea680c7a2018-06-26 16:12:43 +02001008exit:
Ronald Cron3a4f0e32020-11-19 17:55:23 +01001009 /*
1010 * Key attributes may have been returned by psa_get_key_attributes()
1011 * thus reset them as required.
1012 */
Gilles Peskinea1ace9c2019-04-26 16:03:33 +02001013 psa_reset_key_attributes( &got_attributes );
Ronald Cron3a4f0e32020-11-19 17:55:23 +01001014
1015 psa_reset_key_attributes( &attributes );
1016 psa_destroy_key( key );
Gilles Peskine1153e7b2019-05-28 15:10:21 +02001017 PSA_DONE( );
Gilles Peskinea680c7a2018-06-26 16:12:43 +02001018}
1019/* END_CASE */
1020
1021/* BEGIN_CASE */
Gilles Peskine06c28892019-11-26 18:07:46 +01001022void effective_key_attributes( int type_arg, int expected_type_arg,
1023 int bits_arg, int expected_bits_arg,
1024 int usage_arg, int expected_usage_arg,
1025 int alg_arg, int expected_alg_arg )
Gilles Peskined5b33222018-06-18 22:20:03 +02001026{
Ronald Cron5425a212020-08-04 14:58:35 +02001027 mbedtls_svc_key_id_t key = MBEDTLS_SVC_KEY_ID_INIT;
Gilles Peskine1a960492019-11-26 17:12:21 +01001028 psa_key_type_t key_type = type_arg;
Gilles Peskine06c28892019-11-26 18:07:46 +01001029 psa_key_type_t expected_key_type = expected_type_arg;
Gilles Peskine1a960492019-11-26 17:12:21 +01001030 size_t bits = bits_arg;
Gilles Peskine06c28892019-11-26 18:07:46 +01001031 size_t expected_bits = expected_bits_arg;
Gilles Peskined5b33222018-06-18 22:20:03 +02001032 psa_algorithm_t alg = alg_arg;
Gilles Peskine06c28892019-11-26 18:07:46 +01001033 psa_algorithm_t expected_alg = expected_alg_arg;
Gilles Peskined5b33222018-06-18 22:20:03 +02001034 psa_key_usage_t usage = usage_arg;
Gilles Peskine06c28892019-11-26 18:07:46 +01001035 psa_key_usage_t expected_usage = expected_usage_arg;
Gilles Peskine8c8f2ab2019-04-18 21:44:46 +02001036 psa_key_attributes_t attributes = PSA_KEY_ATTRIBUTES_INIT;
Gilles Peskined5b33222018-06-18 22:20:03 +02001037
Gilles Peskine8817f612018-12-18 00:18:46 +01001038 PSA_ASSERT( psa_crypto_init( ) );
Gilles Peskined5b33222018-06-18 22:20:03 +02001039
Gilles Peskine8c8f2ab2019-04-18 21:44:46 +02001040 psa_set_key_usage_flags( &attributes, usage );
1041 psa_set_key_algorithm( &attributes, alg );
1042 psa_set_key_type( &attributes, key_type );
Gilles Peskine1a960492019-11-26 17:12:21 +01001043 psa_set_key_bits( &attributes, bits );
Gilles Peskined5b33222018-06-18 22:20:03 +02001044
Ronald Cron5425a212020-08-04 14:58:35 +02001045 PSA_ASSERT( psa_generate_key( &attributes, &key ) );
Gilles Peskine1a960492019-11-26 17:12:21 +01001046 psa_reset_key_attributes( &attributes );
Gilles Peskined5b33222018-06-18 22:20:03 +02001047
Ronald Cron5425a212020-08-04 14:58:35 +02001048 PSA_ASSERT( psa_get_key_attributes( key, &attributes ) );
Gilles Peskine06c28892019-11-26 18:07:46 +01001049 TEST_EQUAL( psa_get_key_type( &attributes ), expected_key_type );
1050 TEST_EQUAL( psa_get_key_bits( &attributes ), expected_bits );
1051 TEST_EQUAL( psa_get_key_usage_flags( &attributes ), expected_usage );
1052 TEST_EQUAL( psa_get_key_algorithm( &attributes ), expected_alg );
Gilles Peskined5b33222018-06-18 22:20:03 +02001053
1054exit:
Ronald Cron3a4f0e32020-11-19 17:55:23 +01001055 /*
1056 * Key attributes may have been returned by psa_get_key_attributes()
1057 * thus reset them as required.
1058 */
Gilles Peskinea1ace9c2019-04-26 16:03:33 +02001059 psa_reset_key_attributes( &attributes );
Ronald Cron3a4f0e32020-11-19 17:55:23 +01001060
1061 psa_destroy_key( key );
Gilles Peskine1153e7b2019-05-28 15:10:21 +02001062 PSA_DONE( );
Gilles Peskined5b33222018-06-18 22:20:03 +02001063}
1064/* END_CASE */
1065
1066/* BEGIN_CASE */
Gilles Peskine06c28892019-11-26 18:07:46 +01001067void check_key_policy( int type_arg, int bits_arg,
1068 int usage_arg, int alg_arg )
1069{
1070 test_effective_key_attributes( type_arg, type_arg, bits_arg, bits_arg,
gabor-mezei-armff8264c2021-06-28 14:36:03 +02001071 usage_arg,
1072 mbedtls_test_update_key_usage_flags( usage_arg ),
gabor-mezei-armedf2df82021-05-13 16:17:16 +02001073 alg_arg, alg_arg );
Gilles Peskine06c28892019-11-26 18:07:46 +01001074 goto exit;
1075}
1076/* END_CASE */
1077
1078/* BEGIN_CASE */
Gilles Peskine2c2cf0e2019-04-19 19:58:20 +02001079void key_attributes_init( )
Jaeden Amero70261c52019-01-04 11:47:20 +00001080{
1081 /* Test each valid way of initializing the object, except for `= {0}`, as
1082 * Clang 5 complains when `-Wmissing-field-initializers` is used, even
1083 * though it's OK by the C standard. We could test for this, but we'd need
1084 * to supress the Clang warning for the test. */
Gilles Peskine2c2cf0e2019-04-19 19:58:20 +02001085 psa_key_attributes_t func = psa_key_attributes_init( );
1086 psa_key_attributes_t init = PSA_KEY_ATTRIBUTES_INIT;
1087 psa_key_attributes_t zero;
Jaeden Amero70261c52019-01-04 11:47:20 +00001088
1089 memset( &zero, 0, sizeof( zero ) );
1090
Gilles Peskine2c2cf0e2019-04-19 19:58:20 +02001091 TEST_EQUAL( psa_get_key_lifetime( &func ), PSA_KEY_LIFETIME_VOLATILE );
1092 TEST_EQUAL( psa_get_key_lifetime( &init ), PSA_KEY_LIFETIME_VOLATILE );
1093 TEST_EQUAL( psa_get_key_lifetime( &zero ), PSA_KEY_LIFETIME_VOLATILE );
Jaeden Amero5229bbb2019-02-07 16:33:37 +00001094
Gilles Peskine2c2cf0e2019-04-19 19:58:20 +02001095 TEST_EQUAL( psa_get_key_type( &func ), 0 );
1096 TEST_EQUAL( psa_get_key_type( &init ), 0 );
1097 TEST_EQUAL( psa_get_key_type( &zero ), 0 );
1098
1099 TEST_EQUAL( psa_get_key_bits( &func ), 0 );
1100 TEST_EQUAL( psa_get_key_bits( &init ), 0 );
1101 TEST_EQUAL( psa_get_key_bits( &zero ), 0 );
1102
1103 TEST_EQUAL( psa_get_key_usage_flags( &func ), 0 );
1104 TEST_EQUAL( psa_get_key_usage_flags( &init ), 0 );
1105 TEST_EQUAL( psa_get_key_usage_flags( &zero ), 0 );
1106
1107 TEST_EQUAL( psa_get_key_algorithm( &func ), 0 );
1108 TEST_EQUAL( psa_get_key_algorithm( &init ), 0 );
1109 TEST_EQUAL( psa_get_key_algorithm( &zero ), 0 );
Jaeden Amero70261c52019-01-04 11:47:20 +00001110}
1111/* END_CASE */
1112
1113/* BEGIN_CASE */
gabor-mezei-armedf2df82021-05-13 16:17:16 +02001114void mac_key_policy( int policy_usage_arg,
1115 int policy_alg_arg,
1116 int key_type_arg,
Gilles Peskine76f5c7b2018-07-06 16:53:09 +02001117 data_t *key_data,
gabor-mezei-armedf2df82021-05-13 16:17:16 +02001118 int exercise_alg_arg,
Mateusz Starzykd07f4fc2021-08-24 11:01:23 +02001119 int expected_status_sign_arg,
1120 int expected_status_verify_arg )
Gilles Peskined5b33222018-06-18 22:20:03 +02001121{
Ronald Cron5425a212020-08-04 14:58:35 +02001122 mbedtls_svc_key_id_t key = MBEDTLS_SVC_KEY_ID_INIT;
Gilles Peskine2c2cf0e2019-04-19 19:58:20 +02001123 psa_key_attributes_t attributes = PSA_KEY_ATTRIBUTES_INIT;
Jaeden Amero769ce272019-01-04 11:48:03 +00001124 psa_mac_operation_t operation = PSA_MAC_OPERATION_INIT;
gabor-mezei-armedf2df82021-05-13 16:17:16 +02001125 psa_key_type_t key_type = key_type_arg;
1126 psa_algorithm_t policy_alg = policy_alg_arg;
1127 psa_algorithm_t exercise_alg = exercise_alg_arg;
1128 psa_key_usage_t policy_usage = policy_usage_arg;
Gilles Peskine76f5c7b2018-07-06 16:53:09 +02001129 psa_status_t status;
Mateusz Starzykd07f4fc2021-08-24 11:01:23 +02001130 psa_status_t expected_status_sign = expected_status_sign_arg;
1131 psa_status_t expected_status_verify = expected_status_verify_arg;
Gilles Peskine76f5c7b2018-07-06 16:53:09 +02001132 unsigned char mac[PSA_MAC_MAX_SIZE];
Gilles Peskined5b33222018-06-18 22:20:03 +02001133
Gilles Peskine8817f612018-12-18 00:18:46 +01001134 PSA_ASSERT( psa_crypto_init( ) );
Gilles Peskined5b33222018-06-18 22:20:03 +02001135
Gilles Peskine2c2cf0e2019-04-19 19:58:20 +02001136 psa_set_key_usage_flags( &attributes, policy_usage );
1137 psa_set_key_algorithm( &attributes, policy_alg );
1138 psa_set_key_type( &attributes, key_type );
Gilles Peskined5b33222018-06-18 22:20:03 +02001139
Gilles Peskine049c7532019-05-15 20:22:09 +02001140 PSA_ASSERT( psa_import_key( &attributes, key_data->x, key_data->len,
Ronald Cron5425a212020-08-04 14:58:35 +02001141 &key ) );
Gilles Peskined5b33222018-06-18 22:20:03 +02001142
gabor-mezei-arm40d5cd82021-06-29 11:06:16 +02001143 TEST_EQUAL( psa_get_key_usage_flags( &attributes ),
1144 mbedtls_test_update_key_usage_flags( policy_usage ) );
gabor-mezei-armedf2df82021-05-13 16:17:16 +02001145
Ronald Cron5425a212020-08-04 14:58:35 +02001146 status = psa_mac_sign_setup( &operation, key, exercise_alg );
Mateusz Starzykd07f4fc2021-08-24 11:01:23 +02001147 TEST_EQUAL( status, expected_status_sign );
Steven Cooremanb3ce8152021-02-18 12:03:50 +01001148
Mateusz Starzyk1ebcd552021-08-30 17:09:03 +02001149 /* Calculate the MAC, one-shot case. */
1150 uint8_t input[128] = {0};
1151 size_t mac_len;
1152 TEST_EQUAL( psa_mac_compute( key, exercise_alg,
1153 input, 128,
1154 mac, PSA_MAC_MAX_SIZE, &mac_len ),
1155 expected_status_sign );
1156
1157 /* Verify correct MAC, one-shot case. */
1158 status = psa_mac_verify( key, exercise_alg, input, 128,
1159 mac, mac_len );
1160
1161 if( expected_status_sign != PSA_SUCCESS && expected_status_verify == PSA_SUCCESS )
1162 TEST_EQUAL( status, PSA_ERROR_INVALID_SIGNATURE );
Gilles Peskine8817f612018-12-18 00:18:46 +01001163 else
Mateusz Starzyk1ebcd552021-08-30 17:09:03 +02001164 TEST_EQUAL( status, expected_status_verify );
Gilles Peskinefe11b722018-12-18 00:24:04 +01001165
Gilles Peskine76f5c7b2018-07-06 16:53:09 +02001166 psa_mac_abort( &operation );
Gilles Peskined5b33222018-06-18 22:20:03 +02001167
Gilles Peskine76f5c7b2018-07-06 16:53:09 +02001168 memset( mac, 0, sizeof( mac ) );
Ronald Cron5425a212020-08-04 14:58:35 +02001169 status = psa_mac_verify_setup( &operation, key, exercise_alg );
Mateusz Starzykd07f4fc2021-08-24 11:01:23 +02001170 TEST_EQUAL( status, expected_status_verify );
Gilles Peskine76f5c7b2018-07-06 16:53:09 +02001171
1172exit:
1173 psa_mac_abort( &operation );
Ronald Cron5425a212020-08-04 14:58:35 +02001174 psa_destroy_key( key );
Gilles Peskine1153e7b2019-05-28 15:10:21 +02001175 PSA_DONE( );
Gilles Peskine76f5c7b2018-07-06 16:53:09 +02001176}
1177/* END_CASE */
1178
1179/* BEGIN_CASE */
gabor-mezei-armedf2df82021-05-13 16:17:16 +02001180void cipher_key_policy( int policy_usage_arg,
Gilles Peskine76f5c7b2018-07-06 16:53:09 +02001181 int policy_alg,
1182 int key_type,
1183 data_t *key_data,
1184 int exercise_alg )
1185{
Ronald Cron5425a212020-08-04 14:58:35 +02001186 mbedtls_svc_key_id_t key = MBEDTLS_SVC_KEY_ID_INIT;
Gilles Peskine2c2cf0e2019-04-19 19:58:20 +02001187 psa_key_attributes_t attributes = PSA_KEY_ATTRIBUTES_INIT;
Jaeden Amero5bae2272019-01-04 11:48:27 +00001188 psa_cipher_operation_t operation = PSA_CIPHER_OPERATION_INIT;
gabor-mezei-armedf2df82021-05-13 16:17:16 +02001189 psa_key_usage_t policy_usage = policy_usage_arg;
Gilles Peskine76f5c7b2018-07-06 16:53:09 +02001190 psa_status_t status;
1191
Gilles Peskine8817f612018-12-18 00:18:46 +01001192 PSA_ASSERT( psa_crypto_init( ) );
Gilles Peskine76f5c7b2018-07-06 16:53:09 +02001193
Gilles Peskine2c2cf0e2019-04-19 19:58:20 +02001194 psa_set_key_usage_flags( &attributes, policy_usage );
1195 psa_set_key_algorithm( &attributes, policy_alg );
1196 psa_set_key_type( &attributes, key_type );
Gilles Peskine76f5c7b2018-07-06 16:53:09 +02001197
Gilles Peskine049c7532019-05-15 20:22:09 +02001198 PSA_ASSERT( psa_import_key( &attributes, key_data->x, key_data->len,
Ronald Cron5425a212020-08-04 14:58:35 +02001199 &key ) );
Gilles Peskine76f5c7b2018-07-06 16:53:09 +02001200
gabor-mezei-arm98a34352021-06-28 14:05:00 +02001201 /* Check if no key usage flag implication is done */
1202 TEST_EQUAL( policy_usage,
1203 mbedtls_test_update_key_usage_flags( policy_usage ) );
gabor-mezei-armedf2df82021-05-13 16:17:16 +02001204
Ronald Cron5425a212020-08-04 14:58:35 +02001205 status = psa_cipher_encrypt_setup( &operation, key, exercise_alg );
Gilles Peskine76f5c7b2018-07-06 16:53:09 +02001206 if( policy_alg == exercise_alg &&
1207 ( policy_usage & PSA_KEY_USAGE_ENCRYPT ) != 0 )
Gilles Peskine8817f612018-12-18 00:18:46 +01001208 PSA_ASSERT( status );
Gilles Peskine76f5c7b2018-07-06 16:53:09 +02001209 else
Gilles Peskinefe11b722018-12-18 00:24:04 +01001210 TEST_EQUAL( status, PSA_ERROR_NOT_PERMITTED );
Gilles Peskine76f5c7b2018-07-06 16:53:09 +02001211 psa_cipher_abort( &operation );
1212
Ronald Cron5425a212020-08-04 14:58:35 +02001213 status = psa_cipher_decrypt_setup( &operation, key, exercise_alg );
Gilles Peskine76f5c7b2018-07-06 16:53:09 +02001214 if( policy_alg == exercise_alg &&
1215 ( policy_usage & PSA_KEY_USAGE_DECRYPT ) != 0 )
Gilles Peskine8817f612018-12-18 00:18:46 +01001216 PSA_ASSERT( status );
Gilles Peskine76f5c7b2018-07-06 16:53:09 +02001217 else
Gilles Peskinefe11b722018-12-18 00:24:04 +01001218 TEST_EQUAL( status, PSA_ERROR_NOT_PERMITTED );
Gilles Peskine76f5c7b2018-07-06 16:53:09 +02001219
1220exit:
1221 psa_cipher_abort( &operation );
Ronald Cron5425a212020-08-04 14:58:35 +02001222 psa_destroy_key( key );
Gilles Peskine1153e7b2019-05-28 15:10:21 +02001223 PSA_DONE( );
Gilles Peskine76f5c7b2018-07-06 16:53:09 +02001224}
1225/* END_CASE */
1226
1227/* BEGIN_CASE */
gabor-mezei-armedf2df82021-05-13 16:17:16 +02001228void aead_key_policy( int policy_usage_arg,
Gilles Peskine76f5c7b2018-07-06 16:53:09 +02001229 int policy_alg,
1230 int key_type,
1231 data_t *key_data,
1232 int nonce_length_arg,
1233 int tag_length_arg,
Steven Cooremanb3ce8152021-02-18 12:03:50 +01001234 int exercise_alg,
1235 int expected_status_arg )
Gilles Peskine76f5c7b2018-07-06 16:53:09 +02001236{
Ronald Cron5425a212020-08-04 14:58:35 +02001237 mbedtls_svc_key_id_t key = MBEDTLS_SVC_KEY_ID_INIT;
Gilles Peskine2c2cf0e2019-04-19 19:58:20 +02001238 psa_key_attributes_t attributes = PSA_KEY_ATTRIBUTES_INIT;
gabor-mezei-armedf2df82021-05-13 16:17:16 +02001239 psa_key_usage_t policy_usage = policy_usage_arg;
Gilles Peskine76f5c7b2018-07-06 16:53:09 +02001240 psa_status_t status;
Steven Cooremanb3ce8152021-02-18 12:03:50 +01001241 psa_status_t expected_status = expected_status_arg;
Gilles Peskine76f5c7b2018-07-06 16:53:09 +02001242 unsigned char nonce[16] = {0};
1243 size_t nonce_length = nonce_length_arg;
1244 unsigned char tag[16];
1245 size_t tag_length = tag_length_arg;
1246 size_t output_length;
1247
1248 TEST_ASSERT( nonce_length <= sizeof( nonce ) );
1249 TEST_ASSERT( tag_length <= sizeof( tag ) );
1250
Gilles Peskine8817f612018-12-18 00:18:46 +01001251 PSA_ASSERT( psa_crypto_init( ) );
Gilles Peskine76f5c7b2018-07-06 16:53:09 +02001252
Gilles Peskine2c2cf0e2019-04-19 19:58:20 +02001253 psa_set_key_usage_flags( &attributes, policy_usage );
1254 psa_set_key_algorithm( &attributes, policy_alg );
1255 psa_set_key_type( &attributes, key_type );
Gilles Peskine76f5c7b2018-07-06 16:53:09 +02001256
Gilles Peskine049c7532019-05-15 20:22:09 +02001257 PSA_ASSERT( psa_import_key( &attributes, key_data->x, key_data->len,
Ronald Cron5425a212020-08-04 14:58:35 +02001258 &key ) );
Gilles Peskine76f5c7b2018-07-06 16:53:09 +02001259
gabor-mezei-arm98a34352021-06-28 14:05:00 +02001260 /* Check if no key usage implication is done */
1261 TEST_EQUAL( policy_usage,
1262 mbedtls_test_update_key_usage_flags( policy_usage ) );
gabor-mezei-armedf2df82021-05-13 16:17:16 +02001263
Ronald Cron5425a212020-08-04 14:58:35 +02001264 status = psa_aead_encrypt( key, exercise_alg,
Gilles Peskine76f5c7b2018-07-06 16:53:09 +02001265 nonce, nonce_length,
1266 NULL, 0,
1267 NULL, 0,
1268 tag, tag_length,
1269 &output_length );
Steven Cooremanb3ce8152021-02-18 12:03:50 +01001270 if( ( policy_usage & PSA_KEY_USAGE_ENCRYPT ) != 0 )
1271 TEST_EQUAL( status, expected_status );
Gilles Peskine76f5c7b2018-07-06 16:53:09 +02001272 else
Gilles Peskinefe11b722018-12-18 00:24:04 +01001273 TEST_EQUAL( status, PSA_ERROR_NOT_PERMITTED );
Gilles Peskine76f5c7b2018-07-06 16:53:09 +02001274
1275 memset( tag, 0, sizeof( tag ) );
Ronald Cron5425a212020-08-04 14:58:35 +02001276 status = psa_aead_decrypt( key, exercise_alg,
Gilles Peskine76f5c7b2018-07-06 16:53:09 +02001277 nonce, nonce_length,
1278 NULL, 0,
1279 tag, tag_length,
1280 NULL, 0,
1281 &output_length );
Steven Cooremanb3ce8152021-02-18 12:03:50 +01001282 if( ( policy_usage & PSA_KEY_USAGE_DECRYPT ) == 0 )
1283 TEST_EQUAL( status, PSA_ERROR_NOT_PERMITTED );
1284 else if( expected_status == PSA_SUCCESS )
Gilles Peskinefe11b722018-12-18 00:24:04 +01001285 TEST_EQUAL( status, PSA_ERROR_INVALID_SIGNATURE );
Gilles Peskine76f5c7b2018-07-06 16:53:09 +02001286 else
Steven Cooremanb3ce8152021-02-18 12:03:50 +01001287 TEST_EQUAL( status, expected_status );
Gilles Peskine76f5c7b2018-07-06 16:53:09 +02001288
1289exit:
Ronald Cron5425a212020-08-04 14:58:35 +02001290 psa_destroy_key( key );
Gilles Peskine1153e7b2019-05-28 15:10:21 +02001291 PSA_DONE( );
Gilles Peskine76f5c7b2018-07-06 16:53:09 +02001292}
1293/* END_CASE */
1294
1295/* BEGIN_CASE */
gabor-mezei-armedf2df82021-05-13 16:17:16 +02001296void asymmetric_encryption_key_policy( int policy_usage_arg,
Gilles Peskine76f5c7b2018-07-06 16:53:09 +02001297 int policy_alg,
1298 int key_type,
1299 data_t *key_data,
1300 int exercise_alg )
1301{
Ronald Cron5425a212020-08-04 14:58:35 +02001302 mbedtls_svc_key_id_t key = MBEDTLS_SVC_KEY_ID_INIT;
Gilles Peskine2c2cf0e2019-04-19 19:58:20 +02001303 psa_key_attributes_t attributes = PSA_KEY_ATTRIBUTES_INIT;
gabor-mezei-armedf2df82021-05-13 16:17:16 +02001304 psa_key_usage_t policy_usage = policy_usage_arg;
Gilles Peskine76f5c7b2018-07-06 16:53:09 +02001305 psa_status_t status;
1306 size_t key_bits;
1307 size_t buffer_length;
1308 unsigned char *buffer = NULL;
1309 size_t output_length;
1310
Gilles Peskine8817f612018-12-18 00:18:46 +01001311 PSA_ASSERT( psa_crypto_init( ) );
Gilles Peskine76f5c7b2018-07-06 16:53:09 +02001312
Gilles Peskine2c2cf0e2019-04-19 19:58:20 +02001313 psa_set_key_usage_flags( &attributes, policy_usage );
1314 psa_set_key_algorithm( &attributes, policy_alg );
1315 psa_set_key_type( &attributes, key_type );
Gilles Peskine76f5c7b2018-07-06 16:53:09 +02001316
Gilles Peskine049c7532019-05-15 20:22:09 +02001317 PSA_ASSERT( psa_import_key( &attributes, key_data->x, key_data->len,
Ronald Cron5425a212020-08-04 14:58:35 +02001318 &key ) );
Gilles Peskine76f5c7b2018-07-06 16:53:09 +02001319
gabor-mezei-arm98a34352021-06-28 14:05:00 +02001320 /* Check if no key usage implication is done */
1321 TEST_EQUAL( policy_usage,
1322 mbedtls_test_update_key_usage_flags( policy_usage ) );
gabor-mezei-armedf2df82021-05-13 16:17:16 +02001323
Ronald Cron5425a212020-08-04 14:58:35 +02001324 PSA_ASSERT( psa_get_key_attributes( key, &attributes ) );
Gilles Peskine8c8f2ab2019-04-18 21:44:46 +02001325 key_bits = psa_get_key_bits( &attributes );
Gilles Peskine76f5c7b2018-07-06 16:53:09 +02001326 buffer_length = PSA_ASYMMETRIC_ENCRYPT_OUTPUT_SIZE( key_type, key_bits,
1327 exercise_alg );
Gilles Peskine8cebbba2018-09-27 13:54:18 +02001328 ASSERT_ALLOC( buffer, buffer_length );
Gilles Peskine76f5c7b2018-07-06 16:53:09 +02001329
Ronald Cron5425a212020-08-04 14:58:35 +02001330 status = psa_asymmetric_encrypt( key, exercise_alg,
Gilles Peskine76f5c7b2018-07-06 16:53:09 +02001331 NULL, 0,
1332 NULL, 0,
1333 buffer, buffer_length,
1334 &output_length );
1335 if( policy_alg == exercise_alg &&
1336 ( policy_usage & PSA_KEY_USAGE_ENCRYPT ) != 0 )
Gilles Peskine8817f612018-12-18 00:18:46 +01001337 PSA_ASSERT( status );
Gilles Peskine76f5c7b2018-07-06 16:53:09 +02001338 else
Gilles Peskinefe11b722018-12-18 00:24:04 +01001339 TEST_EQUAL( status, PSA_ERROR_NOT_PERMITTED );
Gilles Peskine76f5c7b2018-07-06 16:53:09 +02001340
Gilles Peskinef7ab5ad2018-09-26 18:19:24 +02001341 if( buffer_length != 0 )
1342 memset( buffer, 0, buffer_length );
Ronald Cron5425a212020-08-04 14:58:35 +02001343 status = psa_asymmetric_decrypt( key, exercise_alg,
Gilles Peskine76f5c7b2018-07-06 16:53:09 +02001344 buffer, buffer_length,
1345 NULL, 0,
1346 buffer, buffer_length,
1347 &output_length );
1348 if( policy_alg == exercise_alg &&
1349 ( policy_usage & PSA_KEY_USAGE_DECRYPT ) != 0 )
Gilles Peskinefe11b722018-12-18 00:24:04 +01001350 TEST_EQUAL( status, PSA_ERROR_INVALID_PADDING );
Gilles Peskine76f5c7b2018-07-06 16:53:09 +02001351 else
Gilles Peskinefe11b722018-12-18 00:24:04 +01001352 TEST_EQUAL( status, PSA_ERROR_NOT_PERMITTED );
Gilles Peskine76f5c7b2018-07-06 16:53:09 +02001353
1354exit:
Ronald Cron3a4f0e32020-11-19 17:55:23 +01001355 /*
1356 * Key attributes may have been returned by psa_get_key_attributes()
1357 * thus reset them as required.
1358 */
Gilles Peskinea1ace9c2019-04-26 16:03:33 +02001359 psa_reset_key_attributes( &attributes );
Ronald Cron3a4f0e32020-11-19 17:55:23 +01001360
1361 psa_destroy_key( key );
Gilles Peskine1153e7b2019-05-28 15:10:21 +02001362 PSA_DONE( );
Gilles Peskine76f5c7b2018-07-06 16:53:09 +02001363 mbedtls_free( buffer );
1364}
1365/* END_CASE */
1366
1367/* BEGIN_CASE */
gabor-mezei-armedf2df82021-05-13 16:17:16 +02001368void asymmetric_signature_key_policy( int policy_usage_arg,
Gilles Peskine76f5c7b2018-07-06 16:53:09 +02001369 int policy_alg,
1370 int key_type,
1371 data_t *key_data,
Gilles Peskine30f77cd2019-01-14 16:06:39 +01001372 int exercise_alg,
gabor-mezei-armedf2df82021-05-13 16:17:16 +02001373 int payload_length_arg,
gabor-mezei-armedf2df82021-05-13 16:17:16 +02001374 int expected_usage_arg )
Gilles Peskine76f5c7b2018-07-06 16:53:09 +02001375{
Ronald Cron5425a212020-08-04 14:58:35 +02001376 mbedtls_svc_key_id_t key = MBEDTLS_SVC_KEY_ID_INIT;
Gilles Peskine2c2cf0e2019-04-19 19:58:20 +02001377 psa_key_attributes_t attributes = PSA_KEY_ATTRIBUTES_INIT;
gabor-mezei-armedf2df82021-05-13 16:17:16 +02001378 psa_key_usage_t policy_usage = policy_usage_arg;
1379 psa_key_usage_t expected_usage = expected_usage_arg;
Gilles Peskine76f5c7b2018-07-06 16:53:09 +02001380 psa_status_t status;
Gilles Peskine30f77cd2019-01-14 16:06:39 +01001381 unsigned char payload[PSA_HASH_MAX_SIZE] = {1};
1382 /* If `payload_length_arg > 0`, `exercise_alg` is supposed to be
1383 * compatible with the policy and `payload_length_arg` is supposed to be
1384 * a valid input length to sign. If `payload_length_arg <= 0`,
1385 * `exercise_alg` is supposed to be forbidden by the policy. */
1386 int compatible_alg = payload_length_arg > 0;
1387 size_t payload_length = compatible_alg ? payload_length_arg : 0;
Gilles Peskine89d8c5c2019-11-26 17:01:59 +01001388 unsigned char signature[PSA_SIGNATURE_MAX_SIZE] = {0};
Gilles Peskine76f5c7b2018-07-06 16:53:09 +02001389 size_t signature_length;
1390
gabor-mezei-arm98a34352021-06-28 14:05:00 +02001391 /* Check if all implicit usage flags are deployed
gabor-mezei-armedf2df82021-05-13 16:17:16 +02001392 in the expected usage flags. */
gabor-mezei-arm98a34352021-06-28 14:05:00 +02001393 TEST_EQUAL( expected_usage,
1394 mbedtls_test_update_key_usage_flags( policy_usage ) );
gabor-mezei-armedf2df82021-05-13 16:17:16 +02001395
Gilles Peskine8817f612018-12-18 00:18:46 +01001396 PSA_ASSERT( psa_crypto_init( ) );
Gilles Peskine76f5c7b2018-07-06 16:53:09 +02001397
Gilles Peskine2c2cf0e2019-04-19 19:58:20 +02001398 psa_set_key_usage_flags( &attributes, policy_usage );
1399 psa_set_key_algorithm( &attributes, policy_alg );
1400 psa_set_key_type( &attributes, key_type );
Gilles Peskine76f5c7b2018-07-06 16:53:09 +02001401
Gilles Peskine049c7532019-05-15 20:22:09 +02001402 PSA_ASSERT( psa_import_key( &attributes, key_data->x, key_data->len,
Ronald Cron5425a212020-08-04 14:58:35 +02001403 &key ) );
Gilles Peskine76f5c7b2018-07-06 16:53:09 +02001404
gabor-mezei-armedf2df82021-05-13 16:17:16 +02001405 TEST_EQUAL( psa_get_key_usage_flags( &attributes ), expected_usage );
1406
Ronald Cron5425a212020-08-04 14:58:35 +02001407 status = psa_sign_hash( key, exercise_alg,
Gilles Peskine89d8c5c2019-11-26 17:01:59 +01001408 payload, payload_length,
1409 signature, sizeof( signature ),
1410 &signature_length );
gabor-mezei-armedf2df82021-05-13 16:17:16 +02001411 if( compatible_alg && ( expected_usage & PSA_KEY_USAGE_SIGN_HASH ) != 0 )
Gilles Peskine8817f612018-12-18 00:18:46 +01001412 PSA_ASSERT( status );
Gilles Peskine76f5c7b2018-07-06 16:53:09 +02001413 else
Gilles Peskinefe11b722018-12-18 00:24:04 +01001414 TEST_EQUAL( status, PSA_ERROR_NOT_PERMITTED );
Gilles Peskine76f5c7b2018-07-06 16:53:09 +02001415
1416 memset( signature, 0, sizeof( signature ) );
Ronald Cron5425a212020-08-04 14:58:35 +02001417 status = psa_verify_hash( key, exercise_alg,
Gilles Peskine89d8c5c2019-11-26 17:01:59 +01001418 payload, payload_length,
1419 signature, sizeof( signature ) );
gabor-mezei-armedf2df82021-05-13 16:17:16 +02001420 if( compatible_alg && ( expected_usage & PSA_KEY_USAGE_VERIFY_HASH ) != 0 )
Gilles Peskinefe11b722018-12-18 00:24:04 +01001421 TEST_EQUAL( status, PSA_ERROR_INVALID_SIGNATURE );
Gilles Peskine76f5c7b2018-07-06 16:53:09 +02001422 else
Gilles Peskinefe11b722018-12-18 00:24:04 +01001423 TEST_EQUAL( status, PSA_ERROR_NOT_PERMITTED );
Gilles Peskined5b33222018-06-18 22:20:03 +02001424
Gilles Peskinef7b41372021-09-22 16:15:05 +02001425 if( PSA_ALG_IS_SIGN_HASH( exercise_alg ) &&
gabor-mezei-armd851d682021-06-28 14:53:49 +02001426 PSA_ALG_IS_HASH( PSA_ALG_SIGN_GET_HASH( exercise_alg ) ) )
gabor-mezei-armedf2df82021-05-13 16:17:16 +02001427 {
1428 status = psa_sign_message( key, exercise_alg,
1429 payload, payload_length,
1430 signature, sizeof( signature ),
1431 &signature_length );
1432 if( compatible_alg && ( expected_usage & PSA_KEY_USAGE_SIGN_MESSAGE ) != 0 )
1433 PSA_ASSERT( status );
1434 else
1435 TEST_EQUAL( status, PSA_ERROR_NOT_PERMITTED );
1436
1437 memset( signature, 0, sizeof( signature ) );
1438 status = psa_verify_message( key, exercise_alg,
1439 payload, payload_length,
1440 signature, sizeof( signature ) );
1441 if( compatible_alg && ( expected_usage & PSA_KEY_USAGE_VERIFY_MESSAGE ) != 0 )
1442 TEST_EQUAL( status, PSA_ERROR_INVALID_SIGNATURE );
1443 else
1444 TEST_EQUAL( status, PSA_ERROR_NOT_PERMITTED );
1445 }
1446
Gilles Peskined5b33222018-06-18 22:20:03 +02001447exit:
Ronald Cron5425a212020-08-04 14:58:35 +02001448 psa_destroy_key( key );
Gilles Peskine1153e7b2019-05-28 15:10:21 +02001449 PSA_DONE( );
Gilles Peskined5b33222018-06-18 22:20:03 +02001450}
1451/* END_CASE */
1452
Janos Follathba3fab92019-06-11 14:50:16 +01001453/* BEGIN_CASE */
Gilles Peskineea0fb492018-07-12 17:17:20 +02001454void derive_key_policy( int policy_usage,
1455 int policy_alg,
1456 int key_type,
1457 data_t *key_data,
1458 int exercise_alg )
1459{
Ronald Cron5425a212020-08-04 14:58:35 +02001460 mbedtls_svc_key_id_t key = MBEDTLS_SVC_KEY_ID_INIT;
Gilles Peskine2c2cf0e2019-04-19 19:58:20 +02001461 psa_key_attributes_t attributes = PSA_KEY_ATTRIBUTES_INIT;
Gilles Peskine51ae0e42019-05-16 17:31:03 +02001462 psa_key_derivation_operation_t operation = PSA_KEY_DERIVATION_OPERATION_INIT;
Gilles Peskineea0fb492018-07-12 17:17:20 +02001463 psa_status_t status;
1464
Gilles Peskine8817f612018-12-18 00:18:46 +01001465 PSA_ASSERT( psa_crypto_init( ) );
Gilles Peskineea0fb492018-07-12 17:17:20 +02001466
Gilles Peskine2c2cf0e2019-04-19 19:58:20 +02001467 psa_set_key_usage_flags( &attributes, policy_usage );
1468 psa_set_key_algorithm( &attributes, policy_alg );
1469 psa_set_key_type( &attributes, key_type );
Gilles Peskineea0fb492018-07-12 17:17:20 +02001470
Gilles Peskine049c7532019-05-15 20:22:09 +02001471 PSA_ASSERT( psa_import_key( &attributes, key_data->x, key_data->len,
Ronald Cron5425a212020-08-04 14:58:35 +02001472 &key ) );
Gilles Peskineea0fb492018-07-12 17:17:20 +02001473
Janos Follathba3fab92019-06-11 14:50:16 +01001474 PSA_ASSERT( psa_key_derivation_setup( &operation, exercise_alg ) );
1475
1476 if( PSA_ALG_IS_TLS12_PRF( exercise_alg ) ||
1477 PSA_ALG_IS_TLS12_PSK_TO_MS( exercise_alg ) )
Janos Follath0c1ed842019-06-28 13:35:36 +01001478 {
Janos Follathba3fab92019-06-11 14:50:16 +01001479 PSA_ASSERT( psa_key_derivation_input_bytes(
1480 &operation,
1481 PSA_KEY_DERIVATION_INPUT_SEED,
1482 (const uint8_t*) "", 0) );
Janos Follath0c1ed842019-06-28 13:35:36 +01001483 }
Janos Follathba3fab92019-06-11 14:50:16 +01001484
1485 status = psa_key_derivation_input_key( &operation,
1486 PSA_KEY_DERIVATION_INPUT_SECRET,
Ronald Cron5425a212020-08-04 14:58:35 +02001487 key );
Janos Follathba3fab92019-06-11 14:50:16 +01001488
Gilles Peskineea0fb492018-07-12 17:17:20 +02001489 if( policy_alg == exercise_alg &&
1490 ( policy_usage & PSA_KEY_USAGE_DERIVE ) != 0 )
Gilles Peskine8817f612018-12-18 00:18:46 +01001491 PSA_ASSERT( status );
Gilles Peskineea0fb492018-07-12 17:17:20 +02001492 else
Gilles Peskinefe11b722018-12-18 00:24:04 +01001493 TEST_EQUAL( status, PSA_ERROR_NOT_PERMITTED );
Gilles Peskineea0fb492018-07-12 17:17:20 +02001494
1495exit:
Gilles Peskine51ae0e42019-05-16 17:31:03 +02001496 psa_key_derivation_abort( &operation );
Ronald Cron5425a212020-08-04 14:58:35 +02001497 psa_destroy_key( key );
Gilles Peskine1153e7b2019-05-28 15:10:21 +02001498 PSA_DONE( );
Gilles Peskineea0fb492018-07-12 17:17:20 +02001499}
1500/* END_CASE */
1501
1502/* BEGIN_CASE */
Gilles Peskine01d718c2018-09-18 12:01:02 +02001503void agreement_key_policy( int policy_usage,
1504 int policy_alg,
1505 int key_type_arg,
1506 data_t *key_data,
Steven Cooremance48e852020-10-05 16:02:45 +02001507 int exercise_alg,
1508 int expected_status_arg )
Gilles Peskine01d718c2018-09-18 12:01:02 +02001509{
Ronald Cron5425a212020-08-04 14:58:35 +02001510 mbedtls_svc_key_id_t key = MBEDTLS_SVC_KEY_ID_INIT;
Gilles Peskine2c2cf0e2019-04-19 19:58:20 +02001511 psa_key_attributes_t attributes = PSA_KEY_ATTRIBUTES_INIT;
Gilles Peskine01d718c2018-09-18 12:01:02 +02001512 psa_key_type_t key_type = key_type_arg;
Gilles Peskine51ae0e42019-05-16 17:31:03 +02001513 psa_key_derivation_operation_t operation = PSA_KEY_DERIVATION_OPERATION_INIT;
Gilles Peskine01d718c2018-09-18 12:01:02 +02001514 psa_status_t status;
Steven Cooremance48e852020-10-05 16:02:45 +02001515 psa_status_t expected_status = expected_status_arg;
Gilles Peskine01d718c2018-09-18 12:01:02 +02001516
Gilles Peskine8817f612018-12-18 00:18:46 +01001517 PSA_ASSERT( psa_crypto_init( ) );
Gilles Peskine01d718c2018-09-18 12:01:02 +02001518
Gilles Peskine2c2cf0e2019-04-19 19:58:20 +02001519 psa_set_key_usage_flags( &attributes, policy_usage );
1520 psa_set_key_algorithm( &attributes, policy_alg );
1521 psa_set_key_type( &attributes, key_type );
Gilles Peskine01d718c2018-09-18 12:01:02 +02001522
Gilles Peskine049c7532019-05-15 20:22:09 +02001523 PSA_ASSERT( psa_import_key( &attributes, key_data->x, key_data->len,
Ronald Cron5425a212020-08-04 14:58:35 +02001524 &key ) );
Gilles Peskine01d718c2018-09-18 12:01:02 +02001525
Gilles Peskine51ae0e42019-05-16 17:31:03 +02001526 PSA_ASSERT( psa_key_derivation_setup( &operation, exercise_alg ) );
Gilles Peskinec18e25f2021-02-12 23:48:20 +01001527 status = mbedtls_test_psa_key_agreement_with_self( &operation, key );
Gilles Peskine01d718c2018-09-18 12:01:02 +02001528
Steven Cooremance48e852020-10-05 16:02:45 +02001529 TEST_EQUAL( status, expected_status );
Gilles Peskine01d718c2018-09-18 12:01:02 +02001530
1531exit:
Gilles Peskine51ae0e42019-05-16 17:31:03 +02001532 psa_key_derivation_abort( &operation );
Ronald Cron5425a212020-08-04 14:58:35 +02001533 psa_destroy_key( key );
Gilles Peskine1153e7b2019-05-28 15:10:21 +02001534 PSA_DONE( );
Gilles Peskine01d718c2018-09-18 12:01:02 +02001535}
1536/* END_CASE */
1537
1538/* BEGIN_CASE */
Gilles Peskine96f0b3b2019-05-10 19:33:38 +02001539void key_policy_alg2( int key_type_arg, data_t *key_data,
1540 int usage_arg, int alg_arg, int alg2_arg )
1541{
Ronald Cron5425a212020-08-04 14:58:35 +02001542 mbedtls_svc_key_id_t key = MBEDTLS_SVC_KEY_ID_INIT;
Gilles Peskine96f0b3b2019-05-10 19:33:38 +02001543 psa_key_type_t key_type = key_type_arg;
1544 psa_key_attributes_t attributes = PSA_KEY_ATTRIBUTES_INIT;
1545 psa_key_attributes_t got_attributes = PSA_KEY_ATTRIBUTES_INIT;
1546 psa_key_usage_t usage = usage_arg;
1547 psa_algorithm_t alg = alg_arg;
1548 psa_algorithm_t alg2 = alg2_arg;
1549
1550 PSA_ASSERT( psa_crypto_init( ) );
1551
1552 psa_set_key_usage_flags( &attributes, usage );
1553 psa_set_key_algorithm( &attributes, alg );
1554 psa_set_key_enrollment_algorithm( &attributes, alg2 );
1555 psa_set_key_type( &attributes, key_type );
1556 PSA_ASSERT( psa_import_key( &attributes, key_data->x, key_data->len,
Ronald Cron5425a212020-08-04 14:58:35 +02001557 &key ) );
Gilles Peskine96f0b3b2019-05-10 19:33:38 +02001558
gabor-mezei-arm98a34352021-06-28 14:05:00 +02001559 /* Update the usage flags to obtain implicit usage flags */
1560 usage = mbedtls_test_update_key_usage_flags( usage );
Ronald Cron5425a212020-08-04 14:58:35 +02001561 PSA_ASSERT( psa_get_key_attributes( key, &got_attributes ) );
Gilles Peskine96f0b3b2019-05-10 19:33:38 +02001562 TEST_EQUAL( psa_get_key_usage_flags( &got_attributes ), usage );
1563 TEST_EQUAL( psa_get_key_algorithm( &got_attributes ), alg );
1564 TEST_EQUAL( psa_get_key_enrollment_algorithm( &got_attributes ), alg2 );
1565
Gilles Peskinec18e25f2021-02-12 23:48:20 +01001566 if( ! mbedtls_test_psa_exercise_key( key, usage, alg ) )
Gilles Peskine96f0b3b2019-05-10 19:33:38 +02001567 goto exit;
Gilles Peskinec18e25f2021-02-12 23:48:20 +01001568 if( ! mbedtls_test_psa_exercise_key( key, usage, alg2 ) )
Gilles Peskine96f0b3b2019-05-10 19:33:38 +02001569 goto exit;
1570
1571exit:
Ronald Cron3a4f0e32020-11-19 17:55:23 +01001572 /*
1573 * Key attributes may have been returned by psa_get_key_attributes()
1574 * thus reset them as required.
1575 */
1576 psa_reset_key_attributes( &got_attributes );
1577
Ronald Cron5425a212020-08-04 14:58:35 +02001578 psa_destroy_key( key );
Gilles Peskine1153e7b2019-05-28 15:10:21 +02001579 PSA_DONE( );
Gilles Peskine96f0b3b2019-05-10 19:33:38 +02001580}
1581/* END_CASE */
1582
1583/* BEGIN_CASE */
Gilles Peskine04ee2d22019-04-11 21:25:46 +02001584void raw_agreement_key_policy( int policy_usage,
1585 int policy_alg,
1586 int key_type_arg,
1587 data_t *key_data,
Steven Cooremance48e852020-10-05 16:02:45 +02001588 int exercise_alg,
1589 int expected_status_arg )
Gilles Peskine04ee2d22019-04-11 21:25:46 +02001590{
Ronald Cron5425a212020-08-04 14:58:35 +02001591 mbedtls_svc_key_id_t key = MBEDTLS_SVC_KEY_ID_INIT;
Gilles Peskine2c2cf0e2019-04-19 19:58:20 +02001592 psa_key_attributes_t attributes = PSA_KEY_ATTRIBUTES_INIT;
Gilles Peskine04ee2d22019-04-11 21:25:46 +02001593 psa_key_type_t key_type = key_type_arg;
Gilles Peskine51ae0e42019-05-16 17:31:03 +02001594 psa_key_derivation_operation_t operation = PSA_KEY_DERIVATION_OPERATION_INIT;
Gilles Peskine04ee2d22019-04-11 21:25:46 +02001595 psa_status_t status;
Steven Cooremance48e852020-10-05 16:02:45 +02001596 psa_status_t expected_status = expected_status_arg;
Gilles Peskine04ee2d22019-04-11 21:25:46 +02001597
1598 PSA_ASSERT( psa_crypto_init( ) );
1599
Gilles Peskine2c2cf0e2019-04-19 19:58:20 +02001600 psa_set_key_usage_flags( &attributes, policy_usage );
1601 psa_set_key_algorithm( &attributes, policy_alg );
1602 psa_set_key_type( &attributes, key_type );
Gilles Peskine04ee2d22019-04-11 21:25:46 +02001603
Gilles Peskine049c7532019-05-15 20:22:09 +02001604 PSA_ASSERT( psa_import_key( &attributes, key_data->x, key_data->len,
Ronald Cron5425a212020-08-04 14:58:35 +02001605 &key ) );
Gilles Peskine04ee2d22019-04-11 21:25:46 +02001606
Gilles Peskinec18e25f2021-02-12 23:48:20 +01001607 status = mbedtls_test_psa_raw_key_agreement_with_self( exercise_alg, key );
Gilles Peskine04ee2d22019-04-11 21:25:46 +02001608
Steven Cooremance48e852020-10-05 16:02:45 +02001609 TEST_EQUAL( status, expected_status );
Gilles Peskine04ee2d22019-04-11 21:25:46 +02001610
1611exit:
Gilles Peskine51ae0e42019-05-16 17:31:03 +02001612 psa_key_derivation_abort( &operation );
Ronald Cron5425a212020-08-04 14:58:35 +02001613 psa_destroy_key( key );
Gilles Peskine1153e7b2019-05-28 15:10:21 +02001614 PSA_DONE( );
Gilles Peskine04ee2d22019-04-11 21:25:46 +02001615}
1616/* END_CASE */
1617
1618/* BEGIN_CASE */
Gilles Peskinebcdd44b2019-05-20 17:28:11 +02001619void copy_success( int source_usage_arg,
1620 int source_alg_arg, int source_alg2_arg,
Archana8a180362021-07-05 02:18:48 +05301621 unsigned int source_lifetime_arg,
Gilles Peskine4a644642019-05-03 17:14:08 +02001622 int type_arg, data_t *material,
1623 int copy_attributes,
Gilles Peskinebcdd44b2019-05-20 17:28:11 +02001624 int target_usage_arg,
1625 int target_alg_arg, int target_alg2_arg,
Archana8a180362021-07-05 02:18:48 +05301626 unsigned int target_lifetime_arg,
Gilles Peskinebcdd44b2019-05-20 17:28:11 +02001627 int expected_usage_arg,
1628 int expected_alg_arg, int expected_alg2_arg )
Gilles Peskine57ab7212019-01-28 13:03:09 +01001629{
Gilles Peskineca25db92019-04-19 11:43:08 +02001630 psa_key_attributes_t source_attributes = PSA_KEY_ATTRIBUTES_INIT;
1631 psa_key_attributes_t target_attributes = PSA_KEY_ATTRIBUTES_INIT;
Gilles Peskine57ab7212019-01-28 13:03:09 +01001632 psa_key_usage_t expected_usage = expected_usage_arg;
1633 psa_algorithm_t expected_alg = expected_alg_arg;
Gilles Peskinebcdd44b2019-05-20 17:28:11 +02001634 psa_algorithm_t expected_alg2 = expected_alg2_arg;
Archana8a180362021-07-05 02:18:48 +05301635 psa_key_lifetime_t source_lifetime = source_lifetime_arg;
1636 psa_key_lifetime_t target_lifetime = target_lifetime_arg;
Ronald Cron5425a212020-08-04 14:58:35 +02001637 mbedtls_svc_key_id_t source_key = MBEDTLS_SVC_KEY_ID_INIT;
1638 mbedtls_svc_key_id_t target_key = MBEDTLS_SVC_KEY_ID_INIT;
Gilles Peskine57ab7212019-01-28 13:03:09 +01001639 uint8_t *export_buffer = NULL;
1640
Gilles Peskine57ab7212019-01-28 13:03:09 +01001641 PSA_ASSERT( psa_crypto_init( ) );
1642
Gilles Peskineca25db92019-04-19 11:43:08 +02001643 /* Prepare the source key. */
1644 psa_set_key_usage_flags( &source_attributes, source_usage_arg );
1645 psa_set_key_algorithm( &source_attributes, source_alg_arg );
Gilles Peskinebcdd44b2019-05-20 17:28:11 +02001646 psa_set_key_enrollment_algorithm( &source_attributes, source_alg2_arg );
Gilles Peskineca25db92019-04-19 11:43:08 +02001647 psa_set_key_type( &source_attributes, type_arg );
Archana8a180362021-07-05 02:18:48 +05301648 psa_set_key_lifetime( &source_attributes, source_lifetime);
Gilles Peskine049c7532019-05-15 20:22:09 +02001649 PSA_ASSERT( psa_import_key( &source_attributes,
1650 material->x, material->len,
Ronald Cron5425a212020-08-04 14:58:35 +02001651 &source_key ) );
1652 PSA_ASSERT( psa_get_key_attributes( source_key, &source_attributes ) );
Gilles Peskine57ab7212019-01-28 13:03:09 +01001653
Gilles Peskineca25db92019-04-19 11:43:08 +02001654 /* Prepare the target attributes. */
1655 if( copy_attributes )
Ronald Cron65f38a32020-10-23 17:11:13 +02001656 {
Gilles Peskineca25db92019-04-19 11:43:08 +02001657 target_attributes = source_attributes;
Ronald Cron65f38a32020-10-23 17:11:13 +02001658 }
Archana8a180362021-07-05 02:18:48 +05301659 psa_set_key_lifetime( &target_attributes, target_lifetime);
Ronald Cron65f38a32020-10-23 17:11:13 +02001660
Gilles Peskineca25db92019-04-19 11:43:08 +02001661 if( target_usage_arg != -1 )
1662 psa_set_key_usage_flags( &target_attributes, target_usage_arg );
1663 if( target_alg_arg != -1 )
1664 psa_set_key_algorithm( &target_attributes, target_alg_arg );
Gilles Peskinebcdd44b2019-05-20 17:28:11 +02001665 if( target_alg2_arg != -1 )
1666 psa_set_key_enrollment_algorithm( &target_attributes, target_alg2_arg );
Gilles Peskine57ab7212019-01-28 13:03:09 +01001667
Archana8a180362021-07-05 02:18:48 +05301668
Gilles Peskine57ab7212019-01-28 13:03:09 +01001669 /* Copy the key. */
Ronald Cron5425a212020-08-04 14:58:35 +02001670 PSA_ASSERT( psa_copy_key( source_key,
1671 &target_attributes, &target_key ) );
Gilles Peskine57ab7212019-01-28 13:03:09 +01001672
1673 /* Destroy the source to ensure that this doesn't affect the target. */
Ronald Cron5425a212020-08-04 14:58:35 +02001674 PSA_ASSERT( psa_destroy_key( source_key ) );
Gilles Peskine57ab7212019-01-28 13:03:09 +01001675
1676 /* Test that the target slot has the expected content and policy. */
Ronald Cron5425a212020-08-04 14:58:35 +02001677 PSA_ASSERT( psa_get_key_attributes( target_key, &target_attributes ) );
Gilles Peskineca25db92019-04-19 11:43:08 +02001678 TEST_EQUAL( psa_get_key_type( &source_attributes ),
1679 psa_get_key_type( &target_attributes ) );
1680 TEST_EQUAL( psa_get_key_bits( &source_attributes ),
1681 psa_get_key_bits( &target_attributes ) );
1682 TEST_EQUAL( expected_usage, psa_get_key_usage_flags( &target_attributes ) );
1683 TEST_EQUAL( expected_alg, psa_get_key_algorithm( &target_attributes ) );
Gilles Peskinebcdd44b2019-05-20 17:28:11 +02001684 TEST_EQUAL( expected_alg2,
1685 psa_get_key_enrollment_algorithm( &target_attributes ) );
Gilles Peskine57ab7212019-01-28 13:03:09 +01001686 if( expected_usage & PSA_KEY_USAGE_EXPORT )
1687 {
1688 size_t length;
1689 ASSERT_ALLOC( export_buffer, material->len );
Ronald Cron5425a212020-08-04 14:58:35 +02001690 PSA_ASSERT( psa_export_key( target_key, export_buffer,
Gilles Peskine57ab7212019-01-28 13:03:09 +01001691 material->len, &length ) );
1692 ASSERT_COMPARE( material->x, material->len,
1693 export_buffer, length );
1694 }
Steven Cooremanb3ce8152021-02-18 12:03:50 +01001695
Archana8a180362021-07-05 02:18:48 +05301696 if( !psa_key_lifetime_is_external( target_lifetime ) )
1697 {
1698 if( ! mbedtls_test_psa_exercise_key( target_key, expected_usage, expected_alg ) )
1699 goto exit;
1700 if( ! mbedtls_test_psa_exercise_key( target_key, expected_usage, expected_alg2 ) )
1701 goto exit;
1702 }
Gilles Peskine57ab7212019-01-28 13:03:09 +01001703
Ronald Cron5425a212020-08-04 14:58:35 +02001704 PSA_ASSERT( psa_destroy_key( target_key ) );
Gilles Peskine57ab7212019-01-28 13:03:09 +01001705
1706exit:
Ronald Cron3a4f0e32020-11-19 17:55:23 +01001707 /*
1708 * Source and target key attributes may have been returned by
1709 * psa_get_key_attributes() thus reset them as required.
1710 */
Gilles Peskinea1ace9c2019-04-26 16:03:33 +02001711 psa_reset_key_attributes( &source_attributes );
1712 psa_reset_key_attributes( &target_attributes );
Ronald Cron3a4f0e32020-11-19 17:55:23 +01001713
Gilles Peskine1153e7b2019-05-28 15:10:21 +02001714 PSA_DONE( );
Gilles Peskine57ab7212019-01-28 13:03:09 +01001715 mbedtls_free( export_buffer );
1716}
1717/* END_CASE */
1718
1719/* BEGIN_CASE */
Gilles Peskinebcdd44b2019-05-20 17:28:11 +02001720void copy_fail( int source_usage_arg,
1721 int source_alg_arg, int source_alg2_arg,
Archana8a180362021-07-05 02:18:48 +05301722 int source_lifetime_arg,
Gilles Peskine4a644642019-05-03 17:14:08 +02001723 int type_arg, data_t *material,
1724 int target_type_arg, int target_bits_arg,
Gilles Peskinebcdd44b2019-05-20 17:28:11 +02001725 int target_usage_arg,
1726 int target_alg_arg, int target_alg2_arg,
Ronald Cron88a55462021-03-31 09:39:07 +02001727 int target_id_arg, int target_lifetime_arg,
Gilles Peskine4a644642019-05-03 17:14:08 +02001728 int expected_status_arg )
1729{
1730 psa_key_attributes_t source_attributes = PSA_KEY_ATTRIBUTES_INIT;
1731 psa_key_attributes_t target_attributes = PSA_KEY_ATTRIBUTES_INIT;
Ronald Cron5425a212020-08-04 14:58:35 +02001732 mbedtls_svc_key_id_t source_key = MBEDTLS_SVC_KEY_ID_INIT;
1733 mbedtls_svc_key_id_t target_key = MBEDTLS_SVC_KEY_ID_INIT;
Ronald Cron88a55462021-03-31 09:39:07 +02001734 mbedtls_svc_key_id_t key_id = mbedtls_svc_key_id_make( 1, target_id_arg );
Gilles Peskine4a644642019-05-03 17:14:08 +02001735
1736 PSA_ASSERT( psa_crypto_init( ) );
1737
1738 /* Prepare the source key. */
1739 psa_set_key_usage_flags( &source_attributes, source_usage_arg );
1740 psa_set_key_algorithm( &source_attributes, source_alg_arg );
Gilles Peskinebcdd44b2019-05-20 17:28:11 +02001741 psa_set_key_enrollment_algorithm( &source_attributes, source_alg2_arg );
Gilles Peskine4a644642019-05-03 17:14:08 +02001742 psa_set_key_type( &source_attributes, type_arg );
Archana8a180362021-07-05 02:18:48 +05301743 psa_set_key_lifetime( &source_attributes, source_lifetime_arg );
Gilles Peskine049c7532019-05-15 20:22:09 +02001744 PSA_ASSERT( psa_import_key( &source_attributes,
1745 material->x, material->len,
Ronald Cron5425a212020-08-04 14:58:35 +02001746 &source_key ) );
Gilles Peskine4a644642019-05-03 17:14:08 +02001747
1748 /* Prepare the target attributes. */
Ronald Cron88a55462021-03-31 09:39:07 +02001749 psa_set_key_id( &target_attributes, key_id );
1750 psa_set_key_lifetime( &target_attributes, target_lifetime_arg );
Gilles Peskine4a644642019-05-03 17:14:08 +02001751 psa_set_key_type( &target_attributes, target_type_arg );
1752 psa_set_key_bits( &target_attributes, target_bits_arg );
1753 psa_set_key_usage_flags( &target_attributes, target_usage_arg );
1754 psa_set_key_algorithm( &target_attributes, target_alg_arg );
Gilles Peskinebcdd44b2019-05-20 17:28:11 +02001755 psa_set_key_enrollment_algorithm( &target_attributes, target_alg2_arg );
Gilles Peskine4a644642019-05-03 17:14:08 +02001756
1757 /* Try to copy the key. */
Ronald Cron5425a212020-08-04 14:58:35 +02001758 TEST_EQUAL( psa_copy_key( source_key,
1759 &target_attributes, &target_key ),
Gilles Peskine4a644642019-05-03 17:14:08 +02001760 expected_status_arg );
Gilles Peskine76b29a72019-05-28 14:08:50 +02001761
Ronald Cron5425a212020-08-04 14:58:35 +02001762 PSA_ASSERT( psa_destroy_key( source_key ) );
Gilles Peskine76b29a72019-05-28 14:08:50 +02001763
Gilles Peskine4a644642019-05-03 17:14:08 +02001764exit:
1765 psa_reset_key_attributes( &source_attributes );
1766 psa_reset_key_attributes( &target_attributes );
Gilles Peskine1153e7b2019-05-28 15:10:21 +02001767 PSA_DONE( );
Gilles Peskine4a644642019-05-03 17:14:08 +02001768}
1769/* END_CASE */
1770
1771/* BEGIN_CASE */
Jaeden Amero6a25b412019-01-04 11:47:44 +00001772void hash_operation_init( )
1773{
Jaeden Ameroa0f625a2019-02-15 13:52:25 +00001774 const uint8_t input[1] = { 0 };
Jaeden Amero6a25b412019-01-04 11:47:44 +00001775 /* Test each valid way of initializing the object, except for `= {0}`, as
1776 * Clang 5 complains when `-Wmissing-field-initializers` is used, even
1777 * though it's OK by the C standard. We could test for this, but we'd need
1778 * to supress the Clang warning for the test. */
1779 psa_hash_operation_t func = psa_hash_operation_init( );
1780 psa_hash_operation_t init = PSA_HASH_OPERATION_INIT;
1781 psa_hash_operation_t zero;
1782
1783 memset( &zero, 0, sizeof( zero ) );
1784
Jaeden Amero11aa7ee2019-02-19 11:44:55 +00001785 /* A freshly-initialized hash operation should not be usable. */
Jaeden Ameroa0f625a2019-02-15 13:52:25 +00001786 TEST_EQUAL( psa_hash_update( &func, input, sizeof( input ) ),
1787 PSA_ERROR_BAD_STATE );
1788 TEST_EQUAL( psa_hash_update( &init, input, sizeof( input ) ),
1789 PSA_ERROR_BAD_STATE );
1790 TEST_EQUAL( psa_hash_update( &zero, input, sizeof( input ) ),
1791 PSA_ERROR_BAD_STATE );
1792
Jaeden Amero5229bbb2019-02-07 16:33:37 +00001793 /* A default hash operation should be abortable without error. */
1794 PSA_ASSERT( psa_hash_abort( &func ) );
1795 PSA_ASSERT( psa_hash_abort( &init ) );
1796 PSA_ASSERT( psa_hash_abort( &zero ) );
Jaeden Amero6a25b412019-01-04 11:47:44 +00001797}
1798/* END_CASE */
1799
1800/* BEGIN_CASE */
Gilles Peskine16c0f4f2018-06-20 16:05:20 +02001801void hash_setup( int alg_arg,
1802 int expected_status_arg )
1803{
1804 psa_algorithm_t alg = alg_arg;
Gilles Peskineb866e2b2018-06-21 09:25:10 +02001805 psa_status_t expected_status = expected_status_arg;
Jaeden Amero6a25b412019-01-04 11:47:44 +00001806 psa_hash_operation_t operation = PSA_HASH_OPERATION_INIT;
Gilles Peskine16c0f4f2018-06-20 16:05:20 +02001807 psa_status_t status;
1808
Gilles Peskine8817f612018-12-18 00:18:46 +01001809 PSA_ASSERT( psa_crypto_init( ) );
Gilles Peskine16c0f4f2018-06-20 16:05:20 +02001810
Gilles Peskineda8191d1c2018-07-08 19:46:38 +02001811 status = psa_hash_setup( &operation, alg );
Gilles Peskinefe11b722018-12-18 00:24:04 +01001812 TEST_EQUAL( status, expected_status );
Gilles Peskine16c0f4f2018-06-20 16:05:20 +02001813
Gilles Peskine9e0a4a52019-02-25 22:11:18 +01001814 /* Whether setup succeeded or failed, abort must succeed. */
1815 PSA_ASSERT( psa_hash_abort( &operation ) );
1816
1817 /* If setup failed, reproduce the failure, so as to
1818 * test the resulting state of the operation object. */
1819 if( status != PSA_SUCCESS )
1820 TEST_EQUAL( psa_hash_setup( &operation, alg ), status );
1821
Gilles Peskinef426e0f2019-02-25 17:42:03 +01001822 /* Now the operation object should be reusable. */
1823#if defined(KNOWN_SUPPORTED_HASH_ALG)
1824 PSA_ASSERT( psa_hash_setup( &operation, KNOWN_SUPPORTED_HASH_ALG ) );
1825 PSA_ASSERT( psa_hash_abort( &operation ) );
1826#endif
1827
Gilles Peskine16c0f4f2018-06-20 16:05:20 +02001828exit:
Gilles Peskine1153e7b2019-05-28 15:10:21 +02001829 PSA_DONE( );
Gilles Peskine16c0f4f2018-06-20 16:05:20 +02001830}
1831/* END_CASE */
1832
1833/* BEGIN_CASE */
Gilles Peskine0a749c82019-11-28 19:33:58 +01001834void hash_compute_fail( int alg_arg, data_t *input,
1835 int output_size_arg, int expected_status_arg )
1836{
1837 psa_algorithm_t alg = alg_arg;
1838 uint8_t *output = NULL;
1839 size_t output_size = output_size_arg;
1840 size_t output_length = INVALID_EXPORT_LENGTH;
1841 psa_status_t expected_status = expected_status_arg;
1842 psa_status_t status;
1843
1844 ASSERT_ALLOC( output, output_size );
1845
1846 PSA_ASSERT( psa_crypto_init( ) );
1847
1848 status = psa_hash_compute( alg, input->x, input->len,
1849 output, output_size, &output_length );
1850 TEST_EQUAL( status, expected_status );
1851 TEST_ASSERT( output_length <= output_size );
1852
1853exit:
1854 mbedtls_free( output );
1855 PSA_DONE( );
1856}
1857/* END_CASE */
1858
1859/* BEGIN_CASE */
Gilles Peskine88e08462020-01-28 20:43:00 +01001860void hash_compare_fail( int alg_arg, data_t *input,
1861 data_t *reference_hash,
1862 int expected_status_arg )
1863{
1864 psa_algorithm_t alg = alg_arg;
1865 psa_status_t expected_status = expected_status_arg;
1866 psa_status_t status;
1867
1868 PSA_ASSERT( psa_crypto_init( ) );
1869
1870 status = psa_hash_compare( alg, input->x, input->len,
1871 reference_hash->x, reference_hash->len );
1872 TEST_EQUAL( status, expected_status );
1873
1874exit:
1875 PSA_DONE( );
1876}
1877/* END_CASE */
1878
1879/* BEGIN_CASE */
Gilles Peskine0a749c82019-11-28 19:33:58 +01001880void hash_compute_compare( int alg_arg, data_t *input,
1881 data_t *expected_output )
1882{
1883 psa_algorithm_t alg = alg_arg;
1884 uint8_t output[PSA_HASH_MAX_SIZE + 1];
1885 size_t output_length = INVALID_EXPORT_LENGTH;
1886 size_t i;
1887
1888 PSA_ASSERT( psa_crypto_init( ) );
1889
1890 /* Compute with tight buffer */
1891 PSA_ASSERT( psa_hash_compute( alg, input->x, input->len,
gabor-mezei-armcbcec212020-12-18 14:23:51 +01001892 output, PSA_HASH_LENGTH( alg ),
Gilles Peskine0a749c82019-11-28 19:33:58 +01001893 &output_length ) );
gabor-mezei-armcbcec212020-12-18 14:23:51 +01001894 TEST_EQUAL( output_length, PSA_HASH_LENGTH( alg ) );
Gilles Peskine0a749c82019-11-28 19:33:58 +01001895 ASSERT_COMPARE( output, output_length,
1896 expected_output->x, expected_output->len );
1897
1898 /* Compute with larger buffer */
1899 PSA_ASSERT( psa_hash_compute( alg, input->x, input->len,
1900 output, sizeof( output ),
1901 &output_length ) );
gabor-mezei-armcbcec212020-12-18 14:23:51 +01001902 TEST_EQUAL( output_length, PSA_HASH_LENGTH( alg ) );
Gilles Peskine0a749c82019-11-28 19:33:58 +01001903 ASSERT_COMPARE( output, output_length,
1904 expected_output->x, expected_output->len );
1905
1906 /* Compare with correct hash */
1907 PSA_ASSERT( psa_hash_compare( alg, input->x, input->len,
1908 output, output_length ) );
1909
1910 /* Compare with trailing garbage */
1911 TEST_EQUAL( psa_hash_compare( alg, input->x, input->len,
1912 output, output_length + 1 ),
1913 PSA_ERROR_INVALID_SIGNATURE );
1914
1915 /* Compare with truncated hash */
1916 TEST_EQUAL( psa_hash_compare( alg, input->x, input->len,
1917 output, output_length - 1 ),
1918 PSA_ERROR_INVALID_SIGNATURE );
1919
1920 /* Compare with corrupted value */
1921 for( i = 0; i < output_length; i++ )
1922 {
Chris Jones9634bb12021-01-20 15:56:42 +00001923 mbedtls_test_set_step( i );
Gilles Peskine0a749c82019-11-28 19:33:58 +01001924 output[i] ^= 1;
1925 TEST_EQUAL( psa_hash_compare( alg, input->x, input->len,
1926 output, output_length ),
1927 PSA_ERROR_INVALID_SIGNATURE );
1928 output[i] ^= 1;
1929 }
1930
1931exit:
1932 PSA_DONE( );
1933}
1934/* END_CASE */
1935
Gilles Peskined6dc40c2021-01-12 12:55:31 +01001936/* BEGIN_CASE depends_on:PSA_WANT_ALG_SHA_256 */
itayzafrirf86548d2018-11-01 10:44:32 +02001937void hash_bad_order( )
1938{
Jaeden Amero11aa7ee2019-02-19 11:44:55 +00001939 psa_algorithm_t alg = PSA_ALG_SHA_256;
itayzafrirf86548d2018-11-01 10:44:32 +02001940 unsigned char input[] = "";
1941 /* SHA-256 hash of an empty string */
Jaeden Amero11aa7ee2019-02-19 11:44:55 +00001942 const unsigned char valid_hash[] = {
itayzafrirf86548d2018-11-01 10:44:32 +02001943 0xe3, 0xb0, 0xc4, 0x42, 0x98, 0xfc, 0x1c, 0x14, 0x9a, 0xfb, 0xf4, 0xc8,
1944 0x99, 0x6f, 0xb9, 0x24, 0x27, 0xae, 0x41, 0xe4, 0x64, 0x9b, 0x93, 0x4c,
1945 0xa4, 0x95, 0x99, 0x1b, 0x78, 0x52, 0xb8, 0x55 };
Jaeden Amero11aa7ee2019-02-19 11:44:55 +00001946 unsigned char hash[sizeof(valid_hash)] = { 0 };
itayzafrirf86548d2018-11-01 10:44:32 +02001947 size_t hash_len;
Jaeden Amero6a25b412019-01-04 11:47:44 +00001948 psa_hash_operation_t operation = PSA_HASH_OPERATION_INIT;
itayzafrirf86548d2018-11-01 10:44:32 +02001949
Gilles Peskine8817f612018-12-18 00:18:46 +01001950 PSA_ASSERT( psa_crypto_init( ) );
itayzafrirf86548d2018-11-01 10:44:32 +02001951
Jaeden Amero36ee5d02019-02-19 09:25:10 +00001952 /* Call setup twice in a row. */
1953 PSA_ASSERT( psa_hash_setup( &operation, alg ) );
Dave Rodgman5ae6f752021-06-24 11:36:14 +01001954 ASSERT_OPERATION_IS_ACTIVE( operation );
Jaeden Amero36ee5d02019-02-19 09:25:10 +00001955 TEST_EQUAL( psa_hash_setup( &operation, alg ),
1956 PSA_ERROR_BAD_STATE );
Dave Rodgman5ae6f752021-06-24 11:36:14 +01001957 ASSERT_OPERATION_IS_INACTIVE( operation );
Jaeden Amero36ee5d02019-02-19 09:25:10 +00001958 PSA_ASSERT( psa_hash_abort( &operation ) );
Dave Rodgman5ae6f752021-06-24 11:36:14 +01001959 ASSERT_OPERATION_IS_INACTIVE( operation );
Jaeden Amero36ee5d02019-02-19 09:25:10 +00001960
Jaeden Amero11aa7ee2019-02-19 11:44:55 +00001961 /* Call update without calling setup beforehand. */
Gilles Peskinef812dcf2018-12-18 00:33:25 +01001962 TEST_EQUAL( psa_hash_update( &operation, input, sizeof( input ) ),
Jaeden Ameroa0f625a2019-02-15 13:52:25 +00001963 PSA_ERROR_BAD_STATE );
Jaeden Amero11aa7ee2019-02-19 11:44:55 +00001964 PSA_ASSERT( psa_hash_abort( &operation ) );
itayzafrirf86548d2018-11-01 10:44:32 +02001965
Dave Rodgman5ae6f752021-06-24 11:36:14 +01001966 /* Check that update calls abort on error. */
1967 PSA_ASSERT( psa_hash_setup( &operation, alg ) );
Dave Rodgman6f710582021-06-24 18:14:52 +01001968 operation.id = UINT_MAX;
Dave Rodgman5ae6f752021-06-24 11:36:14 +01001969 ASSERT_OPERATION_IS_ACTIVE( operation );
1970 TEST_EQUAL( psa_hash_update( &operation, input, sizeof( input ) ),
1971 PSA_ERROR_BAD_STATE );
1972 ASSERT_OPERATION_IS_INACTIVE( operation );
1973 PSA_ASSERT( psa_hash_abort( &operation ) );
1974 ASSERT_OPERATION_IS_INACTIVE( operation );
1975
Jaeden Amero11aa7ee2019-02-19 11:44:55 +00001976 /* Call update after finish. */
1977 PSA_ASSERT( psa_hash_setup( &operation, alg ) );
1978 PSA_ASSERT( psa_hash_finish( &operation,
1979 hash, sizeof( hash ), &hash_len ) );
1980 TEST_EQUAL( psa_hash_update( &operation, input, sizeof( input ) ),
Jaeden Ameroa0f625a2019-02-15 13:52:25 +00001981 PSA_ERROR_BAD_STATE );
Jaeden Amero11aa7ee2019-02-19 11:44:55 +00001982 PSA_ASSERT( psa_hash_abort( &operation ) );
itayzafrirf86548d2018-11-01 10:44:32 +02001983
Jaeden Amero11aa7ee2019-02-19 11:44:55 +00001984 /* Call verify without calling setup beforehand. */
1985 TEST_EQUAL( psa_hash_verify( &operation,
1986 valid_hash, sizeof( valid_hash ) ),
1987 PSA_ERROR_BAD_STATE );
1988 PSA_ASSERT( psa_hash_abort( &operation ) );
1989
1990 /* Call verify after finish. */
1991 PSA_ASSERT( psa_hash_setup( &operation, alg ) );
1992 PSA_ASSERT( psa_hash_finish( &operation,
1993 hash, sizeof( hash ), &hash_len ) );
1994 TEST_EQUAL( psa_hash_verify( &operation,
1995 valid_hash, sizeof( valid_hash ) ),
1996 PSA_ERROR_BAD_STATE );
1997 PSA_ASSERT( psa_hash_abort( &operation ) );
1998
1999 /* Call verify twice in a row. */
2000 PSA_ASSERT( psa_hash_setup( &operation, alg ) );
Dave Rodgman5ae6f752021-06-24 11:36:14 +01002001 ASSERT_OPERATION_IS_ACTIVE( operation );
Jaeden Amero11aa7ee2019-02-19 11:44:55 +00002002 PSA_ASSERT( psa_hash_verify( &operation,
2003 valid_hash, sizeof( valid_hash ) ) );
Dave Rodgman5ae6f752021-06-24 11:36:14 +01002004 ASSERT_OPERATION_IS_INACTIVE( operation );
Jaeden Amero11aa7ee2019-02-19 11:44:55 +00002005 TEST_EQUAL( psa_hash_verify( &operation,
2006 valid_hash, sizeof( valid_hash ) ),
2007 PSA_ERROR_BAD_STATE );
Dave Rodgman5ae6f752021-06-24 11:36:14 +01002008 ASSERT_OPERATION_IS_INACTIVE( operation );
Jaeden Amero11aa7ee2019-02-19 11:44:55 +00002009 PSA_ASSERT( psa_hash_abort( &operation ) );
2010
2011 /* Call finish without calling setup beforehand. */
Gilles Peskinefe11b722018-12-18 00:24:04 +01002012 TEST_EQUAL( psa_hash_finish( &operation,
2013 hash, sizeof( hash ), &hash_len ),
Jaeden Ameroa0f625a2019-02-15 13:52:25 +00002014 PSA_ERROR_BAD_STATE );
Jaeden Amero11aa7ee2019-02-19 11:44:55 +00002015 PSA_ASSERT( psa_hash_abort( &operation ) );
2016
2017 /* Call finish twice in a row. */
2018 PSA_ASSERT( psa_hash_setup( &operation, alg ) );
2019 PSA_ASSERT( psa_hash_finish( &operation,
2020 hash, sizeof( hash ), &hash_len ) );
2021 TEST_EQUAL( psa_hash_finish( &operation,
2022 hash, sizeof( hash ), &hash_len ),
2023 PSA_ERROR_BAD_STATE );
2024 PSA_ASSERT( psa_hash_abort( &operation ) );
2025
2026 /* Call finish after calling verify. */
2027 PSA_ASSERT( psa_hash_setup( &operation, alg ) );
2028 PSA_ASSERT( psa_hash_verify( &operation,
2029 valid_hash, sizeof( valid_hash ) ) );
2030 TEST_EQUAL( psa_hash_finish( &operation,
2031 hash, sizeof( hash ), &hash_len ),
2032 PSA_ERROR_BAD_STATE );
2033 PSA_ASSERT( psa_hash_abort( &operation ) );
itayzafrirf86548d2018-11-01 10:44:32 +02002034
2035exit:
Gilles Peskine1153e7b2019-05-28 15:10:21 +02002036 PSA_DONE( );
itayzafrirf86548d2018-11-01 10:44:32 +02002037}
2038/* END_CASE */
2039
Gilles Peskined6dc40c2021-01-12 12:55:31 +01002040/* BEGIN_CASE depends_on:PSA_WANT_ALG_SHA_256 */
itayzafrir27e69452018-11-01 14:26:34 +02002041void hash_verify_bad_args( )
itayzafrirec93d302018-10-18 18:01:10 +03002042{
2043 psa_algorithm_t alg = PSA_ALG_SHA_256;
itayzafrir27e69452018-11-01 14:26:34 +02002044 /* SHA-256 hash of an empty string with 2 extra bytes (0xaa and 0xbb)
2045 * appended to it */
2046 unsigned char hash[] = {
2047 0xe3, 0xb0, 0xc4, 0x42, 0x98, 0xfc, 0x1c, 0x14, 0x9a, 0xfb, 0xf4, 0xc8,
2048 0x99, 0x6f, 0xb9, 0x24, 0x27, 0xae, 0x41, 0xe4, 0x64, 0x9b, 0x93, 0x4c,
2049 0xa4, 0x95, 0x99, 0x1b, 0x78, 0x52, 0xb8, 0x55, 0xaa, 0xbb };
gabor-mezei-armcbcec212020-12-18 14:23:51 +01002050 size_t expected_size = PSA_HASH_LENGTH( alg );
Jaeden Amero6a25b412019-01-04 11:47:44 +00002051 psa_hash_operation_t operation = PSA_HASH_OPERATION_INIT;
itayzafrirec93d302018-10-18 18:01:10 +03002052
Gilles Peskine8817f612018-12-18 00:18:46 +01002053 PSA_ASSERT( psa_crypto_init( ) );
itayzafrirec93d302018-10-18 18:01:10 +03002054
itayzafrir27e69452018-11-01 14:26:34 +02002055 /* psa_hash_verify with a smaller hash than expected */
Gilles Peskine8817f612018-12-18 00:18:46 +01002056 PSA_ASSERT( psa_hash_setup( &operation, alg ) );
Dave Rodgman5ae6f752021-06-24 11:36:14 +01002057 ASSERT_OPERATION_IS_ACTIVE( operation );
Gilles Peskinef812dcf2018-12-18 00:33:25 +01002058 TEST_EQUAL( psa_hash_verify( &operation, hash, expected_size - 1 ),
Gilles Peskinefe11b722018-12-18 00:24:04 +01002059 PSA_ERROR_INVALID_SIGNATURE );
Dave Rodgman5ae6f752021-06-24 11:36:14 +01002060 ASSERT_OPERATION_IS_INACTIVE( operation );
2061 PSA_ASSERT( psa_hash_abort( &operation ) );
2062 ASSERT_OPERATION_IS_INACTIVE( operation );
itayzafrirec93d302018-10-18 18:01:10 +03002063
itayzafrir27e69452018-11-01 14:26:34 +02002064 /* psa_hash_verify with a non-matching hash */
Gilles Peskine8817f612018-12-18 00:18:46 +01002065 PSA_ASSERT( psa_hash_setup( &operation, alg ) );
Gilles Peskinef812dcf2018-12-18 00:33:25 +01002066 TEST_EQUAL( psa_hash_verify( &operation, hash + 1, expected_size ),
Gilles Peskinefe11b722018-12-18 00:24:04 +01002067 PSA_ERROR_INVALID_SIGNATURE );
itayzafrirec93d302018-10-18 18:01:10 +03002068
itayzafrir27e69452018-11-01 14:26:34 +02002069 /* psa_hash_verify with a hash longer than expected */
Gilles Peskine8817f612018-12-18 00:18:46 +01002070 PSA_ASSERT( psa_hash_setup( &operation, alg ) );
Gilles Peskinef812dcf2018-12-18 00:33:25 +01002071 TEST_EQUAL( psa_hash_verify( &operation, hash, sizeof( hash ) ),
Gilles Peskinefe11b722018-12-18 00:24:04 +01002072 PSA_ERROR_INVALID_SIGNATURE );
itayzafrir4271df92018-10-24 18:16:19 +03002073
itayzafrirec93d302018-10-18 18:01:10 +03002074exit:
Gilles Peskine1153e7b2019-05-28 15:10:21 +02002075 PSA_DONE( );
itayzafrirec93d302018-10-18 18:01:10 +03002076}
2077/* END_CASE */
2078
Ronald Cronee414c72021-03-18 18:50:08 +01002079/* BEGIN_CASE depends_on:PSA_WANT_ALG_SHA_256 */
itayzafrirb2dd5ed2018-11-01 11:58:59 +02002080void hash_finish_bad_args( )
itayzafrir58028322018-10-25 10:22:01 +03002081{
2082 psa_algorithm_t alg = PSA_ALG_SHA_256;
itayzafrirb2dd5ed2018-11-01 11:58:59 +02002083 unsigned char hash[PSA_HASH_MAX_SIZE];
gabor-mezei-armcbcec212020-12-18 14:23:51 +01002084 size_t expected_size = PSA_HASH_LENGTH( alg );
Jaeden Amero6a25b412019-01-04 11:47:44 +00002085 psa_hash_operation_t operation = PSA_HASH_OPERATION_INIT;
itayzafrir58028322018-10-25 10:22:01 +03002086 size_t hash_len;
2087
Gilles Peskine8817f612018-12-18 00:18:46 +01002088 PSA_ASSERT( psa_crypto_init( ) );
itayzafrir58028322018-10-25 10:22:01 +03002089
itayzafrir58028322018-10-25 10:22:01 +03002090 /* psa_hash_finish with a smaller hash buffer than expected */
Gilles Peskine8817f612018-12-18 00:18:46 +01002091 PSA_ASSERT( psa_hash_setup( &operation, alg ) );
Gilles Peskinefe11b722018-12-18 00:24:04 +01002092 TEST_EQUAL( psa_hash_finish( &operation,
Gilles Peskinef812dcf2018-12-18 00:33:25 +01002093 hash, expected_size - 1, &hash_len ),
2094 PSA_ERROR_BUFFER_TOO_SMALL );
itayzafrir58028322018-10-25 10:22:01 +03002095
2096exit:
Gilles Peskine1153e7b2019-05-28 15:10:21 +02002097 PSA_DONE( );
itayzafrir58028322018-10-25 10:22:01 +03002098}
2099/* END_CASE */
2100
Ronald Cronee414c72021-03-18 18:50:08 +01002101/* BEGIN_CASE depends_on:PSA_WANT_ALG_SHA_256 */
Gilles Peskineebb2c3e2019-01-19 12:03:41 +01002102void hash_clone_source_state( )
2103{
2104 psa_algorithm_t alg = PSA_ALG_SHA_256;
2105 unsigned char hash[PSA_HASH_MAX_SIZE];
2106 psa_hash_operation_t op_source = PSA_HASH_OPERATION_INIT;
2107 psa_hash_operation_t op_init = PSA_HASH_OPERATION_INIT;
2108 psa_hash_operation_t op_setup = PSA_HASH_OPERATION_INIT;
2109 psa_hash_operation_t op_finished = PSA_HASH_OPERATION_INIT;
2110 psa_hash_operation_t op_aborted = PSA_HASH_OPERATION_INIT;
2111 size_t hash_len;
2112
2113 PSA_ASSERT( psa_crypto_init( ) );
2114 PSA_ASSERT( psa_hash_setup( &op_source, alg ) );
2115
2116 PSA_ASSERT( psa_hash_setup( &op_setup, alg ) );
2117 PSA_ASSERT( psa_hash_setup( &op_finished, alg ) );
2118 PSA_ASSERT( psa_hash_finish( &op_finished,
2119 hash, sizeof( hash ), &hash_len ) );
2120 PSA_ASSERT( psa_hash_setup( &op_aborted, alg ) );
2121 PSA_ASSERT( psa_hash_abort( &op_aborted ) );
2122
2123 TEST_EQUAL( psa_hash_clone( &op_source, &op_setup ),
2124 PSA_ERROR_BAD_STATE );
2125
2126 PSA_ASSERT( psa_hash_clone( &op_source, &op_init ) );
2127 PSA_ASSERT( psa_hash_finish( &op_init,
2128 hash, sizeof( hash ), &hash_len ) );
2129 PSA_ASSERT( psa_hash_clone( &op_source, &op_finished ) );
2130 PSA_ASSERT( psa_hash_finish( &op_finished,
2131 hash, sizeof( hash ), &hash_len ) );
2132 PSA_ASSERT( psa_hash_clone( &op_source, &op_aborted ) );
2133 PSA_ASSERT( psa_hash_finish( &op_aborted,
2134 hash, sizeof( hash ), &hash_len ) );
2135
2136exit:
2137 psa_hash_abort( &op_source );
2138 psa_hash_abort( &op_init );
2139 psa_hash_abort( &op_setup );
2140 psa_hash_abort( &op_finished );
2141 psa_hash_abort( &op_aborted );
Gilles Peskine1153e7b2019-05-28 15:10:21 +02002142 PSA_DONE( );
Gilles Peskineebb2c3e2019-01-19 12:03:41 +01002143}
2144/* END_CASE */
2145
Ronald Cronee414c72021-03-18 18:50:08 +01002146/* BEGIN_CASE depends_on:PSA_WANT_ALG_SHA_256 */
Gilles Peskineebb2c3e2019-01-19 12:03:41 +01002147void hash_clone_target_state( )
2148{
2149 psa_algorithm_t alg = PSA_ALG_SHA_256;
2150 unsigned char hash[PSA_HASH_MAX_SIZE];
2151 psa_hash_operation_t op_init = PSA_HASH_OPERATION_INIT;
2152 psa_hash_operation_t op_setup = PSA_HASH_OPERATION_INIT;
2153 psa_hash_operation_t op_finished = PSA_HASH_OPERATION_INIT;
2154 psa_hash_operation_t op_aborted = PSA_HASH_OPERATION_INIT;
2155 psa_hash_operation_t op_target = PSA_HASH_OPERATION_INIT;
2156 size_t hash_len;
2157
2158 PSA_ASSERT( psa_crypto_init( ) );
2159
2160 PSA_ASSERT( psa_hash_setup( &op_setup, alg ) );
2161 PSA_ASSERT( psa_hash_setup( &op_finished, alg ) );
2162 PSA_ASSERT( psa_hash_finish( &op_finished,
2163 hash, sizeof( hash ), &hash_len ) );
2164 PSA_ASSERT( psa_hash_setup( &op_aborted, alg ) );
2165 PSA_ASSERT( psa_hash_abort( &op_aborted ) );
2166
2167 PSA_ASSERT( psa_hash_clone( &op_setup, &op_target ) );
2168 PSA_ASSERT( psa_hash_finish( &op_target,
2169 hash, sizeof( hash ), &hash_len ) );
2170
2171 TEST_EQUAL( psa_hash_clone( &op_init, &op_target ), PSA_ERROR_BAD_STATE );
2172 TEST_EQUAL( psa_hash_clone( &op_finished, &op_target ),
2173 PSA_ERROR_BAD_STATE );
2174 TEST_EQUAL( psa_hash_clone( &op_aborted, &op_target ),
2175 PSA_ERROR_BAD_STATE );
2176
2177exit:
2178 psa_hash_abort( &op_target );
2179 psa_hash_abort( &op_init );
2180 psa_hash_abort( &op_setup );
2181 psa_hash_abort( &op_finished );
2182 psa_hash_abort( &op_aborted );
Gilles Peskine1153e7b2019-05-28 15:10:21 +02002183 PSA_DONE( );
Gilles Peskineebb2c3e2019-01-19 12:03:41 +01002184}
2185/* END_CASE */
2186
itayzafrir58028322018-10-25 10:22:01 +03002187/* BEGIN_CASE */
Jaeden Amero769ce272019-01-04 11:48:03 +00002188void mac_operation_init( )
2189{
Jaeden Amero252ef282019-02-15 14:05:35 +00002190 const uint8_t input[1] = { 0 };
2191
Jaeden Amero769ce272019-01-04 11:48:03 +00002192 /* Test each valid way of initializing the object, except for `= {0}`, as
2193 * Clang 5 complains when `-Wmissing-field-initializers` is used, even
2194 * though it's OK by the C standard. We could test for this, but we'd need
2195 * to supress the Clang warning for the test. */
2196 psa_mac_operation_t func = psa_mac_operation_init( );
2197 psa_mac_operation_t init = PSA_MAC_OPERATION_INIT;
2198 psa_mac_operation_t zero;
2199
2200 memset( &zero, 0, sizeof( zero ) );
2201
Jaeden Amero252ef282019-02-15 14:05:35 +00002202 /* A freshly-initialized MAC operation should not be usable. */
2203 TEST_EQUAL( psa_mac_update( &func,
2204 input, sizeof( input ) ),
2205 PSA_ERROR_BAD_STATE );
2206 TEST_EQUAL( psa_mac_update( &init,
2207 input, sizeof( input ) ),
2208 PSA_ERROR_BAD_STATE );
2209 TEST_EQUAL( psa_mac_update( &zero,
2210 input, sizeof( input ) ),
2211 PSA_ERROR_BAD_STATE );
2212
Jaeden Amero5229bbb2019-02-07 16:33:37 +00002213 /* A default MAC operation should be abortable without error. */
2214 PSA_ASSERT( psa_mac_abort( &func ) );
2215 PSA_ASSERT( psa_mac_abort( &init ) );
2216 PSA_ASSERT( psa_mac_abort( &zero ) );
Jaeden Amero769ce272019-01-04 11:48:03 +00002217}
2218/* END_CASE */
2219
2220/* BEGIN_CASE */
Gilles Peskine16c0f4f2018-06-20 16:05:20 +02002221void mac_setup( int key_type_arg,
2222 data_t *key,
2223 int alg_arg,
2224 int expected_status_arg )
2225{
Gilles Peskine16c0f4f2018-06-20 16:05:20 +02002226 psa_key_type_t key_type = key_type_arg;
2227 psa_algorithm_t alg = alg_arg;
Gilles Peskineb866e2b2018-06-21 09:25:10 +02002228 psa_status_t expected_status = expected_status_arg;
Jaeden Amero769ce272019-01-04 11:48:03 +00002229 psa_mac_operation_t operation = PSA_MAC_OPERATION_INIT;
Gilles Peskinef426e0f2019-02-25 17:42:03 +01002230 psa_status_t status = PSA_ERROR_GENERIC_ERROR;
2231#if defined(KNOWN_SUPPORTED_MAC_ALG)
2232 const uint8_t smoke_test_key_data[16] = "kkkkkkkkkkkkkkkk";
2233#endif
Gilles Peskine16c0f4f2018-06-20 16:05:20 +02002234
Gilles Peskine8817f612018-12-18 00:18:46 +01002235 PSA_ASSERT( psa_crypto_init( ) );
Gilles Peskine16c0f4f2018-06-20 16:05:20 +02002236
Gilles Peskinef426e0f2019-02-25 17:42:03 +01002237 if( ! exercise_mac_setup( key_type, key->x, key->len, alg,
2238 &operation, &status ) )
2239 goto exit;
Gilles Peskinefe11b722018-12-18 00:24:04 +01002240 TEST_EQUAL( status, expected_status );
Gilles Peskine16c0f4f2018-06-20 16:05:20 +02002241
Gilles Peskinef426e0f2019-02-25 17:42:03 +01002242 /* The operation object should be reusable. */
2243#if defined(KNOWN_SUPPORTED_MAC_ALG)
2244 if( ! exercise_mac_setup( KNOWN_SUPPORTED_MAC_KEY_TYPE,
2245 smoke_test_key_data,
2246 sizeof( smoke_test_key_data ),
2247 KNOWN_SUPPORTED_MAC_ALG,
2248 &operation, &status ) )
2249 goto exit;
2250 TEST_EQUAL( status, PSA_SUCCESS );
2251#endif
2252
Gilles Peskine16c0f4f2018-06-20 16:05:20 +02002253exit:
Gilles Peskine1153e7b2019-05-28 15:10:21 +02002254 PSA_DONE( );
Gilles Peskine16c0f4f2018-06-20 16:05:20 +02002255}
2256/* END_CASE */
2257
Gilles Peskined6dc40c2021-01-12 12:55:31 +01002258/* 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 +00002259void mac_bad_order( )
2260{
Ronald Cron5425a212020-08-04 14:58:35 +02002261 mbedtls_svc_key_id_t key = MBEDTLS_SVC_KEY_ID_INIT;
Jaeden Amero252ef282019-02-15 14:05:35 +00002262 psa_key_type_t key_type = PSA_KEY_TYPE_HMAC;
2263 psa_algorithm_t alg = PSA_ALG_HMAC(PSA_ALG_SHA_256);
Ronald Cron5425a212020-08-04 14:58:35 +02002264 const uint8_t key_data[] = {
Jaeden Amero252ef282019-02-15 14:05:35 +00002265 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
2266 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
2267 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa };
Gilles Peskine2c2cf0e2019-04-19 19:58:20 +02002268 psa_key_attributes_t attributes = PSA_KEY_ATTRIBUTES_INIT;
Jaeden Amero252ef282019-02-15 14:05:35 +00002269 psa_mac_operation_t operation = PSA_MAC_OPERATION_INIT;
2270 uint8_t sign_mac[PSA_MAC_MAX_SIZE + 10] = { 0 };
2271 size_t sign_mac_length = 0;
2272 const uint8_t input[] = { 0xbb, 0xbb, 0xbb, 0xbb };
2273 const uint8_t verify_mac[] = {
2274 0x74, 0x65, 0x93, 0x8c, 0xeb, 0x1d, 0xb3, 0x76, 0x5a, 0x38, 0xe7, 0xdd,
2275 0x85, 0xc5, 0xad, 0x4f, 0x07, 0xe7, 0xd5, 0xb2, 0x64, 0xf0, 0x1a, 0x1a,
2276 0x2c, 0xf9, 0x18, 0xca, 0x59, 0x7e, 0x5d, 0xf6 };
2277
2278 PSA_ASSERT( psa_crypto_init( ) );
Gilles Peskine89d8c5c2019-11-26 17:01:59 +01002279 psa_set_key_usage_flags( &attributes, PSA_KEY_USAGE_SIGN_HASH | PSA_KEY_USAGE_VERIFY_HASH );
Gilles Peskine2c2cf0e2019-04-19 19:58:20 +02002280 psa_set_key_algorithm( &attributes, alg );
2281 psa_set_key_type( &attributes, key_type );
Gilles Peskine16c0f4f2018-06-20 16:05:20 +02002282
Ronald Cron5425a212020-08-04 14:58:35 +02002283 PSA_ASSERT( psa_import_key( &attributes, key_data, sizeof( key_data ),
2284 &key ) );
Gilles Peskine16c0f4f2018-06-20 16:05:20 +02002285
Jaeden Amero252ef282019-02-15 14:05:35 +00002286 /* Call update without calling setup beforehand. */
2287 TEST_EQUAL( psa_mac_update( &operation, input, sizeof( input ) ),
2288 PSA_ERROR_BAD_STATE );
2289 PSA_ASSERT( psa_mac_abort( &operation ) );
2290
2291 /* Call sign finish without calling setup beforehand. */
2292 TEST_EQUAL( psa_mac_sign_finish( &operation, sign_mac, sizeof( sign_mac ),
2293 &sign_mac_length),
2294 PSA_ERROR_BAD_STATE );
2295 PSA_ASSERT( psa_mac_abort( &operation ) );
2296
2297 /* Call verify finish without calling setup beforehand. */
2298 TEST_EQUAL( psa_mac_verify_finish( &operation,
2299 verify_mac, sizeof( verify_mac ) ),
2300 PSA_ERROR_BAD_STATE );
2301 PSA_ASSERT( psa_mac_abort( &operation ) );
2302
Jaeden Amero36ee5d02019-02-19 09:25:10 +00002303 /* Call setup twice in a row. */
Ronald Cron5425a212020-08-04 14:58:35 +02002304 PSA_ASSERT( psa_mac_sign_setup( &operation, key, alg ) );
Dave Rodgman5ae6f752021-06-24 11:36:14 +01002305 ASSERT_OPERATION_IS_ACTIVE( operation );
Ronald Cron5425a212020-08-04 14:58:35 +02002306 TEST_EQUAL( psa_mac_sign_setup( &operation, key, alg ),
Jaeden Amero36ee5d02019-02-19 09:25:10 +00002307 PSA_ERROR_BAD_STATE );
Dave Rodgman5ae6f752021-06-24 11:36:14 +01002308 ASSERT_OPERATION_IS_INACTIVE( operation );
Jaeden Amero36ee5d02019-02-19 09:25:10 +00002309 PSA_ASSERT( psa_mac_abort( &operation ) );
Dave Rodgman5ae6f752021-06-24 11:36:14 +01002310 ASSERT_OPERATION_IS_INACTIVE( operation );
Jaeden Amero36ee5d02019-02-19 09:25:10 +00002311
Jaeden Amero252ef282019-02-15 14:05:35 +00002312 /* Call update after sign finish. */
Ronald Cron5425a212020-08-04 14:58:35 +02002313 PSA_ASSERT( psa_mac_sign_setup( &operation, key, alg ) );
Jaeden Amero252ef282019-02-15 14:05:35 +00002314 PSA_ASSERT( psa_mac_update( &operation, input, sizeof( input ) ) );
2315 PSA_ASSERT( psa_mac_sign_finish( &operation,
2316 sign_mac, sizeof( sign_mac ),
2317 &sign_mac_length ) );
2318 TEST_EQUAL( psa_mac_update( &operation, input, sizeof( input ) ),
2319 PSA_ERROR_BAD_STATE );
2320 PSA_ASSERT( psa_mac_abort( &operation ) );
2321
2322 /* Call update after verify finish. */
Ronald Cron5425a212020-08-04 14:58:35 +02002323 PSA_ASSERT( psa_mac_verify_setup( &operation, key, alg ) );
Jaeden Amero252ef282019-02-15 14:05:35 +00002324 PSA_ASSERT( psa_mac_update( &operation, input, sizeof( input ) ) );
2325 PSA_ASSERT( psa_mac_verify_finish( &operation,
2326 verify_mac, sizeof( verify_mac ) ) );
2327 TEST_EQUAL( psa_mac_update( &operation, input, sizeof( input ) ),
2328 PSA_ERROR_BAD_STATE );
2329 PSA_ASSERT( psa_mac_abort( &operation ) );
2330
2331 /* Call sign finish twice in a row. */
Ronald Cron5425a212020-08-04 14:58:35 +02002332 PSA_ASSERT( psa_mac_sign_setup( &operation, key, alg ) );
Jaeden Amero252ef282019-02-15 14:05:35 +00002333 PSA_ASSERT( psa_mac_update( &operation, input, sizeof( input ) ) );
2334 PSA_ASSERT( psa_mac_sign_finish( &operation,
2335 sign_mac, sizeof( sign_mac ),
2336 &sign_mac_length ) );
2337 TEST_EQUAL( psa_mac_sign_finish( &operation,
2338 sign_mac, sizeof( sign_mac ),
2339 &sign_mac_length ),
2340 PSA_ERROR_BAD_STATE );
2341 PSA_ASSERT( psa_mac_abort( &operation ) );
2342
2343 /* Call verify finish twice in a row. */
Ronald Cron5425a212020-08-04 14:58:35 +02002344 PSA_ASSERT( psa_mac_verify_setup( &operation, key, alg ) );
Jaeden Amero252ef282019-02-15 14:05:35 +00002345 PSA_ASSERT( psa_mac_update( &operation, input, sizeof( input ) ) );
2346 PSA_ASSERT( psa_mac_verify_finish( &operation,
2347 verify_mac, sizeof( verify_mac ) ) );
2348 TEST_EQUAL( psa_mac_verify_finish( &operation,
2349 verify_mac, sizeof( verify_mac ) ),
2350 PSA_ERROR_BAD_STATE );
2351 PSA_ASSERT( psa_mac_abort( &operation ) );
2352
2353 /* Setup sign but try verify. */
Ronald Cron5425a212020-08-04 14:58:35 +02002354 PSA_ASSERT( psa_mac_sign_setup( &operation, key, alg ) );
Jaeden Amero252ef282019-02-15 14:05:35 +00002355 PSA_ASSERT( psa_mac_update( &operation, input, sizeof( input ) ) );
Dave Rodgman647791d2021-06-23 12:49:59 +01002356 ASSERT_OPERATION_IS_ACTIVE( operation );
Jaeden Amero252ef282019-02-15 14:05:35 +00002357 TEST_EQUAL( psa_mac_verify_finish( &operation,
2358 verify_mac, sizeof( verify_mac ) ),
2359 PSA_ERROR_BAD_STATE );
Dave Rodgman647791d2021-06-23 12:49:59 +01002360 ASSERT_OPERATION_IS_INACTIVE( operation );
Jaeden Amero252ef282019-02-15 14:05:35 +00002361 PSA_ASSERT( psa_mac_abort( &operation ) );
Dave Rodgman647791d2021-06-23 12:49:59 +01002362 ASSERT_OPERATION_IS_INACTIVE( operation );
Jaeden Amero252ef282019-02-15 14:05:35 +00002363
2364 /* Setup verify but try sign. */
Ronald Cron5425a212020-08-04 14:58:35 +02002365 PSA_ASSERT( psa_mac_verify_setup( &operation, key, alg ) );
Jaeden Amero252ef282019-02-15 14:05:35 +00002366 PSA_ASSERT( psa_mac_update( &operation, input, sizeof( input ) ) );
Dave Rodgman647791d2021-06-23 12:49:59 +01002367 ASSERT_OPERATION_IS_ACTIVE( operation );
Jaeden Amero252ef282019-02-15 14:05:35 +00002368 TEST_EQUAL( psa_mac_sign_finish( &operation,
2369 sign_mac, sizeof( sign_mac ),
2370 &sign_mac_length ),
2371 PSA_ERROR_BAD_STATE );
Dave Rodgman647791d2021-06-23 12:49:59 +01002372 ASSERT_OPERATION_IS_INACTIVE( operation );
Jaeden Amero252ef282019-02-15 14:05:35 +00002373 PSA_ASSERT( psa_mac_abort( &operation ) );
Dave Rodgman647791d2021-06-23 12:49:59 +01002374 ASSERT_OPERATION_IS_INACTIVE( operation );
Gilles Peskine16c0f4f2018-06-20 16:05:20 +02002375
Ronald Cron5425a212020-08-04 14:58:35 +02002376 PSA_ASSERT( psa_destroy_key( key ) );
Gilles Peskine76b29a72019-05-28 14:08:50 +02002377
Gilles Peskine16c0f4f2018-06-20 16:05:20 +02002378exit:
Gilles Peskine1153e7b2019-05-28 15:10:21 +02002379 PSA_DONE( );
Gilles Peskine16c0f4f2018-06-20 16:05:20 +02002380}
2381/* END_CASE */
2382
2383/* BEGIN_CASE */
Gilles Peskinea7aa4422018-08-14 15:17:54 +02002384void mac_sign( int key_type_arg,
Ronald Cron5425a212020-08-04 14:58:35 +02002385 data_t *key_data,
Gilles Peskinea7aa4422018-08-14 15:17:54 +02002386 int alg_arg,
2387 data_t *input,
2388 data_t *expected_mac )
2389{
Ronald Cron5425a212020-08-04 14:58:35 +02002390 mbedtls_svc_key_id_t key = MBEDTLS_SVC_KEY_ID_INIT;
Gilles Peskinea7aa4422018-08-14 15:17:54 +02002391 psa_key_type_t key_type = key_type_arg;
2392 psa_algorithm_t alg = alg_arg;
Jaeden Amero769ce272019-01-04 11:48:03 +00002393 psa_mac_operation_t operation = PSA_MAC_OPERATION_INIT;
Gilles Peskine2c2cf0e2019-04-19 19:58:20 +02002394 psa_key_attributes_t attributes = PSA_KEY_ATTRIBUTES_INIT;
Gilles Peskine5e65cec2020-08-25 23:38:39 +02002395 uint8_t *actual_mac = NULL;
Gilles Peskinea7aa4422018-08-14 15:17:54 +02002396 size_t mac_buffer_size =
gabor-mezei-armcbcec212020-12-18 14:23:51 +01002397 PSA_MAC_LENGTH( key_type, PSA_BYTES_TO_BITS( key_data->len ), alg );
Gilles Peskinea7aa4422018-08-14 15:17:54 +02002398 size_t mac_length = 0;
Gilles Peskine8b356b52020-08-25 23:44:59 +02002399 const size_t output_sizes_to_test[] = {
2400 0,
2401 1,
2402 expected_mac->len - 1,
2403 expected_mac->len,
2404 expected_mac->len + 1,
2405 };
Gilles Peskinea7aa4422018-08-14 15:17:54 +02002406
Gilles Peskinea7aa4422018-08-14 15:17:54 +02002407 TEST_ASSERT( mac_buffer_size <= PSA_MAC_MAX_SIZE );
gabor-mezei-armcbcec212020-12-18 14:23:51 +01002408 /* We expect PSA_MAC_LENGTH to be exact. */
Gilles Peskine3d404d62020-08-25 23:47:36 +02002409 TEST_ASSERT( expected_mac->len == mac_buffer_size );
Gilles Peskinea7aa4422018-08-14 15:17:54 +02002410
Gilles Peskine8817f612018-12-18 00:18:46 +01002411 PSA_ASSERT( psa_crypto_init( ) );
Gilles Peskinea7aa4422018-08-14 15:17:54 +02002412
Gilles Peskine89d8c5c2019-11-26 17:01:59 +01002413 psa_set_key_usage_flags( &attributes, PSA_KEY_USAGE_SIGN_HASH );
Gilles Peskine2c2cf0e2019-04-19 19:58:20 +02002414 psa_set_key_algorithm( &attributes, alg );
2415 psa_set_key_type( &attributes, key_type );
Gilles Peskinea7aa4422018-08-14 15:17:54 +02002416
Ronald Cron5425a212020-08-04 14:58:35 +02002417 PSA_ASSERT( psa_import_key( &attributes, key_data->x, key_data->len,
2418 &key ) );
Gilles Peskinea7aa4422018-08-14 15:17:54 +02002419
Gilles Peskine8b356b52020-08-25 23:44:59 +02002420 for( size_t i = 0; i < ARRAY_LENGTH( output_sizes_to_test ); i++ )
2421 {
2422 const size_t output_size = output_sizes_to_test[i];
2423 psa_status_t expected_status =
2424 ( output_size >= expected_mac->len ? PSA_SUCCESS :
2425 PSA_ERROR_BUFFER_TOO_SMALL );
Gilles Peskine5e65cec2020-08-25 23:38:39 +02002426
Chris Jones9634bb12021-01-20 15:56:42 +00002427 mbedtls_test_set_step( output_size );
Gilles Peskine8b356b52020-08-25 23:44:59 +02002428 ASSERT_ALLOC( actual_mac, output_size );
Gilles Peskinea7aa4422018-08-14 15:17:54 +02002429
gabor-mezei-arm534bb992021-03-01 15:35:48 +01002430 /* Calculate the MAC, one-shot case. */
2431 TEST_EQUAL( psa_mac_compute( key, alg,
2432 input->x, input->len,
2433 actual_mac, output_size, &mac_length ),
2434 expected_status );
2435 if( expected_status == PSA_SUCCESS )
2436 {
2437 ASSERT_COMPARE( expected_mac->x, expected_mac->len,
2438 actual_mac, mac_length );
2439 }
2440
2441 if( output_size > 0 )
2442 memset( actual_mac, 0, output_size );
2443
2444 /* Calculate the MAC, multi-part case. */
Ronald Cron5425a212020-08-04 14:58:35 +02002445 PSA_ASSERT( psa_mac_sign_setup( &operation, key, alg ) );
Gilles Peskine8b356b52020-08-25 23:44:59 +02002446 PSA_ASSERT( psa_mac_update( &operation,
2447 input->x, input->len ) );
2448 TEST_EQUAL( psa_mac_sign_finish( &operation,
2449 actual_mac, output_size,
2450 &mac_length ),
2451 expected_status );
2452 PSA_ASSERT( psa_mac_abort( &operation ) );
2453
2454 if( expected_status == PSA_SUCCESS )
2455 {
2456 ASSERT_COMPARE( expected_mac->x, expected_mac->len,
2457 actual_mac, mac_length );
2458 }
2459 mbedtls_free( actual_mac );
2460 actual_mac = NULL;
2461 }
Gilles Peskinea7aa4422018-08-14 15:17:54 +02002462
Gilles Peskinea7aa4422018-08-14 15:17:54 +02002463exit:
Gilles Peskine64f13ef2020-08-25 23:15:20 +02002464 psa_mac_abort( &operation );
Ronald Cron5425a212020-08-04 14:58:35 +02002465 psa_destroy_key( key );
Gilles Peskine1153e7b2019-05-28 15:10:21 +02002466 PSA_DONE( );
Gilles Peskine5e65cec2020-08-25 23:38:39 +02002467 mbedtls_free( actual_mac );
Gilles Peskinea7aa4422018-08-14 15:17:54 +02002468}
2469/* END_CASE */
2470
2471/* BEGIN_CASE */
Gilles Peskinec0ec9722018-06-18 17:03:37 +02002472void mac_verify( int key_type_arg,
Ronald Cron5425a212020-08-04 14:58:35 +02002473 data_t *key_data,
Gilles Peskinec0ec9722018-06-18 17:03:37 +02002474 int alg_arg,
2475 data_t *input,
2476 data_t *expected_mac )
Gilles Peskine8c9def32018-02-08 10:02:12 +01002477{
Ronald Cron5425a212020-08-04 14:58:35 +02002478 mbedtls_svc_key_id_t key = MBEDTLS_SVC_KEY_ID_INIT;
Gilles Peskine8c9def32018-02-08 10:02:12 +01002479 psa_key_type_t key_type = key_type_arg;
2480 psa_algorithm_t alg = alg_arg;
Jaeden Amero769ce272019-01-04 11:48:03 +00002481 psa_mac_operation_t operation = PSA_MAC_OPERATION_INIT;
Gilles Peskine2c2cf0e2019-04-19 19:58:20 +02002482 psa_key_attributes_t attributes = PSA_KEY_ATTRIBUTES_INIT;
Gilles Peskine29c4a6c2020-08-26 00:01:39 +02002483 uint8_t *perturbed_mac = NULL;
Gilles Peskine8c9def32018-02-08 10:02:12 +01002484
Gilles Peskine69c12672018-06-28 00:07:19 +02002485 TEST_ASSERT( expected_mac->len <= PSA_MAC_MAX_SIZE );
2486
Gilles Peskine8817f612018-12-18 00:18:46 +01002487 PSA_ASSERT( psa_crypto_init( ) );
Gilles Peskine8c9def32018-02-08 10:02:12 +01002488
Gilles Peskine89d8c5c2019-11-26 17:01:59 +01002489 psa_set_key_usage_flags( &attributes, PSA_KEY_USAGE_VERIFY_HASH );
Gilles Peskine2c2cf0e2019-04-19 19:58:20 +02002490 psa_set_key_algorithm( &attributes, alg );
2491 psa_set_key_type( &attributes, key_type );
mohammad16036df908f2018-04-02 08:34:15 -07002492
Ronald Cron5425a212020-08-04 14:58:35 +02002493 PSA_ASSERT( psa_import_key( &attributes, key_data->x, key_data->len,
2494 &key ) );
Gilles Peskinec0ec9722018-06-18 17:03:37 +02002495
gabor-mezei-arm534bb992021-03-01 15:35:48 +01002496 /* Verify correct MAC, one-shot case. */
2497 PSA_ASSERT( psa_mac_verify( key, alg, input->x, input->len,
2498 expected_mac->x, expected_mac->len ) );
2499
2500 /* Verify correct MAC, multi-part case. */
Ronald Cron5425a212020-08-04 14:58:35 +02002501 PSA_ASSERT( psa_mac_verify_setup( &operation, key, alg ) );
Gilles Peskine8817f612018-12-18 00:18:46 +01002502 PSA_ASSERT( psa_mac_update( &operation,
2503 input->x, input->len ) );
2504 PSA_ASSERT( psa_mac_verify_finish( &operation,
2505 expected_mac->x,
2506 expected_mac->len ) );
Gilles Peskine8c9def32018-02-08 10:02:12 +01002507
gabor-mezei-arm534bb992021-03-01 15:35:48 +01002508 /* Test a MAC that's too short, one-shot case. */
2509 TEST_EQUAL( psa_mac_verify( key, alg,
2510 input->x, input->len,
2511 expected_mac->x,
2512 expected_mac->len - 1 ),
2513 PSA_ERROR_INVALID_SIGNATURE );
2514
2515 /* Test a MAC that's too short, multi-part case. */
Ronald Cron5425a212020-08-04 14:58:35 +02002516 PSA_ASSERT( psa_mac_verify_setup( &operation, key, alg ) );
Gilles Peskine29c4a6c2020-08-26 00:01:39 +02002517 PSA_ASSERT( psa_mac_update( &operation,
2518 input->x, input->len ) );
2519 TEST_EQUAL( psa_mac_verify_finish( &operation,
2520 expected_mac->x,
2521 expected_mac->len - 1 ),
2522 PSA_ERROR_INVALID_SIGNATURE );
2523
gabor-mezei-arm534bb992021-03-01 15:35:48 +01002524 /* Test a MAC that's too long, one-shot case. */
Gilles Peskine29c4a6c2020-08-26 00:01:39 +02002525 ASSERT_ALLOC( perturbed_mac, expected_mac->len + 1 );
2526 memcpy( perturbed_mac, expected_mac->x, expected_mac->len );
gabor-mezei-arm534bb992021-03-01 15:35:48 +01002527 TEST_EQUAL( psa_mac_verify( key, alg,
2528 input->x, input->len,
2529 perturbed_mac, expected_mac->len + 1 ),
2530 PSA_ERROR_INVALID_SIGNATURE );
2531
2532 /* Test a MAC that's too long, multi-part case. */
Ronald Cron5425a212020-08-04 14:58:35 +02002533 PSA_ASSERT( psa_mac_verify_setup( &operation, key, alg ) );
Gilles Peskine29c4a6c2020-08-26 00:01:39 +02002534 PSA_ASSERT( psa_mac_update( &operation,
2535 input->x, input->len ) );
2536 TEST_EQUAL( psa_mac_verify_finish( &operation,
2537 perturbed_mac,
2538 expected_mac->len + 1 ),
2539 PSA_ERROR_INVALID_SIGNATURE );
2540
2541 /* Test changing one byte. */
2542 for( size_t i = 0; i < expected_mac->len; i++ )
2543 {
Chris Jones9634bb12021-01-20 15:56:42 +00002544 mbedtls_test_set_step( i );
Gilles Peskine29c4a6c2020-08-26 00:01:39 +02002545 perturbed_mac[i] ^= 1;
gabor-mezei-arm534bb992021-03-01 15:35:48 +01002546
2547 TEST_EQUAL( psa_mac_verify( key, alg,
2548 input->x, input->len,
2549 perturbed_mac, expected_mac->len ),
2550 PSA_ERROR_INVALID_SIGNATURE );
2551
Ronald Cron5425a212020-08-04 14:58:35 +02002552 PSA_ASSERT( psa_mac_verify_setup( &operation, key, alg ) );
Gilles Peskine29c4a6c2020-08-26 00:01:39 +02002553 PSA_ASSERT( psa_mac_update( &operation,
2554 input->x, input->len ) );
2555 TEST_EQUAL( psa_mac_verify_finish( &operation,
2556 perturbed_mac,
2557 expected_mac->len ),
2558 PSA_ERROR_INVALID_SIGNATURE );
2559 perturbed_mac[i] ^= 1;
2560 }
2561
Gilles Peskine8c9def32018-02-08 10:02:12 +01002562exit:
Gilles Peskine64f13ef2020-08-25 23:15:20 +02002563 psa_mac_abort( &operation );
Ronald Cron5425a212020-08-04 14:58:35 +02002564 psa_destroy_key( key );
Gilles Peskine1153e7b2019-05-28 15:10:21 +02002565 PSA_DONE( );
Gilles Peskine29c4a6c2020-08-26 00:01:39 +02002566 mbedtls_free( perturbed_mac );
Gilles Peskine8c9def32018-02-08 10:02:12 +01002567}
2568/* END_CASE */
2569
2570/* BEGIN_CASE */
Jaeden Amero5bae2272019-01-04 11:48:27 +00002571void cipher_operation_init( )
2572{
Jaeden Ameroab439972019-02-15 14:12:05 +00002573 const uint8_t input[1] = { 0 };
2574 unsigned char output[1] = { 0 };
2575 size_t output_length;
Jaeden Amero5bae2272019-01-04 11:48:27 +00002576 /* Test each valid way of initializing the object, except for `= {0}`, as
2577 * Clang 5 complains when `-Wmissing-field-initializers` is used, even
2578 * though it's OK by the C standard. We could test for this, but we'd need
2579 * to supress the Clang warning for the test. */
2580 psa_cipher_operation_t func = psa_cipher_operation_init( );
2581 psa_cipher_operation_t init = PSA_CIPHER_OPERATION_INIT;
2582 psa_cipher_operation_t zero;
2583
2584 memset( &zero, 0, sizeof( zero ) );
2585
Jaeden Ameroab439972019-02-15 14:12:05 +00002586 /* A freshly-initialized cipher operation should not be usable. */
2587 TEST_EQUAL( psa_cipher_update( &func,
2588 input, sizeof( input ),
2589 output, sizeof( output ),
2590 &output_length ),
2591 PSA_ERROR_BAD_STATE );
2592 TEST_EQUAL( psa_cipher_update( &init,
2593 input, sizeof( input ),
2594 output, sizeof( output ),
2595 &output_length ),
2596 PSA_ERROR_BAD_STATE );
2597 TEST_EQUAL( psa_cipher_update( &zero,
2598 input, sizeof( input ),
2599 output, sizeof( output ),
2600 &output_length ),
2601 PSA_ERROR_BAD_STATE );
2602
Jaeden Amero5229bbb2019-02-07 16:33:37 +00002603 /* A default cipher operation should be abortable without error. */
2604 PSA_ASSERT( psa_cipher_abort( &func ) );
2605 PSA_ASSERT( psa_cipher_abort( &init ) );
2606 PSA_ASSERT( psa_cipher_abort( &zero ) );
Jaeden Amero5bae2272019-01-04 11:48:27 +00002607}
2608/* END_CASE */
2609
2610/* BEGIN_CASE */
Gilles Peskine16c0f4f2018-06-20 16:05:20 +02002611void cipher_setup( int key_type_arg,
2612 data_t *key,
2613 int alg_arg,
2614 int expected_status_arg )
2615{
Gilles Peskine16c0f4f2018-06-20 16:05:20 +02002616 psa_key_type_t key_type = key_type_arg;
2617 psa_algorithm_t alg = alg_arg;
Gilles Peskineb866e2b2018-06-21 09:25:10 +02002618 psa_status_t expected_status = expected_status_arg;
Jaeden Amero5bae2272019-01-04 11:48:27 +00002619 psa_cipher_operation_t operation = PSA_CIPHER_OPERATION_INIT;
Gilles Peskine16c0f4f2018-06-20 16:05:20 +02002620 psa_status_t status;
Gilles Peskine612ffd22021-01-20 18:51:00 +01002621#if defined(KNOWN_SUPPORTED_CIPHER_ALG)
Gilles Peskinef426e0f2019-02-25 17:42:03 +01002622 const uint8_t smoke_test_key_data[16] = "kkkkkkkkkkkkkkkk";
2623#endif
Gilles Peskine16c0f4f2018-06-20 16:05:20 +02002624
Gilles Peskine8817f612018-12-18 00:18:46 +01002625 PSA_ASSERT( psa_crypto_init( ) );
Gilles Peskine16c0f4f2018-06-20 16:05:20 +02002626
Gilles Peskinef426e0f2019-02-25 17:42:03 +01002627 if( ! exercise_cipher_setup( key_type, key->x, key->len, alg,
2628 &operation, &status ) )
2629 goto exit;
Gilles Peskinefe11b722018-12-18 00:24:04 +01002630 TEST_EQUAL( status, expected_status );
Gilles Peskine16c0f4f2018-06-20 16:05:20 +02002631
Gilles Peskinef426e0f2019-02-25 17:42:03 +01002632 /* The operation object should be reusable. */
2633#if defined(KNOWN_SUPPORTED_CIPHER_ALG)
2634 if( ! exercise_cipher_setup( KNOWN_SUPPORTED_CIPHER_KEY_TYPE,
2635 smoke_test_key_data,
2636 sizeof( smoke_test_key_data ),
2637 KNOWN_SUPPORTED_CIPHER_ALG,
2638 &operation, &status ) )
2639 goto exit;
2640 TEST_EQUAL( status, PSA_SUCCESS );
2641#endif
2642
Gilles Peskine16c0f4f2018-06-20 16:05:20 +02002643exit:
Gilles Peskine64f13ef2020-08-25 23:15:20 +02002644 psa_cipher_abort( &operation );
Gilles Peskine1153e7b2019-05-28 15:10:21 +02002645 PSA_DONE( );
Gilles Peskine16c0f4f2018-06-20 16:05:20 +02002646}
2647/* END_CASE */
2648
Ronald Cronee414c72021-03-18 18:50:08 +01002649/* BEGIN_CASE depends_on:PSA_WANT_KEY_TYPE_AES:PSA_WANT_ALG_CBC_PKCS7 */
Jaeden Ameroab439972019-02-15 14:12:05 +00002650void cipher_bad_order( )
2651{
Ronald Cron5425a212020-08-04 14:58:35 +02002652 mbedtls_svc_key_id_t key = MBEDTLS_SVC_KEY_ID_INIT;
Jaeden Ameroab439972019-02-15 14:12:05 +00002653 psa_key_type_t key_type = PSA_KEY_TYPE_AES;
2654 psa_algorithm_t alg = PSA_ALG_CBC_PKCS7;
Gilles Peskine2c2cf0e2019-04-19 19:58:20 +02002655 psa_key_attributes_t attributes = PSA_KEY_ATTRIBUTES_INIT;
Jaeden Ameroab439972019-02-15 14:12:05 +00002656 psa_cipher_operation_t operation = PSA_CIPHER_OPERATION_INIT;
gabor-mezei-armcbcec212020-12-18 14:23:51 +01002657 unsigned char iv[PSA_BLOCK_CIPHER_BLOCK_LENGTH(PSA_KEY_TYPE_AES)] = { 0 };
Ronald Cron5425a212020-08-04 14:58:35 +02002658 const uint8_t key_data[] = {
Jaeden Ameroab439972019-02-15 14:12:05 +00002659 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
2660 0xaa, 0xaa, 0xaa, 0xaa };
2661 const uint8_t text[] = {
2662 0xbb, 0xbb, 0xbb, 0xbb, 0xbb, 0xbb, 0xbb, 0xbb, 0xbb, 0xbb, 0xbb, 0xbb,
2663 0xbb, 0xbb, 0xbb, 0xbb };
gabor-mezei-armcbcec212020-12-18 14:23:51 +01002664 uint8_t buffer[PSA_BLOCK_CIPHER_BLOCK_LENGTH(PSA_KEY_TYPE_AES)] = { 0 };
Jaeden Ameroab439972019-02-15 14:12:05 +00002665 size_t length = 0;
2666
2667 PSA_ASSERT( psa_crypto_init( ) );
Gilles Peskine2c2cf0e2019-04-19 19:58:20 +02002668 psa_set_key_usage_flags( &attributes, PSA_KEY_USAGE_ENCRYPT | PSA_KEY_USAGE_DECRYPT );
2669 psa_set_key_algorithm( &attributes, alg );
2670 psa_set_key_type( &attributes, key_type );
Ronald Cron5425a212020-08-04 14:58:35 +02002671 PSA_ASSERT( psa_import_key( &attributes, key_data, sizeof( key_data ),
2672 &key ) );
Jaeden Ameroab439972019-02-15 14:12:05 +00002673
Jaeden Amero36ee5d02019-02-19 09:25:10 +00002674 /* Call encrypt setup twice in a row. */
Ronald Cron5425a212020-08-04 14:58:35 +02002675 PSA_ASSERT( psa_cipher_encrypt_setup( &operation, key, alg ) );
Dave Rodgman5ae6f752021-06-24 11:36:14 +01002676 ASSERT_OPERATION_IS_ACTIVE( operation );
Ronald Cron5425a212020-08-04 14:58:35 +02002677 TEST_EQUAL( psa_cipher_encrypt_setup( &operation, key, alg ),
Jaeden Amero36ee5d02019-02-19 09:25:10 +00002678 PSA_ERROR_BAD_STATE );
Dave Rodgman5ae6f752021-06-24 11:36:14 +01002679 ASSERT_OPERATION_IS_INACTIVE( operation );
Jaeden Amero36ee5d02019-02-19 09:25:10 +00002680 PSA_ASSERT( psa_cipher_abort( &operation ) );
Dave Rodgman5ae6f752021-06-24 11:36:14 +01002681 ASSERT_OPERATION_IS_INACTIVE( operation );
Jaeden Amero36ee5d02019-02-19 09:25:10 +00002682
2683 /* Call decrypt setup twice in a row. */
Ronald Cron5425a212020-08-04 14:58:35 +02002684 PSA_ASSERT( psa_cipher_decrypt_setup( &operation, key, alg ) );
Dave Rodgman5ae6f752021-06-24 11:36:14 +01002685 ASSERT_OPERATION_IS_ACTIVE( operation );
Ronald Cron5425a212020-08-04 14:58:35 +02002686 TEST_EQUAL( psa_cipher_decrypt_setup( &operation, key, alg ),
Jaeden Amero36ee5d02019-02-19 09:25:10 +00002687 PSA_ERROR_BAD_STATE );
Dave Rodgman5ae6f752021-06-24 11:36:14 +01002688 ASSERT_OPERATION_IS_INACTIVE( operation );
Jaeden Amero36ee5d02019-02-19 09:25:10 +00002689 PSA_ASSERT( psa_cipher_abort( &operation ) );
Dave Rodgman5ae6f752021-06-24 11:36:14 +01002690 ASSERT_OPERATION_IS_INACTIVE( operation );
Jaeden Amero36ee5d02019-02-19 09:25:10 +00002691
Jaeden Ameroab439972019-02-15 14:12:05 +00002692 /* Generate an IV without calling setup beforehand. */
2693 TEST_EQUAL( psa_cipher_generate_iv( &operation,
2694 buffer, sizeof( buffer ),
2695 &length ),
2696 PSA_ERROR_BAD_STATE );
2697 PSA_ASSERT( psa_cipher_abort( &operation ) );
2698
2699 /* Generate an IV twice in a row. */
Ronald Cron5425a212020-08-04 14:58:35 +02002700 PSA_ASSERT( psa_cipher_encrypt_setup( &operation, key, alg ) );
Jaeden Ameroab439972019-02-15 14:12:05 +00002701 PSA_ASSERT( psa_cipher_generate_iv( &operation,
2702 buffer, sizeof( buffer ),
2703 &length ) );
Dave Rodgman647791d2021-06-23 12:49:59 +01002704 ASSERT_OPERATION_IS_ACTIVE( operation );
Jaeden Ameroab439972019-02-15 14:12:05 +00002705 TEST_EQUAL( psa_cipher_generate_iv( &operation,
2706 buffer, sizeof( buffer ),
2707 &length ),
2708 PSA_ERROR_BAD_STATE );
Dave Rodgman647791d2021-06-23 12:49:59 +01002709 ASSERT_OPERATION_IS_INACTIVE( operation );
Jaeden Ameroab439972019-02-15 14:12:05 +00002710 PSA_ASSERT( psa_cipher_abort( &operation ) );
Dave Rodgman647791d2021-06-23 12:49:59 +01002711 ASSERT_OPERATION_IS_INACTIVE( operation );
Jaeden Ameroab439972019-02-15 14:12:05 +00002712
2713 /* Generate an IV after it's already set. */
Ronald Cron5425a212020-08-04 14:58:35 +02002714 PSA_ASSERT( psa_cipher_encrypt_setup( &operation, key, alg ) );
Jaeden Ameroab439972019-02-15 14:12:05 +00002715 PSA_ASSERT( psa_cipher_set_iv( &operation,
2716 iv, sizeof( iv ) ) );
2717 TEST_EQUAL( psa_cipher_generate_iv( &operation,
2718 buffer, sizeof( buffer ),
2719 &length ),
2720 PSA_ERROR_BAD_STATE );
2721 PSA_ASSERT( psa_cipher_abort( &operation ) );
2722
2723 /* Set an IV without calling setup beforehand. */
2724 TEST_EQUAL( psa_cipher_set_iv( &operation,
2725 iv, sizeof( iv ) ),
2726 PSA_ERROR_BAD_STATE );
2727 PSA_ASSERT( psa_cipher_abort( &operation ) );
2728
2729 /* Set an IV after it's already set. */
Ronald Cron5425a212020-08-04 14:58:35 +02002730 PSA_ASSERT( psa_cipher_encrypt_setup( &operation, key, alg ) );
Jaeden Ameroab439972019-02-15 14:12:05 +00002731 PSA_ASSERT( psa_cipher_set_iv( &operation,
2732 iv, sizeof( iv ) ) );
Dave Rodgman647791d2021-06-23 12:49:59 +01002733 ASSERT_OPERATION_IS_ACTIVE( operation );
Jaeden Ameroab439972019-02-15 14:12:05 +00002734 TEST_EQUAL( psa_cipher_set_iv( &operation,
2735 iv, sizeof( iv ) ),
2736 PSA_ERROR_BAD_STATE );
Dave Rodgman647791d2021-06-23 12:49:59 +01002737 ASSERT_OPERATION_IS_INACTIVE( operation );
Jaeden Ameroab439972019-02-15 14:12:05 +00002738 PSA_ASSERT( psa_cipher_abort( &operation ) );
Dave Rodgman647791d2021-06-23 12:49:59 +01002739 ASSERT_OPERATION_IS_INACTIVE( operation );
Jaeden Ameroab439972019-02-15 14:12:05 +00002740
2741 /* Set an IV after it's already generated. */
Ronald Cron5425a212020-08-04 14:58:35 +02002742 PSA_ASSERT( psa_cipher_encrypt_setup( &operation, key, alg ) );
Jaeden Ameroab439972019-02-15 14:12:05 +00002743 PSA_ASSERT( psa_cipher_generate_iv( &operation,
2744 buffer, sizeof( buffer ),
2745 &length ) );
2746 TEST_EQUAL( psa_cipher_set_iv( &operation,
2747 iv, sizeof( iv ) ),
2748 PSA_ERROR_BAD_STATE );
2749 PSA_ASSERT( psa_cipher_abort( &operation ) );
2750
2751 /* Call update without calling setup beforehand. */
2752 TEST_EQUAL( psa_cipher_update( &operation,
2753 text, sizeof( text ),
2754 buffer, sizeof( buffer ),
2755 &length ),
2756 PSA_ERROR_BAD_STATE );
2757 PSA_ASSERT( psa_cipher_abort( &operation ) );
2758
2759 /* Call update without an IV where an IV is required. */
Dave Rodgman095dadc2021-06-23 12:48:52 +01002760 PSA_ASSERT( psa_cipher_encrypt_setup( &operation, key, alg ) );
Dave Rodgman647791d2021-06-23 12:49:59 +01002761 ASSERT_OPERATION_IS_ACTIVE( operation );
Jaeden Ameroab439972019-02-15 14:12:05 +00002762 TEST_EQUAL( psa_cipher_update( &operation,
2763 text, sizeof( text ),
2764 buffer, sizeof( buffer ),
2765 &length ),
2766 PSA_ERROR_BAD_STATE );
Dave Rodgman647791d2021-06-23 12:49:59 +01002767 ASSERT_OPERATION_IS_INACTIVE( operation );
Jaeden Ameroab439972019-02-15 14:12:05 +00002768 PSA_ASSERT( psa_cipher_abort( &operation ) );
Dave Rodgman647791d2021-06-23 12:49:59 +01002769 ASSERT_OPERATION_IS_INACTIVE( operation );
Jaeden Ameroab439972019-02-15 14:12:05 +00002770
2771 /* Call update after finish. */
Ronald Cron5425a212020-08-04 14:58:35 +02002772 PSA_ASSERT( psa_cipher_encrypt_setup( &operation, key, alg ) );
Jaeden Ameroab439972019-02-15 14:12:05 +00002773 PSA_ASSERT( psa_cipher_set_iv( &operation,
2774 iv, sizeof( iv ) ) );
2775 PSA_ASSERT( psa_cipher_finish( &operation,
2776 buffer, sizeof( buffer ), &length ) );
2777 TEST_EQUAL( psa_cipher_update( &operation,
2778 text, sizeof( text ),
2779 buffer, sizeof( buffer ),
2780 &length ),
2781 PSA_ERROR_BAD_STATE );
2782 PSA_ASSERT( psa_cipher_abort( &operation ) );
2783
2784 /* Call finish without calling setup beforehand. */
2785 TEST_EQUAL( psa_cipher_finish( &operation,
2786 buffer, sizeof( buffer ), &length ),
2787 PSA_ERROR_BAD_STATE );
2788 PSA_ASSERT( psa_cipher_abort( &operation ) );
2789
2790 /* Call finish without an IV where an IV is required. */
Ronald Cron5425a212020-08-04 14:58:35 +02002791 PSA_ASSERT( psa_cipher_encrypt_setup( &operation, key, alg ) );
Jaeden Ameroab439972019-02-15 14:12:05 +00002792 /* Not calling update means we are encrypting an empty buffer, which is OK
2793 * for cipher modes with padding. */
Dave Rodgman647791d2021-06-23 12:49:59 +01002794 ASSERT_OPERATION_IS_ACTIVE( operation );
Jaeden Ameroab439972019-02-15 14:12:05 +00002795 TEST_EQUAL( psa_cipher_finish( &operation,
2796 buffer, sizeof( buffer ), &length ),
2797 PSA_ERROR_BAD_STATE );
Dave Rodgman647791d2021-06-23 12:49:59 +01002798 ASSERT_OPERATION_IS_INACTIVE( operation );
Jaeden Ameroab439972019-02-15 14:12:05 +00002799 PSA_ASSERT( psa_cipher_abort( &operation ) );
Dave Rodgman647791d2021-06-23 12:49:59 +01002800 ASSERT_OPERATION_IS_INACTIVE( operation );
Jaeden Ameroab439972019-02-15 14:12:05 +00002801
2802 /* Call finish twice in a row. */
Ronald Cron5425a212020-08-04 14:58:35 +02002803 PSA_ASSERT( psa_cipher_encrypt_setup( &operation, key, alg ) );
Jaeden Ameroab439972019-02-15 14:12:05 +00002804 PSA_ASSERT( psa_cipher_set_iv( &operation,
2805 iv, sizeof( iv ) ) );
2806 PSA_ASSERT( psa_cipher_finish( &operation,
2807 buffer, sizeof( buffer ), &length ) );
2808 TEST_EQUAL( psa_cipher_finish( &operation,
2809 buffer, sizeof( buffer ), &length ),
2810 PSA_ERROR_BAD_STATE );
2811 PSA_ASSERT( psa_cipher_abort( &operation ) );
2812
Ronald Cron5425a212020-08-04 14:58:35 +02002813 PSA_ASSERT( psa_destroy_key( key ) );
Gilles Peskine76b29a72019-05-28 14:08:50 +02002814
Jaeden Ameroab439972019-02-15 14:12:05 +00002815exit:
Gilles Peskine64f13ef2020-08-25 23:15:20 +02002816 psa_cipher_abort( &operation );
Gilles Peskine1153e7b2019-05-28 15:10:21 +02002817 PSA_DONE( );
Gilles Peskine16c0f4f2018-06-20 16:05:20 +02002818}
2819/* END_CASE */
2820
2821/* BEGIN_CASE */
gabor-mezei-arma56756e2021-06-25 15:49:14 +02002822void cipher_encrypt_fail( int alg_arg,
2823 int key_type_arg,
2824 data_t *key_data,
2825 data_t *input,
2826 int expected_status_arg )
Gilles Peskine50e586b2018-06-08 14:28:46 +02002827{
Ronald Cron5425a212020-08-04 14:58:35 +02002828 mbedtls_svc_key_id_t key = MBEDTLS_SVC_KEY_ID_INIT;
Gilles Peskine50e586b2018-06-08 14:28:46 +02002829 psa_status_t status;
2830 psa_key_type_t key_type = key_type_arg;
2831 psa_algorithm_t alg = alg_arg;
Gilles Peskineb866e2b2018-06-21 09:25:10 +02002832 psa_status_t expected_status = expected_status_arg;
itayzafrir3e02b3b2018-06-12 17:06:52 +03002833 unsigned char *output = NULL;
Gilles Peskine50e586b2018-06-08 14:28:46 +02002834 size_t output_buffer_size = 0;
gabor-mezei-armf494bcd2021-03-01 15:11:46 +01002835 size_t output_length = 0;
2836 psa_key_attributes_t attributes = PSA_KEY_ATTRIBUTES_INIT;
2837
2838 if ( PSA_ERROR_BAD_STATE != expected_status )
2839 {
2840 PSA_ASSERT( psa_crypto_init( ) );
2841
2842 psa_set_key_usage_flags( &attributes, PSA_KEY_USAGE_ENCRYPT );
2843 psa_set_key_algorithm( &attributes, alg );
2844 psa_set_key_type( &attributes, key_type );
2845
2846 output_buffer_size = PSA_CIPHER_ENCRYPT_OUTPUT_SIZE( key_type, alg,
2847 input->len );
2848 ASSERT_ALLOC( output, output_buffer_size );
2849
2850 PSA_ASSERT( psa_import_key( &attributes, key_data->x, key_data->len,
2851 &key ) );
2852 }
2853
2854 status = psa_cipher_encrypt( key, alg, input->x, input->len, output,
2855 output_buffer_size, &output_length );
2856
2857 TEST_EQUAL( status, expected_status );
2858
2859exit:
2860 mbedtls_free( output );
2861 psa_destroy_key( key );
2862 PSA_DONE( );
2863}
2864/* END_CASE */
2865
2866/* BEGIN_CASE */
Mateusz Starzyked71e922021-10-21 10:04:57 +02002867void cipher_encrypt_validate_iv_length( int alg, int key_type, data_t* key_data,
2868 data_t *input, int iv_length,
2869 int expected_result )
2870{
2871 mbedtls_svc_key_id_t key = MBEDTLS_SVC_KEY_ID_INIT;
2872 psa_cipher_operation_t operation = PSA_CIPHER_OPERATION_INIT;
2873 psa_key_attributes_t attributes = PSA_KEY_ATTRIBUTES_INIT;
2874 size_t output_buffer_size = 0;
2875 unsigned char *output = NULL;
2876
2877 output_buffer_size = PSA_CIPHER_ENCRYPT_OUTPUT_SIZE( key_type, alg, input->len );
2878 ASSERT_ALLOC( output, output_buffer_size );
2879
2880 PSA_ASSERT( psa_crypto_init( ) );
2881
2882 psa_set_key_usage_flags( &attributes, PSA_KEY_USAGE_ENCRYPT );
2883 psa_set_key_algorithm( &attributes, alg );
2884 psa_set_key_type( &attributes, key_type );
2885
2886 PSA_ASSERT( psa_import_key( &attributes, key_data->x, key_data->len,
2887 &key ) );
2888 PSA_ASSERT( psa_cipher_encrypt_setup( &operation, key, alg ) );
2889 TEST_EQUAL( expected_result, psa_cipher_set_iv( &operation, output,
2890 iv_length ) );
2891
2892exit:
2893 psa_cipher_abort( &operation );
2894 mbedtls_free( output );
2895 psa_destroy_key( key );
2896 PSA_DONE( );
2897}
2898/* END_CASE */
2899
2900/* BEGIN_CASE */
gabor-mezei-arma56756e2021-06-25 15:49:14 +02002901void cipher_encrypt_alg_without_iv( int alg_arg,
2902 int key_type_arg,
2903 data_t *key_data,
2904 data_t *input,
2905 data_t *expected_output )
gabor-mezei-armf494bcd2021-03-01 15:11:46 +01002906{
2907 mbedtls_svc_key_id_t key = MBEDTLS_SVC_KEY_ID_INIT;
2908 psa_key_type_t key_type = key_type_arg;
2909 psa_algorithm_t alg = alg_arg;
2910 unsigned char *output = NULL;
2911 size_t output_buffer_size = 0;
2912 size_t output_length = 0;
2913 psa_key_attributes_t attributes = PSA_KEY_ATTRIBUTES_INIT;
2914
2915 PSA_ASSERT( psa_crypto_init( ) );
2916
2917 psa_set_key_usage_flags( &attributes, PSA_KEY_USAGE_ENCRYPT );
2918 psa_set_key_algorithm( &attributes, alg );
2919 psa_set_key_type( &attributes, key_type );
2920
2921 output_buffer_size = PSA_CIPHER_ENCRYPT_OUTPUT_SIZE( key_type, alg, input->len );
2922 ASSERT_ALLOC( output, output_buffer_size );
2923
2924 PSA_ASSERT( psa_import_key( &attributes, key_data->x, key_data->len,
2925 &key ) );
2926
2927 PSA_ASSERT( psa_cipher_encrypt( key, alg, input->x, input->len, output,
2928 output_buffer_size, &output_length ) );
2929 TEST_ASSERT( output_length <=
2930 PSA_CIPHER_ENCRYPT_OUTPUT_SIZE( key_type, alg, input->len ) );
2931 TEST_ASSERT( output_length <=
2932 PSA_CIPHER_ENCRYPT_OUTPUT_MAX_SIZE( input->len ) );
2933
2934 ASSERT_COMPARE( expected_output->x, expected_output->len,
2935 output, output_length );
2936exit:
2937 mbedtls_free( output );
2938 psa_destroy_key( key );
2939 PSA_DONE( );
2940}
2941/* END_CASE */
2942
2943/* BEGIN_CASE */
Paul Elliotta417f562021-07-14 12:31:21 +01002944void cipher_bad_key( int alg_arg, int key_type_arg, data_t *key_data )
2945{
2946 mbedtls_svc_key_id_t key = MBEDTLS_SVC_KEY_ID_INIT;
2947 psa_algorithm_t alg = alg_arg;
2948 psa_key_type_t key_type = key_type_arg;
2949 psa_key_attributes_t attributes = PSA_KEY_ATTRIBUTES_INIT;
2950 psa_cipher_operation_t operation = PSA_CIPHER_OPERATION_INIT;
2951 psa_status_t status;
2952
2953 PSA_ASSERT( psa_crypto_init( ) );
2954
2955 psa_set_key_usage_flags( &attributes, PSA_KEY_USAGE_ENCRYPT );
2956 psa_set_key_algorithm( &attributes, alg );
2957 psa_set_key_type( &attributes, key_type );
2958
2959 /* Usage of either of these two size macros would cause divide by zero
2960 * with incorrect key types previously. Input length should be irrelevant
2961 * here. */
2962 TEST_EQUAL( PSA_CIPHER_ENCRYPT_OUTPUT_SIZE( key_type, alg, 16 ),
2963 0 );
2964 TEST_EQUAL( PSA_CIPHER_UPDATE_OUTPUT_SIZE( key_type, alg, 16 ), 0 );
2965
2966
2967 PSA_ASSERT( psa_import_key( &attributes, key_data->x, key_data->len,
2968 &key ) );
2969
2970 /* Should fail due to invalid alg type (to support invalid key type).
2971 * Encrypt or decrypt will end up in the same place. */
2972 status = psa_cipher_encrypt_setup( &operation, key, alg );
2973
2974 TEST_EQUAL( status, PSA_ERROR_INVALID_ARGUMENT );
2975
2976exit:
2977 psa_cipher_abort( &operation );
2978 psa_destroy_key( key );
2979 PSA_DONE( );
2980}
2981/* END_CASE */
2982
2983/* BEGIN_CASE */
gabor-mezei-armf494bcd2021-03-01 15:11:46 +01002984void cipher_encrypt_validation( int alg_arg,
2985 int key_type_arg,
2986 data_t *key_data,
2987 data_t *input )
2988{
2989 mbedtls_svc_key_id_t key = MBEDTLS_SVC_KEY_ID_INIT;
2990 psa_key_type_t key_type = key_type_arg;
2991 psa_algorithm_t alg = alg_arg;
2992 size_t iv_size = PSA_CIPHER_IV_LENGTH ( key_type, alg );
2993 unsigned char *output1 = NULL;
2994 size_t output1_buffer_size = 0;
2995 size_t output1_length = 0;
2996 unsigned char *output2 = NULL;
2997 size_t output2_buffer_size = 0;
2998 size_t output2_length = 0;
Gilles Peskine50e586b2018-06-08 14:28:46 +02002999 size_t function_output_length = 0;
Jaeden Amero5bae2272019-01-04 11:48:27 +00003000 psa_cipher_operation_t operation = PSA_CIPHER_OPERATION_INIT;
Gilles Peskine2c2cf0e2019-04-19 19:58:20 +02003001 psa_key_attributes_t attributes = PSA_KEY_ATTRIBUTES_INIT;
Gilles Peskine50e586b2018-06-08 14:28:46 +02003002
Gilles Peskine8817f612018-12-18 00:18:46 +01003003 PSA_ASSERT( psa_crypto_init( ) );
Gilles Peskine50e586b2018-06-08 14:28:46 +02003004
Gilles Peskine2c2cf0e2019-04-19 19:58:20 +02003005 psa_set_key_usage_flags( &attributes, PSA_KEY_USAGE_ENCRYPT );
3006 psa_set_key_algorithm( &attributes, alg );
3007 psa_set_key_type( &attributes, key_type );
Moran Pekered346952018-07-05 15:22:45 +03003008
gabor-mezei-armf494bcd2021-03-01 15:11:46 +01003009 output1_buffer_size = PSA_CIPHER_ENCRYPT_OUTPUT_SIZE( key_type, alg, input->len );
3010 output2_buffer_size = PSA_CIPHER_UPDATE_OUTPUT_SIZE( key_type, alg, input->len ) +
3011 PSA_CIPHER_FINISH_OUTPUT_SIZE( key_type, alg );
3012 ASSERT_ALLOC( output1, output1_buffer_size );
3013 ASSERT_ALLOC( output2, output2_buffer_size );
3014
Ronald Cron5425a212020-08-04 14:58:35 +02003015 PSA_ASSERT( psa_import_key( &attributes, key_data->x, key_data->len,
3016 &key ) );
Gilles Peskine50e586b2018-06-08 14:28:46 +02003017
gabor-mezei-arm50c86cf2021-06-25 15:47:50 +02003018 /* The one-shot cipher encryption uses generated iv so validating
3019 the output is not possible. Validating with multipart encryption. */
gabor-mezei-armf494bcd2021-03-01 15:11:46 +01003020 PSA_ASSERT( psa_cipher_encrypt( key, alg, input->x, input->len, output1,
3021 output1_buffer_size, &output1_length ) );
3022 TEST_ASSERT( output1_length <=
3023 PSA_CIPHER_ENCRYPT_OUTPUT_SIZE( key_type, alg, input->len ) );
3024 TEST_ASSERT( output1_length <=
gabor-mezei-armceface22021-01-21 12:26:17 +01003025 PSA_CIPHER_ENCRYPT_OUTPUT_MAX_SIZE( input->len ) );
gabor-mezei-armf494bcd2021-03-01 15:11:46 +01003026
3027 PSA_ASSERT( psa_cipher_encrypt_setup( &operation, key, alg ) );
3028 PSA_ASSERT( psa_cipher_set_iv( &operation, output1, iv_size ) );
Gilles Peskine50e586b2018-06-08 14:28:46 +02003029
Gilles Peskine8817f612018-12-18 00:18:46 +01003030 PSA_ASSERT( psa_cipher_update( &operation,
3031 input->x, input->len,
gabor-mezei-armf494bcd2021-03-01 15:11:46 +01003032 output2, output2_buffer_size,
Gilles Peskine8817f612018-12-18 00:18:46 +01003033 &function_output_length ) );
gabor-mezei-armceface22021-01-21 12:26:17 +01003034 TEST_ASSERT( function_output_length <=
3035 PSA_CIPHER_UPDATE_OUTPUT_SIZE( key_type, alg, input->len ) );
3036 TEST_ASSERT( function_output_length <=
3037 PSA_CIPHER_UPDATE_OUTPUT_MAX_SIZE( input->len ) );
gabor-mezei-armf494bcd2021-03-01 15:11:46 +01003038 output2_length += function_output_length;
gabor-mezei-armceface22021-01-21 12:26:17 +01003039
gabor-mezei-armf494bcd2021-03-01 15:11:46 +01003040 PSA_ASSERT( psa_cipher_finish( &operation,
3041 output2 + output2_length,
3042 output2_buffer_size - output2_length,
3043 &function_output_length ) );
gabor-mezei-armceface22021-01-21 12:26:17 +01003044 TEST_ASSERT( function_output_length <=
3045 PSA_CIPHER_FINISH_OUTPUT_SIZE( key_type, alg ) );
3046 TEST_ASSERT( function_output_length <=
3047 PSA_CIPHER_FINISH_OUTPUT_MAX_SIZE );
gabor-mezei-armf494bcd2021-03-01 15:11:46 +01003048 output2_length += function_output_length;
Gilles Peskinea7ec95f2018-06-08 14:40:59 +02003049
gabor-mezei-armf494bcd2021-03-01 15:11:46 +01003050 PSA_ASSERT( psa_cipher_abort( &operation ) );
3051 ASSERT_COMPARE( output1 + iv_size, output1_length - iv_size,
3052 output2, output2_length );
Gilles Peskinea7ec95f2018-06-08 14:40:59 +02003053
Gilles Peskine50e586b2018-06-08 14:28:46 +02003054exit:
Gilles Peskine64f13ef2020-08-25 23:15:20 +02003055 psa_cipher_abort( &operation );
gabor-mezei-armf494bcd2021-03-01 15:11:46 +01003056 mbedtls_free( output1 );
3057 mbedtls_free( output2 );
Ronald Cron5425a212020-08-04 14:58:35 +02003058 psa_destroy_key( key );
Gilles Peskine1153e7b2019-05-28 15:10:21 +02003059 PSA_DONE( );
Gilles Peskine50e586b2018-06-08 14:28:46 +02003060}
3061/* END_CASE */
3062
3063/* BEGIN_CASE */
3064void cipher_encrypt_multipart( int alg_arg, int key_type_arg,
Ronald Cron5425a212020-08-04 14:58:35 +02003065 data_t *key_data, data_t *iv,
itayzafrir3e02b3b2018-06-12 17:06:52 +03003066 data_t *input,
Gilles Peskinee0866522019-02-19 19:44:00 +01003067 int first_part_size_arg,
3068 int output1_length_arg, int output2_length_arg,
gabor-mezei-arm95aad832021-06-25 18:21:33 +02003069 data_t *expected_output,
3070 int expected_status_arg )
Gilles Peskine50e586b2018-06-08 14:28:46 +02003071{
Ronald Cron5425a212020-08-04 14:58:35 +02003072 mbedtls_svc_key_id_t key = MBEDTLS_SVC_KEY_ID_INIT;
Gilles Peskine50e586b2018-06-08 14:28:46 +02003073 psa_key_type_t key_type = key_type_arg;
3074 psa_algorithm_t alg = alg_arg;
gabor-mezei-arm95aad832021-06-25 18:21:33 +02003075 psa_status_t status;
3076 psa_status_t expected_status = expected_status_arg;
Gilles Peskinee0866522019-02-19 19:44:00 +01003077 size_t first_part_size = first_part_size_arg;
3078 size_t output1_length = output1_length_arg;
3079 size_t output2_length = output2_length_arg;
itayzafrir3e02b3b2018-06-12 17:06:52 +03003080 unsigned char *output = NULL;
Gilles Peskine50e586b2018-06-08 14:28:46 +02003081 size_t output_buffer_size = 0;
3082 size_t function_output_length = 0;
Gilles Peskinea7ec95f2018-06-08 14:40:59 +02003083 size_t total_output_length = 0;
Jaeden Amero5bae2272019-01-04 11:48:27 +00003084 psa_cipher_operation_t operation = PSA_CIPHER_OPERATION_INIT;
Gilles Peskine2c2cf0e2019-04-19 19:58:20 +02003085 psa_key_attributes_t attributes = PSA_KEY_ATTRIBUTES_INIT;
Gilles Peskine50e586b2018-06-08 14:28:46 +02003086
Gilles Peskine8817f612018-12-18 00:18:46 +01003087 PSA_ASSERT( psa_crypto_init( ) );
Gilles Peskine50e586b2018-06-08 14:28:46 +02003088
Gilles Peskine2c2cf0e2019-04-19 19:58:20 +02003089 psa_set_key_usage_flags( &attributes, PSA_KEY_USAGE_ENCRYPT );
3090 psa_set_key_algorithm( &attributes, alg );
3091 psa_set_key_type( &attributes, key_type );
Moran Pekered346952018-07-05 15:22:45 +03003092
Ronald Cron5425a212020-08-04 14:58:35 +02003093 PSA_ASSERT( psa_import_key( &attributes, key_data->x, key_data->len,
3094 &key ) );
Gilles Peskine50e586b2018-06-08 14:28:46 +02003095
Ronald Cron5425a212020-08-04 14:58:35 +02003096 PSA_ASSERT( psa_cipher_encrypt_setup( &operation, key, alg ) );
Gilles Peskine50e586b2018-06-08 14:28:46 +02003097
Steven Cooremaned3c9ec2020-07-06 14:08:59 +02003098 if( iv->len > 0 )
3099 {
Steven Cooremana6033e92020-08-25 11:47:50 +02003100 PSA_ASSERT( psa_cipher_set_iv( &operation, iv->x, iv->len ) );
Steven Cooremaned3c9ec2020-07-06 14:08:59 +02003101 }
3102
gabor-mezei-armf494bcd2021-03-01 15:11:46 +01003103 output_buffer_size = PSA_CIPHER_UPDATE_OUTPUT_SIZE( key_type, alg, input->len ) +
3104 PSA_CIPHER_FINISH_OUTPUT_SIZE( key_type, alg );
Gilles Peskine8cebbba2018-09-27 13:54:18 +02003105 ASSERT_ALLOC( output, output_buffer_size );
Gilles Peskine50e586b2018-06-08 14:28:46 +02003106
Gilles Peskinee0866522019-02-19 19:44:00 +01003107 TEST_ASSERT( first_part_size <= input->len );
Gilles Peskine8817f612018-12-18 00:18:46 +01003108 PSA_ASSERT( psa_cipher_update( &operation, input->x, first_part_size,
3109 output, output_buffer_size,
3110 &function_output_length ) );
Gilles Peskinee0866522019-02-19 19:44:00 +01003111 TEST_ASSERT( function_output_length == output1_length );
gabor-mezei-armceface22021-01-21 12:26:17 +01003112 TEST_ASSERT( function_output_length <=
3113 PSA_CIPHER_UPDATE_OUTPUT_SIZE( key_type, alg, first_part_size ) );
3114 TEST_ASSERT( function_output_length <=
3115 PSA_CIPHER_UPDATE_OUTPUT_MAX_SIZE( first_part_size) );
Gilles Peskinea7ec95f2018-06-08 14:40:59 +02003116 total_output_length += function_output_length;
gabor-mezei-armceface22021-01-21 12:26:17 +01003117
gabor-mezei-arm95aad832021-06-25 18:21:33 +02003118 if( first_part_size < input->len )
3119 {
3120 PSA_ASSERT( psa_cipher_update( &operation,
3121 input->x + first_part_size,
3122 input->len - first_part_size,
3123 ( output_buffer_size == 0 ? NULL :
3124 output + total_output_length ),
3125 output_buffer_size - total_output_length,
3126 &function_output_length ) );
3127 TEST_ASSERT( function_output_length == output2_length );
3128 TEST_ASSERT( function_output_length <=
3129 PSA_CIPHER_UPDATE_OUTPUT_SIZE( key_type,
3130 alg,
3131 input->len - first_part_size ) );
3132 TEST_ASSERT( function_output_length <=
3133 PSA_CIPHER_UPDATE_OUTPUT_MAX_SIZE( input->len ) );
3134 total_output_length += function_output_length;
3135 }
gabor-mezei-armceface22021-01-21 12:26:17 +01003136
gabor-mezei-arm95aad832021-06-25 18:21:33 +02003137 status = psa_cipher_finish( &operation,
3138 ( output_buffer_size == 0 ? NULL :
3139 output + total_output_length ),
3140 output_buffer_size - total_output_length,
3141 &function_output_length );
gabor-mezei-armceface22021-01-21 12:26:17 +01003142 TEST_ASSERT( function_output_length <=
3143 PSA_CIPHER_FINISH_OUTPUT_SIZE( key_type, alg ) );
3144 TEST_ASSERT( function_output_length <=
3145 PSA_CIPHER_FINISH_OUTPUT_MAX_SIZE );
Gilles Peskinea7ec95f2018-06-08 14:40:59 +02003146 total_output_length += function_output_length;
gabor-mezei-arm95aad832021-06-25 18:21:33 +02003147 TEST_EQUAL( status, expected_status );
Gilles Peskine50e586b2018-06-08 14:28:46 +02003148
gabor-mezei-arm95aad832021-06-25 18:21:33 +02003149 if( expected_status == PSA_SUCCESS )
3150 {
3151 PSA_ASSERT( psa_cipher_abort( &operation ) );
3152
3153 ASSERT_COMPARE( expected_output->x, expected_output->len,
3154 output, total_output_length );
3155 }
Gilles Peskine50e586b2018-06-08 14:28:46 +02003156
3157exit:
Gilles Peskine64f13ef2020-08-25 23:15:20 +02003158 psa_cipher_abort( &operation );
itayzafrir3e02b3b2018-06-12 17:06:52 +03003159 mbedtls_free( output );
Ronald Cron5425a212020-08-04 14:58:35 +02003160 psa_destroy_key( key );
Gilles Peskine1153e7b2019-05-28 15:10:21 +02003161 PSA_DONE( );
Gilles Peskine50e586b2018-06-08 14:28:46 +02003162}
3163/* END_CASE */
3164
3165/* BEGIN_CASE */
3166void cipher_decrypt_multipart( int alg_arg, int key_type_arg,
Ronald Cron5425a212020-08-04 14:58:35 +02003167 data_t *key_data, data_t *iv,
itayzafrir3e02b3b2018-06-12 17:06:52 +03003168 data_t *input,
Gilles Peskinee0866522019-02-19 19:44:00 +01003169 int first_part_size_arg,
3170 int output1_length_arg, int output2_length_arg,
gabor-mezei-arm95aad832021-06-25 18:21:33 +02003171 data_t *expected_output,
3172 int expected_status_arg )
Gilles Peskine50e586b2018-06-08 14:28:46 +02003173{
Ronald Cron5425a212020-08-04 14:58:35 +02003174 mbedtls_svc_key_id_t key = MBEDTLS_SVC_KEY_ID_INIT;
Gilles Peskine50e586b2018-06-08 14:28:46 +02003175 psa_key_type_t key_type = key_type_arg;
3176 psa_algorithm_t alg = alg_arg;
gabor-mezei-arm95aad832021-06-25 18:21:33 +02003177 psa_status_t status;
3178 psa_status_t expected_status = expected_status_arg;
Gilles Peskinee0866522019-02-19 19:44:00 +01003179 size_t first_part_size = first_part_size_arg;
3180 size_t output1_length = output1_length_arg;
3181 size_t output2_length = output2_length_arg;
itayzafrir3e02b3b2018-06-12 17:06:52 +03003182 unsigned char *output = NULL;
Gilles Peskine50e586b2018-06-08 14:28:46 +02003183 size_t output_buffer_size = 0;
3184 size_t function_output_length = 0;
Gilles Peskinea7ec95f2018-06-08 14:40:59 +02003185 size_t total_output_length = 0;
Jaeden Amero5bae2272019-01-04 11:48:27 +00003186 psa_cipher_operation_t operation = PSA_CIPHER_OPERATION_INIT;
Gilles Peskine2c2cf0e2019-04-19 19:58:20 +02003187 psa_key_attributes_t attributes = PSA_KEY_ATTRIBUTES_INIT;
Gilles Peskine50e586b2018-06-08 14:28:46 +02003188
Gilles Peskine8817f612018-12-18 00:18:46 +01003189 PSA_ASSERT( psa_crypto_init( ) );
Gilles Peskine50e586b2018-06-08 14:28:46 +02003190
Gilles Peskine2c2cf0e2019-04-19 19:58:20 +02003191 psa_set_key_usage_flags( &attributes, PSA_KEY_USAGE_DECRYPT );
3192 psa_set_key_algorithm( &attributes, alg );
3193 psa_set_key_type( &attributes, key_type );
Moran Pekered346952018-07-05 15:22:45 +03003194
Ronald Cron5425a212020-08-04 14:58:35 +02003195 PSA_ASSERT( psa_import_key( &attributes, key_data->x, key_data->len,
3196 &key ) );
Gilles Peskine50e586b2018-06-08 14:28:46 +02003197
Ronald Cron5425a212020-08-04 14:58:35 +02003198 PSA_ASSERT( psa_cipher_decrypt_setup( &operation, key, alg ) );
Gilles Peskine50e586b2018-06-08 14:28:46 +02003199
Steven Cooreman177deba2020-09-07 17:14:14 +02003200 if( iv->len > 0 )
3201 {
Steven Cooremana6033e92020-08-25 11:47:50 +02003202 PSA_ASSERT( psa_cipher_set_iv( &operation, iv->x, iv->len ) );
Steven Cooremaned3c9ec2020-07-06 14:08:59 +02003203 }
Gilles Peskine50e586b2018-06-08 14:28:46 +02003204
gabor-mezei-armf494bcd2021-03-01 15:11:46 +01003205 output_buffer_size = PSA_CIPHER_UPDATE_OUTPUT_SIZE( key_type, alg, input->len ) +
3206 PSA_CIPHER_FINISH_OUTPUT_SIZE( key_type, alg );
Gilles Peskine8cebbba2018-09-27 13:54:18 +02003207 ASSERT_ALLOC( output, output_buffer_size );
Gilles Peskine50e586b2018-06-08 14:28:46 +02003208
Gilles Peskinee0866522019-02-19 19:44:00 +01003209 TEST_ASSERT( first_part_size <= input->len );
Gilles Peskine8817f612018-12-18 00:18:46 +01003210 PSA_ASSERT( psa_cipher_update( &operation,
3211 input->x, first_part_size,
3212 output, output_buffer_size,
3213 &function_output_length ) );
Gilles Peskinee0866522019-02-19 19:44:00 +01003214 TEST_ASSERT( function_output_length == output1_length );
gabor-mezei-armceface22021-01-21 12:26:17 +01003215 TEST_ASSERT( function_output_length <=
3216 PSA_CIPHER_UPDATE_OUTPUT_SIZE( key_type, alg, first_part_size ) );
3217 TEST_ASSERT( function_output_length <=
3218 PSA_CIPHER_UPDATE_OUTPUT_MAX_SIZE( first_part_size ) );
Gilles Peskinea7ec95f2018-06-08 14:40:59 +02003219 total_output_length += function_output_length;
gabor-mezei-armceface22021-01-21 12:26:17 +01003220
gabor-mezei-arm95aad832021-06-25 18:21:33 +02003221 if( first_part_size < input->len )
Steven Cooreman177deba2020-09-07 17:14:14 +02003222 {
gabor-mezei-arm95aad832021-06-25 18:21:33 +02003223 PSA_ASSERT( psa_cipher_update( &operation,
3224 input->x + first_part_size,
3225 input->len - first_part_size,
3226 ( output_buffer_size == 0 ? NULL :
3227 output + total_output_length ),
3228 output_buffer_size - total_output_length,
3229 &function_output_length ) );
3230 TEST_ASSERT( function_output_length == output2_length );
3231 TEST_ASSERT( function_output_length <=
3232 PSA_CIPHER_UPDATE_OUTPUT_SIZE( key_type,
3233 alg,
3234 input->len - first_part_size ) );
3235 TEST_ASSERT( function_output_length <=
3236 PSA_CIPHER_UPDATE_OUTPUT_MAX_SIZE( input->len ) );
3237 total_output_length += function_output_length;
Steven Cooremaned3c9ec2020-07-06 14:08:59 +02003238 }
Gilles Peskine50e586b2018-06-08 14:28:46 +02003239
Gilles Peskine50e586b2018-06-08 14:28:46 +02003240 status = psa_cipher_finish( &operation,
Gilles Peskine0c510f32021-03-24 00:41:51 +01003241 ( output_buffer_size == 0 ? NULL :
3242 output + total_output_length ),
Gilles Peskineee46fe72019-02-19 19:05:33 +01003243 output_buffer_size - total_output_length,
Gilles Peskine50e586b2018-06-08 14:28:46 +02003244 &function_output_length );
gabor-mezei-armceface22021-01-21 12:26:17 +01003245 TEST_ASSERT( function_output_length <=
3246 PSA_CIPHER_FINISH_OUTPUT_SIZE( key_type, alg ) );
3247 TEST_ASSERT( function_output_length <=
3248 PSA_CIPHER_FINISH_OUTPUT_MAX_SIZE );
Gilles Peskinea7ec95f2018-06-08 14:40:59 +02003249 total_output_length += function_output_length;
Gilles Peskinefe11b722018-12-18 00:24:04 +01003250 TEST_EQUAL( status, expected_status );
Gilles Peskine50e586b2018-06-08 14:28:46 +02003251
3252 if( expected_status == PSA_SUCCESS )
3253 {
Gilles Peskine8817f612018-12-18 00:18:46 +01003254 PSA_ASSERT( psa_cipher_abort( &operation ) );
gabor-mezei-arm95aad832021-06-25 18:21:33 +02003255
Gilles Peskinebd7dea92018-09-27 13:57:19 +02003256 ASSERT_COMPARE( expected_output->x, expected_output->len,
3257 output, total_output_length );
Gilles Peskine50e586b2018-06-08 14:28:46 +02003258 }
3259
Gilles Peskine50e586b2018-06-08 14:28:46 +02003260exit:
Gilles Peskine64f13ef2020-08-25 23:15:20 +02003261 psa_cipher_abort( &operation );
itayzafrir3e02b3b2018-06-12 17:06:52 +03003262 mbedtls_free( output );
Ronald Cron5425a212020-08-04 14:58:35 +02003263 psa_destroy_key( key );
Gilles Peskine1153e7b2019-05-28 15:10:21 +02003264 PSA_DONE( );
Gilles Peskine50e586b2018-06-08 14:28:46 +02003265}
3266/* END_CASE */
3267
Gilles Peskine50e586b2018-06-08 14:28:46 +02003268/* BEGIN_CASE */
gabor-mezei-arma56756e2021-06-25 15:49:14 +02003269void cipher_decrypt_fail( int alg_arg,
3270 int key_type_arg,
3271 data_t *key_data,
3272 data_t *iv,
3273 data_t *input_arg,
3274 int expected_status_arg )
gabor-mezei-armf494bcd2021-03-01 15:11:46 +01003275{
3276 mbedtls_svc_key_id_t key = MBEDTLS_SVC_KEY_ID_INIT;
3277 psa_status_t status;
3278 psa_key_type_t key_type = key_type_arg;
3279 psa_algorithm_t alg = alg_arg;
3280 psa_status_t expected_status = expected_status_arg;
3281 unsigned char *input = NULL;
3282 size_t input_buffer_size = 0;
3283 unsigned char *output = NULL;
3284 size_t output_buffer_size = 0;
3285 size_t output_length = 0;
3286 psa_key_attributes_t attributes = PSA_KEY_ATTRIBUTES_INIT;
3287
3288 if ( PSA_ERROR_BAD_STATE != expected_status )
3289 {
3290 PSA_ASSERT( psa_crypto_init( ) );
3291
3292 psa_set_key_usage_flags( &attributes, PSA_KEY_USAGE_DECRYPT );
3293 psa_set_key_algorithm( &attributes, alg );
3294 psa_set_key_type( &attributes, key_type );
3295
3296 PSA_ASSERT( psa_import_key( &attributes, key_data->x, key_data->len,
3297 &key ) );
3298 }
3299
3300 /* Allocate input buffer and copy the iv and the plaintext */
3301 input_buffer_size = ( (size_t) input_arg->len + (size_t) iv->len );
3302 if ( input_buffer_size > 0 )
3303 {
3304 ASSERT_ALLOC( input, input_buffer_size );
3305 memcpy( input, iv->x, iv->len );
3306 memcpy( input + iv->len, input_arg->x, input_arg->len );
3307 }
3308
3309 output_buffer_size = PSA_CIPHER_DECRYPT_OUTPUT_SIZE( key_type, alg, input_buffer_size );
3310 ASSERT_ALLOC( output, output_buffer_size );
3311
3312 status = psa_cipher_decrypt( key, alg, input, input_buffer_size, output,
3313 output_buffer_size, &output_length );
3314 TEST_EQUAL( status, expected_status );
3315
3316exit:
3317 mbedtls_free( input );
3318 mbedtls_free( output );
3319 psa_destroy_key( key );
3320 PSA_DONE( );
3321}
3322/* END_CASE */
3323
3324/* BEGIN_CASE */
3325void cipher_decrypt( int alg_arg,
3326 int key_type_arg,
3327 data_t *key_data,
3328 data_t *iv,
3329 data_t *input_arg,
3330 data_t *expected_output )
3331{
3332 mbedtls_svc_key_id_t key = MBEDTLS_SVC_KEY_ID_INIT;
3333 psa_key_type_t key_type = key_type_arg;
3334 psa_algorithm_t alg = alg_arg;
3335 unsigned char *input = NULL;
3336 size_t input_buffer_size = 0;
3337 unsigned char *output = NULL;
3338 size_t output_buffer_size = 0;
3339 size_t output_length = 0;
3340 psa_key_attributes_t attributes = PSA_KEY_ATTRIBUTES_INIT;
3341
3342 PSA_ASSERT( psa_crypto_init( ) );
3343
3344 psa_set_key_usage_flags( &attributes, PSA_KEY_USAGE_DECRYPT );
3345 psa_set_key_algorithm( &attributes, alg );
3346 psa_set_key_type( &attributes, key_type );
3347
3348 /* Allocate input buffer and copy the iv and the plaintext */
3349 input_buffer_size = ( (size_t) input_arg->len + (size_t) iv->len );
3350 if ( input_buffer_size > 0 )
3351 {
3352 ASSERT_ALLOC( input, input_buffer_size );
3353 memcpy( input, iv->x, iv->len );
3354 memcpy( input + iv->len, input_arg->x, input_arg->len );
3355 }
3356
3357 output_buffer_size = PSA_CIPHER_DECRYPT_OUTPUT_SIZE( key_type, alg, input_buffer_size );
3358 ASSERT_ALLOC( output, output_buffer_size );
3359
3360 PSA_ASSERT( psa_import_key( &attributes, key_data->x, key_data->len,
3361 &key ) );
3362
3363 PSA_ASSERT( psa_cipher_decrypt( key, alg, input, input_buffer_size, output,
3364 output_buffer_size, &output_length ) );
3365 TEST_ASSERT( output_length <=
3366 PSA_CIPHER_DECRYPT_OUTPUT_SIZE( key_type, alg, input_buffer_size ) );
3367 TEST_ASSERT( output_length <=
3368 PSA_CIPHER_DECRYPT_OUTPUT_MAX_SIZE( input_buffer_size ) );
3369
3370 ASSERT_COMPARE( expected_output->x, expected_output->len,
3371 output, output_length );
3372exit:
3373 mbedtls_free( input );
3374 mbedtls_free( output );
3375 psa_destroy_key( key );
3376 PSA_DONE( );
3377}
3378/* END_CASE */
3379
3380/* BEGIN_CASE */
3381void cipher_verify_output( int alg_arg,
3382 int key_type_arg,
Ronald Cron5425a212020-08-04 14:58:35 +02003383 data_t *key_data,
itayzafrir3e02b3b2018-06-12 17:06:52 +03003384 data_t *input )
mohammad1603d7d7ba52018-03-12 18:51:53 +02003385{
Ronald Cron5425a212020-08-04 14:58:35 +02003386 mbedtls_svc_key_id_t key = MBEDTLS_SVC_KEY_ID_INIT;
mohammad1603d7d7ba52018-03-12 18:51:53 +02003387 psa_key_type_t key_type = key_type_arg;
3388 psa_algorithm_t alg = alg_arg;
itayzafrir3e02b3b2018-06-12 17:06:52 +03003389 unsigned char *output1 = NULL;
mohammad1603d7d7ba52018-03-12 18:51:53 +02003390 size_t output1_size = 0;
3391 size_t output1_length = 0;
itayzafrir3e02b3b2018-06-12 17:06:52 +03003392 unsigned char *output2 = NULL;
mohammad1603d7d7ba52018-03-12 18:51:53 +02003393 size_t output2_size = 0;
3394 size_t output2_length = 0;
Gilles Peskine2c2cf0e2019-04-19 19:58:20 +02003395 psa_key_attributes_t attributes = PSA_KEY_ATTRIBUTES_INIT;
mohammad1603d7d7ba52018-03-12 18:51:53 +02003396
Gilles Peskine8817f612018-12-18 00:18:46 +01003397 PSA_ASSERT( psa_crypto_init( ) );
mohammad1603d7d7ba52018-03-12 18:51:53 +02003398
Gilles Peskine2c2cf0e2019-04-19 19:58:20 +02003399 psa_set_key_usage_flags( &attributes, PSA_KEY_USAGE_ENCRYPT | PSA_KEY_USAGE_DECRYPT );
3400 psa_set_key_algorithm( &attributes, alg );
3401 psa_set_key_type( &attributes, key_type );
Moran Pekered346952018-07-05 15:22:45 +03003402
Ronald Cron5425a212020-08-04 14:58:35 +02003403 PSA_ASSERT( psa_import_key( &attributes, key_data->x, key_data->len,
3404 &key ) );
gabor-mezei-armceface22021-01-21 12:26:17 +01003405 output1_size = PSA_CIPHER_ENCRYPT_OUTPUT_SIZE( key_type, alg, input->len );
Gilles Peskine8cebbba2018-09-27 13:54:18 +02003406 ASSERT_ALLOC( output1, output1_size );
Moran Pekerded84402018-06-06 16:36:50 +03003407
gabor-mezei-armf494bcd2021-03-01 15:11:46 +01003408 PSA_ASSERT( psa_cipher_encrypt( key, alg, input->x, input->len,
3409 output1, output1_size,
3410 &output1_length ) );
gabor-mezei-armceface22021-01-21 12:26:17 +01003411 TEST_ASSERT( output1_length <=
gabor-mezei-armf494bcd2021-03-01 15:11:46 +01003412 PSA_CIPHER_ENCRYPT_OUTPUT_SIZE( key_type, alg, input->len ) );
gabor-mezei-armceface22021-01-21 12:26:17 +01003413 TEST_ASSERT( output1_length <=
gabor-mezei-armf494bcd2021-03-01 15:11:46 +01003414 PSA_CIPHER_ENCRYPT_OUTPUT_MAX_SIZE( input->len ) );
Moran Pekerded84402018-06-06 16:36:50 +03003415
3416 output2_size = output1_length;
Gilles Peskine8cebbba2018-09-27 13:54:18 +02003417 ASSERT_ALLOC( output2, output2_size );
Moran Pekerded84402018-06-06 16:36:50 +03003418
gabor-mezei-armf494bcd2021-03-01 15:11:46 +01003419 PSA_ASSERT( psa_cipher_decrypt( key, alg, output1, output1_length,
3420 output2, output2_size,
3421 &output2_length ) );
gabor-mezei-armceface22021-01-21 12:26:17 +01003422 TEST_ASSERT( output2_length <=
gabor-mezei-armf494bcd2021-03-01 15:11:46 +01003423 PSA_CIPHER_DECRYPT_OUTPUT_SIZE( key_type, alg, output1_length ) );
gabor-mezei-armceface22021-01-21 12:26:17 +01003424 TEST_ASSERT( output2_length <=
gabor-mezei-armf494bcd2021-03-01 15:11:46 +01003425 PSA_CIPHER_DECRYPT_OUTPUT_MAX_SIZE( output1_length ) );
Moran Pekerded84402018-06-06 16:36:50 +03003426
Gilles Peskinebd7dea92018-09-27 13:57:19 +02003427 ASSERT_COMPARE( input->x, input->len, output2, output2_length );
Moran Pekerded84402018-06-06 16:36:50 +03003428
3429exit:
itayzafrir3e02b3b2018-06-12 17:06:52 +03003430 mbedtls_free( output1 );
3431 mbedtls_free( output2 );
Ronald Cron5425a212020-08-04 14:58:35 +02003432 psa_destroy_key( key );
Gilles Peskine1153e7b2019-05-28 15:10:21 +02003433 PSA_DONE( );
Moran Pekerded84402018-06-06 16:36:50 +03003434}
3435/* END_CASE */
3436
3437/* BEGIN_CASE */
Gilles Peskine50e586b2018-06-08 14:28:46 +02003438void cipher_verify_output_multipart( int alg_arg,
3439 int key_type_arg,
Ronald Cron5425a212020-08-04 14:58:35 +02003440 data_t *key_data,
itayzafrir3e02b3b2018-06-12 17:06:52 +03003441 data_t *input,
Gilles Peskinee0866522019-02-19 19:44:00 +01003442 int first_part_size_arg )
Moran Pekerded84402018-06-06 16:36:50 +03003443{
Ronald Cron5425a212020-08-04 14:58:35 +02003444 mbedtls_svc_key_id_t key = MBEDTLS_SVC_KEY_ID_INIT;
Moran Pekerded84402018-06-06 16:36:50 +03003445 psa_key_type_t key_type = key_type_arg;
3446 psa_algorithm_t alg = alg_arg;
Gilles Peskinee0866522019-02-19 19:44:00 +01003447 size_t first_part_size = first_part_size_arg;
Moran Pekerded84402018-06-06 16:36:50 +03003448 unsigned char iv[16] = {0};
3449 size_t iv_size = 16;
3450 size_t iv_length = 0;
itayzafrir3e02b3b2018-06-12 17:06:52 +03003451 unsigned char *output1 = NULL;
Gilles Peskine048b7f02018-06-08 14:20:49 +02003452 size_t output1_buffer_size = 0;
Moran Pekerded84402018-06-06 16:36:50 +03003453 size_t output1_length = 0;
itayzafrir3e02b3b2018-06-12 17:06:52 +03003454 unsigned char *output2 = NULL;
Gilles Peskine048b7f02018-06-08 14:20:49 +02003455 size_t output2_buffer_size = 0;
Moran Pekerded84402018-06-06 16:36:50 +03003456 size_t output2_length = 0;
Gilles Peskine048b7f02018-06-08 14:20:49 +02003457 size_t function_output_length;
Jaeden Amero5bae2272019-01-04 11:48:27 +00003458 psa_cipher_operation_t operation1 = PSA_CIPHER_OPERATION_INIT;
3459 psa_cipher_operation_t operation2 = PSA_CIPHER_OPERATION_INIT;
Gilles Peskine2c2cf0e2019-04-19 19:58:20 +02003460 psa_key_attributes_t attributes = PSA_KEY_ATTRIBUTES_INIT;
Moran Pekerded84402018-06-06 16:36:50 +03003461
Gilles Peskine8817f612018-12-18 00:18:46 +01003462 PSA_ASSERT( psa_crypto_init( ) );
Moran Pekerded84402018-06-06 16:36:50 +03003463
Gilles Peskine2c2cf0e2019-04-19 19:58:20 +02003464 psa_set_key_usage_flags( &attributes, PSA_KEY_USAGE_ENCRYPT | PSA_KEY_USAGE_DECRYPT );
3465 psa_set_key_algorithm( &attributes, alg );
3466 psa_set_key_type( &attributes, key_type );
Moran Pekered346952018-07-05 15:22:45 +03003467
Ronald Cron5425a212020-08-04 14:58:35 +02003468 PSA_ASSERT( psa_import_key( &attributes, key_data->x, key_data->len,
3469 &key ) );
Moran Pekerded84402018-06-06 16:36:50 +03003470
Ronald Cron5425a212020-08-04 14:58:35 +02003471 PSA_ASSERT( psa_cipher_encrypt_setup( &operation1, key, alg ) );
3472 PSA_ASSERT( psa_cipher_decrypt_setup( &operation2, key, alg ) );
Moran Pekerded84402018-06-06 16:36:50 +03003473
Steven Cooreman177deba2020-09-07 17:14:14 +02003474 if( alg != PSA_ALG_ECB_NO_PADDING )
3475 {
Steven Cooremana6033e92020-08-25 11:47:50 +02003476 PSA_ASSERT( psa_cipher_generate_iv( &operation1,
3477 iv, iv_size,
3478 &iv_length ) );
Steven Cooremaned3c9ec2020-07-06 14:08:59 +02003479 }
3480
gabor-mezei-armceface22021-01-21 12:26:17 +01003481 output1_buffer_size = PSA_CIPHER_ENCRYPT_OUTPUT_SIZE( key_type, alg, input->len );
3482 TEST_ASSERT( output1_buffer_size <=
3483 PSA_CIPHER_ENCRYPT_OUTPUT_MAX_SIZE( input->len ) );
Gilles Peskine8cebbba2018-09-27 13:54:18 +02003484 ASSERT_ALLOC( output1, output1_buffer_size );
Moran Pekerded84402018-06-06 16:36:50 +03003485
Gilles Peskinee0866522019-02-19 19:44:00 +01003486 TEST_ASSERT( first_part_size <= input->len );
Gilles Peskine4ca9c3f2018-06-06 18:44:09 +02003487
Gilles Peskine8817f612018-12-18 00:18:46 +01003488 PSA_ASSERT( psa_cipher_update( &operation1, input->x, first_part_size,
3489 output1, output1_buffer_size,
3490 &function_output_length ) );
gabor-mezei-armceface22021-01-21 12:26:17 +01003491 TEST_ASSERT( function_output_length <=
3492 PSA_CIPHER_UPDATE_OUTPUT_SIZE( key_type, alg, first_part_size ) );
3493 TEST_ASSERT( function_output_length <=
3494 PSA_CIPHER_UPDATE_OUTPUT_MAX_SIZE( first_part_size ) );
Gilles Peskine048b7f02018-06-08 14:20:49 +02003495 output1_length += function_output_length;
Moran Pekerded84402018-06-06 16:36:50 +03003496
Gilles Peskine8817f612018-12-18 00:18:46 +01003497 PSA_ASSERT( psa_cipher_update( &operation1,
3498 input->x + first_part_size,
3499 input->len - first_part_size,
3500 output1, output1_buffer_size,
3501 &function_output_length ) );
gabor-mezei-armceface22021-01-21 12:26:17 +01003502 TEST_ASSERT( function_output_length <=
3503 PSA_CIPHER_UPDATE_OUTPUT_SIZE( key_type,
3504 alg,
3505 input->len - first_part_size ) );
3506 TEST_ASSERT( function_output_length <=
3507 PSA_CIPHER_UPDATE_OUTPUT_MAX_SIZE( input->len - first_part_size ) );
Gilles Peskine048b7f02018-06-08 14:20:49 +02003508 output1_length += function_output_length;
Moran Pekerded84402018-06-06 16:36:50 +03003509
Gilles Peskine8817f612018-12-18 00:18:46 +01003510 PSA_ASSERT( psa_cipher_finish( &operation1,
3511 output1 + output1_length,
3512 output1_buffer_size - output1_length,
3513 &function_output_length ) );
gabor-mezei-armceface22021-01-21 12:26:17 +01003514 TEST_ASSERT( function_output_length <=
3515 PSA_CIPHER_FINISH_OUTPUT_SIZE( key_type, alg ) );
3516 TEST_ASSERT( function_output_length <=
3517 PSA_CIPHER_FINISH_OUTPUT_MAX_SIZE );
Gilles Peskine048b7f02018-06-08 14:20:49 +02003518 output1_length += function_output_length;
mohammad1603d7d7ba52018-03-12 18:51:53 +02003519
Gilles Peskine8817f612018-12-18 00:18:46 +01003520 PSA_ASSERT( psa_cipher_abort( &operation1 ) );
mohammad1603d7d7ba52018-03-12 18:51:53 +02003521
Gilles Peskine048b7f02018-06-08 14:20:49 +02003522 output2_buffer_size = output1_length;
gabor-mezei-armceface22021-01-21 12:26:17 +01003523 TEST_ASSERT( output2_buffer_size <=
3524 PSA_CIPHER_DECRYPT_OUTPUT_SIZE( key_type, alg, output1_length ) );
3525 TEST_ASSERT( output2_buffer_size <=
3526 PSA_CIPHER_DECRYPT_OUTPUT_MAX_SIZE( output1_length ) );
Gilles Peskine8cebbba2018-09-27 13:54:18 +02003527 ASSERT_ALLOC( output2, output2_buffer_size );
mohammad1603d7d7ba52018-03-12 18:51:53 +02003528
Steven Cooreman177deba2020-09-07 17:14:14 +02003529 if( iv_length > 0 )
3530 {
Steven Cooremana6033e92020-08-25 11:47:50 +02003531 PSA_ASSERT( psa_cipher_set_iv( &operation2,
3532 iv, iv_length ) );
Steven Cooremaned3c9ec2020-07-06 14:08:59 +02003533 }
Moran Pekerded84402018-06-06 16:36:50 +03003534
Gilles Peskine8817f612018-12-18 00:18:46 +01003535 PSA_ASSERT( psa_cipher_update( &operation2, output1, first_part_size,
3536 output2, output2_buffer_size,
3537 &function_output_length ) );
gabor-mezei-armceface22021-01-21 12:26:17 +01003538 TEST_ASSERT( function_output_length <=
3539 PSA_CIPHER_UPDATE_OUTPUT_SIZE( key_type, alg, first_part_size ) );
3540 TEST_ASSERT( function_output_length <=
3541 PSA_CIPHER_UPDATE_OUTPUT_MAX_SIZE( first_part_size ) );
Gilles Peskine048b7f02018-06-08 14:20:49 +02003542 output2_length += function_output_length;
Moran Pekerded84402018-06-06 16:36:50 +03003543
Gilles Peskine8817f612018-12-18 00:18:46 +01003544 PSA_ASSERT( psa_cipher_update( &operation2,
3545 output1 + first_part_size,
3546 output1_length - first_part_size,
3547 output2, output2_buffer_size,
3548 &function_output_length ) );
gabor-mezei-armceface22021-01-21 12:26:17 +01003549 TEST_ASSERT( function_output_length <=
3550 PSA_CIPHER_UPDATE_OUTPUT_SIZE( key_type,
3551 alg,
3552 output1_length - first_part_size ) );
3553 TEST_ASSERT( function_output_length <=
3554 PSA_CIPHER_UPDATE_OUTPUT_MAX_SIZE( output1_length - first_part_size ) );
Gilles Peskine048b7f02018-06-08 14:20:49 +02003555 output2_length += function_output_length;
Moran Pekerded84402018-06-06 16:36:50 +03003556
Gilles Peskine8817f612018-12-18 00:18:46 +01003557 PSA_ASSERT( psa_cipher_finish( &operation2,
3558 output2 + output2_length,
3559 output2_buffer_size - output2_length,
3560 &function_output_length ) );
gabor-mezei-armceface22021-01-21 12:26:17 +01003561 TEST_ASSERT( function_output_length <=
3562 PSA_CIPHER_FINISH_OUTPUT_SIZE( key_type, alg ) );
3563 TEST_ASSERT( function_output_length <=
3564 PSA_CIPHER_FINISH_OUTPUT_MAX_SIZE );
Gilles Peskine048b7f02018-06-08 14:20:49 +02003565 output2_length += function_output_length;
Gilles Peskine4ca9c3f2018-06-06 18:44:09 +02003566
Gilles Peskine8817f612018-12-18 00:18:46 +01003567 PSA_ASSERT( psa_cipher_abort( &operation2 ) );
mohammad1603d7d7ba52018-03-12 18:51:53 +02003568
Gilles Peskinebd7dea92018-09-27 13:57:19 +02003569 ASSERT_COMPARE( input->x, input->len, output2, output2_length );
mohammad1603d7d7ba52018-03-12 18:51:53 +02003570
3571exit:
Gilles Peskine64f13ef2020-08-25 23:15:20 +02003572 psa_cipher_abort( &operation1 );
3573 psa_cipher_abort( &operation2 );
itayzafrir3e02b3b2018-06-12 17:06:52 +03003574 mbedtls_free( output1 );
3575 mbedtls_free( output2 );
Ronald Cron5425a212020-08-04 14:58:35 +02003576 psa_destroy_key( key );
Gilles Peskine1153e7b2019-05-28 15:10:21 +02003577 PSA_DONE( );
mohammad1603d7d7ba52018-03-12 18:51:53 +02003578}
3579/* END_CASE */
Gilles Peskine7268afc2018-06-06 15:19:24 +02003580
Gilles Peskine20035e32018-02-03 22:44:14 +01003581/* BEGIN_CASE */
Gilles Peskine7da96b02018-08-17 18:45:42 +02003582void aead_encrypt_decrypt( int key_type_arg, data_t *key_data,
Gilles Peskinec1bb6c82018-06-18 16:04:39 +02003583 int alg_arg,
Gilles Peskine7da96b02018-08-17 18:45:42 +02003584 data_t *nonce,
3585 data_t *additional_data,
3586 data_t *input_data,
Gilles Peskinec1bb6c82018-06-18 16:04:39 +02003587 int expected_result_arg )
Gilles Peskinea1cac842018-06-11 19:33:02 +02003588{
Ronald Cron5425a212020-08-04 14:58:35 +02003589 mbedtls_svc_key_id_t key = MBEDTLS_SVC_KEY_ID_INIT;
Gilles Peskinea1cac842018-06-11 19:33:02 +02003590 psa_key_type_t key_type = key_type_arg;
3591 psa_algorithm_t alg = alg_arg;
Bence Szépkútiec174e22021-03-19 18:46:15 +01003592 size_t key_bits;
Gilles Peskinea1cac842018-06-11 19:33:02 +02003593 unsigned char *output_data = NULL;
3594 size_t output_size = 0;
3595 size_t output_length = 0;
3596 unsigned char *output_data2 = NULL;
3597 size_t output_length2 = 0;
Steven Cooremanf49478b2021-02-15 15:19:25 +01003598 psa_status_t status = PSA_ERROR_GENERIC_ERROR;
Gilles Peskine4abf7412018-06-18 16:35:34 +02003599 psa_status_t expected_result = expected_result_arg;
Gilles Peskine2c2cf0e2019-04-19 19:58:20 +02003600 psa_key_attributes_t attributes = PSA_KEY_ATTRIBUTES_INIT;
Gilles Peskinea1cac842018-06-11 19:33:02 +02003601
Gilles Peskine8817f612018-12-18 00:18:46 +01003602 PSA_ASSERT( psa_crypto_init( ) );
Gilles Peskinea1cac842018-06-11 19:33:02 +02003603
Gilles Peskine2c2cf0e2019-04-19 19:58:20 +02003604 psa_set_key_usage_flags( &attributes, PSA_KEY_USAGE_ENCRYPT | PSA_KEY_USAGE_DECRYPT );
3605 psa_set_key_algorithm( &attributes, alg );
3606 psa_set_key_type( &attributes, key_type );
Gilles Peskinea1cac842018-06-11 19:33:02 +02003607
Gilles Peskine049c7532019-05-15 20:22:09 +02003608 PSA_ASSERT( psa_import_key( &attributes, key_data->x, key_data->len,
Ronald Cron5425a212020-08-04 14:58:35 +02003609 &key ) );
Bence Szépkútiec174e22021-03-19 18:46:15 +01003610 PSA_ASSERT( psa_get_key_attributes( key, &attributes ) );
3611 key_bits = psa_get_key_bits( &attributes );
3612
3613 output_size = input_data->len + PSA_AEAD_TAG_LENGTH( key_type, key_bits,
3614 alg );
3615 /* For all currently defined algorithms, PSA_AEAD_ENCRYPT_OUTPUT_SIZE
3616 * should be exact. */
3617 if( expected_result != PSA_ERROR_INVALID_ARGUMENT &&
3618 expected_result != PSA_ERROR_NOT_SUPPORTED )
3619 {
3620 TEST_EQUAL( output_size,
3621 PSA_AEAD_ENCRYPT_OUTPUT_SIZE( key_type, alg, input_data->len ) );
3622 TEST_ASSERT( output_size <=
3623 PSA_AEAD_ENCRYPT_OUTPUT_MAX_SIZE( input_data->len ) );
3624 }
3625 ASSERT_ALLOC( output_data, output_size );
Gilles Peskinea1cac842018-06-11 19:33:02 +02003626
Steven Cooremanf49478b2021-02-15 15:19:25 +01003627 status = psa_aead_encrypt( key, alg,
3628 nonce->x, nonce->len,
3629 additional_data->x,
3630 additional_data->len,
3631 input_data->x, input_data->len,
3632 output_data, output_size,
3633 &output_length );
3634
3635 /* If the operation is not supported, just skip and not fail in case the
3636 * encryption involves a common limitation of cryptography hardwares and
3637 * an alternative implementation. */
3638 if( status == PSA_ERROR_NOT_SUPPORTED )
3639 {
3640 MBEDTLS_TEST_PSA_SKIP_IF_ALT_AES_192( key_type, key_data->len * 8 );
3641 MBEDTLS_TEST_PSA_SKIP_IF_ALT_GCM_NOT_12BYTES_NONCE( alg, nonce->len );
3642 }
3643
3644 TEST_EQUAL( status, expected_result );
Gilles Peskinea1cac842018-06-11 19:33:02 +02003645
3646 if( PSA_SUCCESS == expected_result )
3647 {
Gilles Peskine8cebbba2018-09-27 13:54:18 +02003648 ASSERT_ALLOC( output_data2, output_length );
Gilles Peskinea1cac842018-06-11 19:33:02 +02003649
Gilles Peskine003a4a92019-05-14 16:09:40 +02003650 /* For all currently defined algorithms, PSA_AEAD_DECRYPT_OUTPUT_SIZE
3651 * should be exact. */
3652 TEST_EQUAL( input_data->len,
Bence Szépkútiec174e22021-03-19 18:46:15 +01003653 PSA_AEAD_DECRYPT_OUTPUT_SIZE( key_type, alg, output_length ) );
Gilles Peskine003a4a92019-05-14 16:09:40 +02003654
gabor-mezei-armceface22021-01-21 12:26:17 +01003655 TEST_ASSERT( input_data->len <=
3656 PSA_AEAD_DECRYPT_OUTPUT_MAX_SIZE( output_length ) );
3657
Ronald Cron5425a212020-08-04 14:58:35 +02003658 TEST_EQUAL( psa_aead_decrypt( key, alg,
Gilles Peskinefe11b722018-12-18 00:24:04 +01003659 nonce->x, nonce->len,
3660 additional_data->x,
3661 additional_data->len,
3662 output_data, output_length,
3663 output_data2, output_length,
Gilles Peskinef812dcf2018-12-18 00:33:25 +01003664 &output_length2 ),
3665 expected_result );
Gilles Peskine2d277862018-06-18 15:41:12 +02003666
Gilles Peskinebd7dea92018-09-27 13:57:19 +02003667 ASSERT_COMPARE( input_data->x, input_data->len,
3668 output_data2, output_length2 );
Gilles Peskinea1cac842018-06-11 19:33:02 +02003669 }
Gilles Peskine2d277862018-06-18 15:41:12 +02003670
Gilles Peskinea1cac842018-06-11 19:33:02 +02003671exit:
Ronald Cron5425a212020-08-04 14:58:35 +02003672 psa_destroy_key( key );
Gilles Peskinea1cac842018-06-11 19:33:02 +02003673 mbedtls_free( output_data );
3674 mbedtls_free( output_data2 );
Gilles Peskine1153e7b2019-05-28 15:10:21 +02003675 PSA_DONE( );
Gilles Peskinea1cac842018-06-11 19:33:02 +02003676}
3677/* END_CASE */
3678
3679/* BEGIN_CASE */
Gilles Peskine7da96b02018-08-17 18:45:42 +02003680void aead_encrypt( int key_type_arg, data_t *key_data,
3681 int alg_arg,
3682 data_t *nonce,
3683 data_t *additional_data,
3684 data_t *input_data,
3685 data_t *expected_result )
Gilles Peskinea1cac842018-06-11 19:33:02 +02003686{
Ronald Cron5425a212020-08-04 14:58:35 +02003687 mbedtls_svc_key_id_t key = MBEDTLS_SVC_KEY_ID_INIT;
Gilles Peskinea1cac842018-06-11 19:33:02 +02003688 psa_key_type_t key_type = key_type_arg;
3689 psa_algorithm_t alg = alg_arg;
Bence Szépkútiec174e22021-03-19 18:46:15 +01003690 size_t key_bits;
Gilles Peskinea1cac842018-06-11 19:33:02 +02003691 unsigned char *output_data = NULL;
3692 size_t output_size = 0;
3693 size_t output_length = 0;
Gilles Peskine2c2cf0e2019-04-19 19:58:20 +02003694 psa_key_attributes_t attributes = PSA_KEY_ATTRIBUTES_INIT;
Steven Cooremand588ea12021-01-11 19:36:04 +01003695 psa_status_t status = PSA_ERROR_GENERIC_ERROR;
Gilles Peskinea1cac842018-06-11 19:33:02 +02003696
Gilles Peskine8817f612018-12-18 00:18:46 +01003697 PSA_ASSERT( psa_crypto_init( ) );
Gilles Peskinea1cac842018-06-11 19:33:02 +02003698
Gilles Peskine2c2cf0e2019-04-19 19:58:20 +02003699 psa_set_key_usage_flags( &attributes, PSA_KEY_USAGE_ENCRYPT );
3700 psa_set_key_algorithm( &attributes, alg );
3701 psa_set_key_type( &attributes, key_type );
Gilles Peskinea1cac842018-06-11 19:33:02 +02003702
Gilles Peskine049c7532019-05-15 20:22:09 +02003703 PSA_ASSERT( psa_import_key( &attributes, key_data->x, key_data->len,
Ronald Cron5425a212020-08-04 14:58:35 +02003704 &key ) );
Bence Szépkútiec174e22021-03-19 18:46:15 +01003705 PSA_ASSERT( psa_get_key_attributes( key, &attributes ) );
3706 key_bits = psa_get_key_bits( &attributes );
3707
3708 output_size = input_data->len + PSA_AEAD_TAG_LENGTH( key_type, key_bits,
3709 alg );
3710 /* For all currently defined algorithms, PSA_AEAD_ENCRYPT_OUTPUT_SIZE
3711 * should be exact. */
3712 TEST_EQUAL( output_size,
3713 PSA_AEAD_ENCRYPT_OUTPUT_SIZE( key_type, alg, input_data->len ) );
3714 TEST_ASSERT( output_size <=
3715 PSA_AEAD_ENCRYPT_OUTPUT_MAX_SIZE( input_data->len ) );
3716 ASSERT_ALLOC( output_data, output_size );
Gilles Peskinea1cac842018-06-11 19:33:02 +02003717
Steven Cooremand588ea12021-01-11 19:36:04 +01003718 status = psa_aead_encrypt( key, alg,
3719 nonce->x, nonce->len,
3720 additional_data->x, additional_data->len,
3721 input_data->x, input_data->len,
3722 output_data, output_size,
3723 &output_length );
Gilles Peskinea1cac842018-06-11 19:33:02 +02003724
Ronald Cron28a45ed2021-02-09 20:35:42 +01003725 /* If the operation is not supported, just skip and not fail in case the
3726 * encryption involves a common limitation of cryptography hardwares and
3727 * an alternative implementation. */
3728 if( status == PSA_ERROR_NOT_SUPPORTED )
Steven Cooremand588ea12021-01-11 19:36:04 +01003729 {
Ronald Cron28a45ed2021-02-09 20:35:42 +01003730 MBEDTLS_TEST_PSA_SKIP_IF_ALT_AES_192( key_type, key_data->len * 8 );
3731 MBEDTLS_TEST_PSA_SKIP_IF_ALT_GCM_NOT_12BYTES_NONCE( alg, nonce->len );
Steven Cooremand588ea12021-01-11 19:36:04 +01003732 }
Steven Cooremand588ea12021-01-11 19:36:04 +01003733
3734 PSA_ASSERT( status );
Gilles Peskinebd7dea92018-09-27 13:57:19 +02003735 ASSERT_COMPARE( expected_result->x, expected_result->len,
3736 output_data, output_length );
Gilles Peskine2d277862018-06-18 15:41:12 +02003737
Gilles Peskinea1cac842018-06-11 19:33:02 +02003738exit:
Ronald Cron5425a212020-08-04 14:58:35 +02003739 psa_destroy_key( key );
Gilles Peskinea1cac842018-06-11 19:33:02 +02003740 mbedtls_free( output_data );
Gilles Peskine1153e7b2019-05-28 15:10:21 +02003741 PSA_DONE( );
Gilles Peskinea1cac842018-06-11 19:33:02 +02003742}
3743/* END_CASE */
3744
3745/* BEGIN_CASE */
Gilles Peskine7da96b02018-08-17 18:45:42 +02003746void aead_decrypt( int key_type_arg, data_t *key_data,
3747 int alg_arg,
3748 data_t *nonce,
3749 data_t *additional_data,
3750 data_t *input_data,
3751 data_t *expected_data,
3752 int expected_result_arg )
Gilles Peskinea1cac842018-06-11 19:33:02 +02003753{
Ronald Cron5425a212020-08-04 14:58:35 +02003754 mbedtls_svc_key_id_t key = MBEDTLS_SVC_KEY_ID_INIT;
Gilles Peskinea1cac842018-06-11 19:33:02 +02003755 psa_key_type_t key_type = key_type_arg;
3756 psa_algorithm_t alg = alg_arg;
Bence Szépkútiec174e22021-03-19 18:46:15 +01003757 size_t key_bits;
Gilles Peskinea1cac842018-06-11 19:33:02 +02003758 unsigned char *output_data = NULL;
3759 size_t output_size = 0;
3760 size_t output_length = 0;
Gilles Peskine2c2cf0e2019-04-19 19:58:20 +02003761 psa_key_attributes_t attributes = PSA_KEY_ATTRIBUTES_INIT;
Gilles Peskine4abf7412018-06-18 16:35:34 +02003762 psa_status_t expected_result = expected_result_arg;
Steven Cooremand588ea12021-01-11 19:36:04 +01003763 psa_status_t status = PSA_ERROR_GENERIC_ERROR;
Gilles Peskinea1cac842018-06-11 19:33:02 +02003764
Gilles Peskine8817f612018-12-18 00:18:46 +01003765 PSA_ASSERT( psa_crypto_init( ) );
Gilles Peskinea1cac842018-06-11 19:33:02 +02003766
Gilles Peskine2c2cf0e2019-04-19 19:58:20 +02003767 psa_set_key_usage_flags( &attributes, PSA_KEY_USAGE_DECRYPT );
3768 psa_set_key_algorithm( &attributes, alg );
3769 psa_set_key_type( &attributes, key_type );
Gilles Peskinea1cac842018-06-11 19:33:02 +02003770
Gilles Peskine049c7532019-05-15 20:22:09 +02003771 PSA_ASSERT( psa_import_key( &attributes, key_data->x, key_data->len,
Ronald Cron5425a212020-08-04 14:58:35 +02003772 &key ) );
Bence Szépkútiec174e22021-03-19 18:46:15 +01003773 PSA_ASSERT( psa_get_key_attributes( key, &attributes ) );
3774 key_bits = psa_get_key_bits( &attributes );
3775
3776 output_size = input_data->len - PSA_AEAD_TAG_LENGTH( key_type, key_bits,
3777 alg );
3778 if( expected_result != PSA_ERROR_INVALID_ARGUMENT &&
3779 expected_result != PSA_ERROR_NOT_SUPPORTED )
3780 {
3781 /* For all currently defined algorithms, PSA_AEAD_DECRYPT_OUTPUT_SIZE
3782 * should be exact. */
3783 TEST_EQUAL( output_size,
3784 PSA_AEAD_DECRYPT_OUTPUT_SIZE( key_type, alg, input_data->len ) );
3785 TEST_ASSERT( output_size <=
3786 PSA_AEAD_DECRYPT_OUTPUT_MAX_SIZE( input_data->len ) );
3787 }
3788 ASSERT_ALLOC( output_data, output_size );
Gilles Peskinea1cac842018-06-11 19:33:02 +02003789
Steven Cooremand588ea12021-01-11 19:36:04 +01003790 status = psa_aead_decrypt( key, alg,
3791 nonce->x, nonce->len,
3792 additional_data->x,
3793 additional_data->len,
3794 input_data->x, input_data->len,
3795 output_data, output_size,
3796 &output_length );
3797
Ronald Cron28a45ed2021-02-09 20:35:42 +01003798 /* If the operation is not supported, just skip and not fail in case the
3799 * decryption involves a common limitation of cryptography hardwares and
3800 * an alternative implementation. */
3801 if( status == PSA_ERROR_NOT_SUPPORTED )
Steven Cooremand588ea12021-01-11 19:36:04 +01003802 {
Ronald Cron28a45ed2021-02-09 20:35:42 +01003803 MBEDTLS_TEST_PSA_SKIP_IF_ALT_AES_192( key_type, key_data->len * 8 );
3804 MBEDTLS_TEST_PSA_SKIP_IF_ALT_GCM_NOT_12BYTES_NONCE( alg, nonce->len );
Steven Cooremand588ea12021-01-11 19:36:04 +01003805 }
Steven Cooremand588ea12021-01-11 19:36:04 +01003806
3807 TEST_EQUAL( status, expected_result );
Gilles Peskinea1cac842018-06-11 19:33:02 +02003808
Gilles Peskine2d277862018-06-18 15:41:12 +02003809 if( expected_result == PSA_SUCCESS )
Gilles Peskinebd7dea92018-09-27 13:57:19 +02003810 ASSERT_COMPARE( expected_data->x, expected_data->len,
3811 output_data, output_length );
Gilles Peskinea1cac842018-06-11 19:33:02 +02003812
Gilles Peskinea1cac842018-06-11 19:33:02 +02003813exit:
Ronald Cron5425a212020-08-04 14:58:35 +02003814 psa_destroy_key( key );
Gilles Peskinea1cac842018-06-11 19:33:02 +02003815 mbedtls_free( output_data );
Gilles Peskine1153e7b2019-05-28 15:10:21 +02003816 PSA_DONE( );
Gilles Peskinea1cac842018-06-11 19:33:02 +02003817}
3818/* END_CASE */
3819
3820/* BEGIN_CASE */
Paul Elliott0023e0a2021-04-27 10:06:22 +01003821void aead_multipart_encrypt( int key_type_arg, data_t *key_data,
3822 int alg_arg,
3823 data_t *nonce,
3824 data_t *additional_data,
Paul Elliott0023e0a2021-04-27 10:06:22 +01003825 data_t *input_data,
Paul Elliott97fd1ba2021-07-21 18:46:06 +01003826 int do_set_lengths,
3827 data_t *expected_output )
Paul Elliott0023e0a2021-04-27 10:06:22 +01003828{
Paul Elliottd3f82412021-06-16 16:52:21 +01003829 size_t ad_part_len = 0;
3830 size_t data_part_len = 0;
Paul Elliottbb979e72021-09-22 12:54:42 +01003831 set_lengths_method_t set_lengths_method = DO_NOT_SET_LENGTHS;
Paul Elliott0023e0a2021-04-27 10:06:22 +01003832
Paul Elliott32f46ba2021-09-23 18:24:36 +01003833 for( ad_part_len = 1; ad_part_len <= additional_data->len; ad_part_len++ )
Paul Elliott0023e0a2021-04-27 10:06:22 +01003834 {
Paul Elliott32f46ba2021-09-23 18:24:36 +01003835 mbedtls_test_set_step( ad_part_len );
3836
3837 if( do_set_lengths )
Paul Elliott0023e0a2021-04-27 10:06:22 +01003838 {
Paul Elliott32f46ba2021-09-23 18:24:36 +01003839 if( ad_part_len & 0x01 )
3840 set_lengths_method = SET_LENGTHS_AFTER_NONCE;
3841 else
3842 set_lengths_method = SET_LENGTHS_BEFORE_NONCE;
Paul Elliott0023e0a2021-04-27 10:06:22 +01003843 }
Paul Elliott32f46ba2021-09-23 18:24:36 +01003844
3845 /* Split ad into length(ad_part_len) parts. */
3846 if( !aead_multipart_internal_func( key_type_arg, key_data,
3847 alg_arg, nonce,
3848 additional_data,
3849 ad_part_len,
3850 input_data, -1,
3851 set_lengths_method,
3852 expected_output,
3853 1, 0 ) )
3854 break;
3855
3856 /* length(0) part, length(ad_part_len) part, length(0) part... */
3857 mbedtls_test_set_step( 1000 + ad_part_len );
3858
3859 if( !aead_multipart_internal_func( key_type_arg, key_data,
3860 alg_arg, nonce,
3861 additional_data,
3862 ad_part_len,
3863 input_data, -1,
3864 set_lengths_method,
3865 expected_output,
3866 1, 1 ) )
3867 break;
Paul Elliott0023e0a2021-04-27 10:06:22 +01003868 }
Paul Elliottd3f82412021-06-16 16:52:21 +01003869
Paul Elliott32f46ba2021-09-23 18:24:36 +01003870 for( data_part_len = 1; data_part_len <= input_data->len; data_part_len++ )
Paul Elliott0023e0a2021-04-27 10:06:22 +01003871 {
Paul Elliott32f46ba2021-09-23 18:24:36 +01003872 /* Split data into length(data_part_len) parts. */
3873 mbedtls_test_set_step( 2000 + data_part_len );
3874
3875 if( do_set_lengths )
Paul Elliott0023e0a2021-04-27 10:06:22 +01003876 {
Paul Elliott32f46ba2021-09-23 18:24:36 +01003877 if( data_part_len & 0x01 )
3878 set_lengths_method = SET_LENGTHS_AFTER_NONCE;
3879 else
3880 set_lengths_method = SET_LENGTHS_BEFORE_NONCE;
Paul Elliott0023e0a2021-04-27 10:06:22 +01003881 }
Paul Elliott0023e0a2021-04-27 10:06:22 +01003882
Paul Elliott32f46ba2021-09-23 18:24:36 +01003883 if( !aead_multipart_internal_func( key_type_arg, key_data,
3884 alg_arg, nonce,
3885 additional_data, -1,
3886 input_data, data_part_len,
3887 set_lengths_method,
3888 expected_output,
3889 1, 0 ) )
3890 break;
3891
3892 /* length(0) part, length(data_part_len) part, length(0) part... */
3893 mbedtls_test_set_step( 3000 + data_part_len );
3894
3895 if( !aead_multipart_internal_func( key_type_arg, key_data,
3896 alg_arg, nonce,
3897 additional_data, -1,
3898 input_data, data_part_len,
3899 set_lengths_method,
3900 expected_output,
3901 1, 1 ) )
3902 break;
3903 }
Paul Elliott0023e0a2021-04-27 10:06:22 +01003904
Paul Elliott8fc45162021-06-23 16:06:01 +01003905 /* Goto is required to silence warnings about unused labels, as we
3906 * don't actually do any test assertions in this function. */
3907 goto exit;
Paul Elliott0023e0a2021-04-27 10:06:22 +01003908}
3909/* END_CASE */
3910
3911/* BEGIN_CASE */
Paul Elliott0023e0a2021-04-27 10:06:22 +01003912void aead_multipart_decrypt( int key_type_arg, data_t *key_data,
3913 int alg_arg,
3914 data_t *nonce,
3915 data_t *additional_data,
Paul Elliott0023e0a2021-04-27 10:06:22 +01003916 data_t *input_data,
Paul Elliott97fd1ba2021-07-21 18:46:06 +01003917 int do_set_lengths,
Paul Elliott9961a662021-09-17 19:19:02 +01003918 data_t *expected_output )
Paul Elliott0023e0a2021-04-27 10:06:22 +01003919{
Paul Elliottd3f82412021-06-16 16:52:21 +01003920 size_t ad_part_len = 0;
3921 size_t data_part_len = 0;
Paul Elliottbb979e72021-09-22 12:54:42 +01003922 set_lengths_method_t set_lengths_method = DO_NOT_SET_LENGTHS;
Paul Elliott0023e0a2021-04-27 10:06:22 +01003923
Paul Elliott32f46ba2021-09-23 18:24:36 +01003924 for( ad_part_len = 1; ad_part_len <= additional_data->len; ad_part_len++ )
Paul Elliott0023e0a2021-04-27 10:06:22 +01003925 {
Paul Elliott32f46ba2021-09-23 18:24:36 +01003926 /* Split ad into length(ad_part_len) parts. */
3927 mbedtls_test_set_step( ad_part_len );
3928
3929 if( do_set_lengths )
Paul Elliott0023e0a2021-04-27 10:06:22 +01003930 {
Paul Elliott32f46ba2021-09-23 18:24:36 +01003931 if( ad_part_len & 0x01 )
3932 set_lengths_method = SET_LENGTHS_AFTER_NONCE;
3933 else
3934 set_lengths_method = SET_LENGTHS_BEFORE_NONCE;
Paul Elliott0023e0a2021-04-27 10:06:22 +01003935 }
Paul Elliott32f46ba2021-09-23 18:24:36 +01003936
3937 if( !aead_multipart_internal_func( key_type_arg, key_data,
3938 alg_arg, nonce,
3939 additional_data,
3940 ad_part_len,
3941 input_data, -1,
3942 set_lengths_method,
3943 expected_output,
3944 0, 0 ) )
3945 break;
3946
3947 /* length(0) part, length(ad_part_len) part, length(0) part... */
3948 mbedtls_test_set_step( 1000 + ad_part_len );
3949
3950 if( !aead_multipart_internal_func( key_type_arg, key_data,
3951 alg_arg, nonce,
3952 additional_data,
3953 ad_part_len,
3954 input_data, -1,
3955 set_lengths_method,
3956 expected_output,
3957 0, 1 ) )
3958 break;
Paul Elliott0023e0a2021-04-27 10:06:22 +01003959 }
3960
Paul Elliott32f46ba2021-09-23 18:24:36 +01003961 for( data_part_len = 1; data_part_len <= input_data->len; data_part_len++ )
Paul Elliott0023e0a2021-04-27 10:06:22 +01003962 {
Paul Elliott32f46ba2021-09-23 18:24:36 +01003963 /* Split data into length(data_part_len) parts. */
3964 mbedtls_test_set_step( 2000 + data_part_len );
3965
3966 if( do_set_lengths )
Paul Elliott0023e0a2021-04-27 10:06:22 +01003967 {
Paul Elliott32f46ba2021-09-23 18:24:36 +01003968 if( data_part_len & 0x01 )
3969 set_lengths_method = SET_LENGTHS_AFTER_NONCE;
3970 else
3971 set_lengths_method = SET_LENGTHS_BEFORE_NONCE;
Paul Elliott0023e0a2021-04-27 10:06:22 +01003972 }
Paul Elliott32f46ba2021-09-23 18:24:36 +01003973
3974 if( !aead_multipart_internal_func( key_type_arg, key_data,
3975 alg_arg, nonce,
3976 additional_data, -1,
3977 input_data, data_part_len,
3978 set_lengths_method,
3979 expected_output,
3980 0, 0 ) )
3981 break;
3982
3983 /* length(0) part, length(data_part_len) part, length(0) part... */
3984 mbedtls_test_set_step( 3000 + data_part_len );
3985
3986 if( !aead_multipart_internal_func( key_type_arg, key_data,
3987 alg_arg, nonce,
3988 additional_data, -1,
3989 input_data, data_part_len,
3990 set_lengths_method,
3991 expected_output,
3992 0, 1 ) )
3993 break;
Paul Elliott0023e0a2021-04-27 10:06:22 +01003994 }
3995
Paul Elliott8fc45162021-06-23 16:06:01 +01003996 /* Goto is required to silence warnings about unused labels, as we
3997 * don't actually do any test assertions in this function. */
Paul Elliottd3f82412021-06-16 16:52:21 +01003998 goto exit;
Paul Elliott0023e0a2021-04-27 10:06:22 +01003999}
4000/* END_CASE */
4001
4002/* BEGIN_CASE */
Paul Elliott8eb9daf2021-06-04 16:42:21 +01004003void aead_multipart_generate_nonce( int key_type_arg, data_t *key_data,
4004 int alg_arg,
Paul Elliottf1277632021-08-24 18:11:37 +01004005 int nonce_length,
4006 int expected_nonce_length_arg,
Paul Elliott3bd5dba2021-06-23 17:14:40 +01004007 data_t *additional_data,
4008 data_t *input_data,
4009 int expected_status_arg )
Paul Elliott8eb9daf2021-06-04 16:42:21 +01004010{
4011
4012 mbedtls_svc_key_id_t key = MBEDTLS_SVC_KEY_ID_INIT;
4013 psa_key_type_t key_type = key_type_arg;
4014 psa_algorithm_t alg = alg_arg;
Paul Elliottfbb4c6d2021-09-22 16:44:21 +01004015 psa_aead_operation_t operation = PSA_AEAD_OPERATION_INIT;
Paul Elliott8eb9daf2021-06-04 16:42:21 +01004016 uint8_t nonce_buffer[PSA_AEAD_NONCE_MAX_SIZE];
4017 psa_key_attributes_t attributes = PSA_KEY_ATTRIBUTES_INIT;
4018 psa_status_t status = PSA_ERROR_GENERIC_ERROR;
Paul Elliott693bf312021-07-23 17:40:41 +01004019 psa_status_t expected_status = expected_status_arg;
Paul Elliottf1277632021-08-24 18:11:37 +01004020 size_t actual_nonce_length = 0;
4021 size_t expected_nonce_length = expected_nonce_length_arg;
4022 unsigned char *output = NULL;
4023 unsigned char *ciphertext = NULL;
Paul Elliott3bd5dba2021-06-23 17:14:40 +01004024 size_t output_size = 0;
Paul Elliottf1277632021-08-24 18:11:37 +01004025 size_t ciphertext_size = 0;
4026 size_t ciphertext_length = 0;
Paul Elliott3bd5dba2021-06-23 17:14:40 +01004027 size_t tag_length = 0;
4028 uint8_t tag_buffer[PSA_AEAD_TAG_MAX_SIZE];
Paul Elliott8eb9daf2021-06-04 16:42:21 +01004029
4030 PSA_ASSERT( psa_crypto_init( ) );
4031
4032 psa_set_key_usage_flags( & attributes, PSA_KEY_USAGE_ENCRYPT );
4033 psa_set_key_algorithm( & attributes, alg );
4034 psa_set_key_type( & attributes, key_type );
4035
4036 PSA_ASSERT( psa_import_key( &attributes, key_data->x, key_data->len,
4037 &key ) );
4038
4039 PSA_ASSERT( psa_get_key_attributes( key, &attributes ) );
4040
Paul Elliott3bd5dba2021-06-23 17:14:40 +01004041 output_size = PSA_AEAD_UPDATE_OUTPUT_SIZE( key_type, alg, input_data->len );
4042
Paul Elliottf1277632021-08-24 18:11:37 +01004043 ASSERT_ALLOC( output, output_size );
Paul Elliott3bd5dba2021-06-23 17:14:40 +01004044
Paul Elliottf1277632021-08-24 18:11:37 +01004045 ciphertext_size = PSA_AEAD_FINISH_OUTPUT_SIZE( key_type, alg );
Paul Elliott3bd5dba2021-06-23 17:14:40 +01004046
Paul Elliottf1277632021-08-24 18:11:37 +01004047 TEST_ASSERT( ciphertext_size <= PSA_AEAD_FINISH_OUTPUT_MAX_SIZE );
Paul Elliott3bd5dba2021-06-23 17:14:40 +01004048
Paul Elliottf1277632021-08-24 18:11:37 +01004049 ASSERT_ALLOC( ciphertext, ciphertext_size );
Paul Elliott3bd5dba2021-06-23 17:14:40 +01004050
Paul Elliott8eb9daf2021-06-04 16:42:21 +01004051 status = psa_aead_encrypt_setup( &operation, key, alg );
4052
4053 /* If the operation is not supported, just skip and not fail in case the
4054 * encryption involves a common limitation of cryptography hardwares and
4055 * an alternative implementation. */
4056 if( status == PSA_ERROR_NOT_SUPPORTED )
4057 {
4058 MBEDTLS_TEST_PSA_SKIP_IF_ALT_AES_192( key_type, key_data->len * 8 );
Paul Elliottf1277632021-08-24 18:11:37 +01004059 MBEDTLS_TEST_PSA_SKIP_IF_ALT_GCM_NOT_12BYTES_NONCE( alg, nonce_length );
Paul Elliott8eb9daf2021-06-04 16:42:21 +01004060 }
4061
4062 PSA_ASSERT( status );
4063
Paul Elliott8eb9daf2021-06-04 16:42:21 +01004064 status = psa_aead_generate_nonce( &operation, nonce_buffer,
Paul Elliottf1277632021-08-24 18:11:37 +01004065 nonce_length,
4066 &actual_nonce_length );
Paul Elliott8eb9daf2021-06-04 16:42:21 +01004067
Paul Elliott693bf312021-07-23 17:40:41 +01004068 TEST_EQUAL( status, expected_status );
Paul Elliott3bd5dba2021-06-23 17:14:40 +01004069
Paul Elliottf1277632021-08-24 18:11:37 +01004070 TEST_EQUAL( actual_nonce_length, expected_nonce_length );
Paul Elliottd85f5472021-07-16 18:20:16 +01004071
Paul Elliott88ecbe12021-09-22 17:23:03 +01004072 if( expected_status == PSA_SUCCESS )
4073 TEST_EQUAL( actual_nonce_length, PSA_AEAD_NONCE_LENGTH( key_type,
4074 alg ) );
4075
Paul Elliottf1277632021-08-24 18:11:37 +01004076 TEST_ASSERT( actual_nonce_length < PSA_AEAD_NONCE_MAX_SIZE );
Paul Elliotte0fcb3b2021-07-16 18:52:03 +01004077
Paul Elliott693bf312021-07-23 17:40:41 +01004078 if( expected_status == PSA_SUCCESS )
Paul Elliott3bd5dba2021-06-23 17:14:40 +01004079 {
4080
4081 /* Ensure we can still complete operation. */
4082
4083 PSA_ASSERT( psa_aead_update_ad( &operation, additional_data->x,
4084 additional_data->len ) );
4085
4086 PSA_ASSERT( psa_aead_update( &operation, input_data->x, input_data->len,
Paul Elliottf1277632021-08-24 18:11:37 +01004087 output, output_size,
4088 &ciphertext_length ) );
Paul Elliott3bd5dba2021-06-23 17:14:40 +01004089
Paul Elliottf1277632021-08-24 18:11:37 +01004090 PSA_ASSERT( psa_aead_finish( &operation, ciphertext, ciphertext_size,
4091 &ciphertext_length, tag_buffer,
Paul Elliott3bd5dba2021-06-23 17:14:40 +01004092 PSA_AEAD_TAG_MAX_SIZE, &tag_length ) );
4093 }
Paul Elliott8eb9daf2021-06-04 16:42:21 +01004094
4095exit:
4096 psa_destroy_key( key );
Paul Elliottf1277632021-08-24 18:11:37 +01004097 mbedtls_free( output );
4098 mbedtls_free( ciphertext );
Paul Elliott8eb9daf2021-06-04 16:42:21 +01004099 psa_aead_abort( &operation );
4100 PSA_DONE( );
4101}
4102/* END_CASE */
4103
4104/* BEGIN_CASE */
Paul Elliott863864a2021-07-23 17:28:31 +01004105void aead_multipart_set_nonce( int key_type_arg, data_t *key_data,
4106 int alg_arg,
Paul Elliott4023ffd2021-09-10 16:21:22 +01004107 int nonce_length_arg,
Paul Elliott863864a2021-07-23 17:28:31 +01004108 data_t *additional_data,
4109 data_t *input_data,
4110 int expected_status_arg )
4111{
4112
4113 mbedtls_svc_key_id_t key = MBEDTLS_SVC_KEY_ID_INIT;
4114 psa_key_type_t key_type = key_type_arg;
4115 psa_algorithm_t alg = alg_arg;
Paul Elliottfbb4c6d2021-09-22 16:44:21 +01004116 psa_aead_operation_t operation = PSA_AEAD_OPERATION_INIT;
Paul Elliott863864a2021-07-23 17:28:31 +01004117 uint8_t *nonce_buffer = NULL;
4118 psa_key_attributes_t attributes = PSA_KEY_ATTRIBUTES_INIT;
4119 psa_status_t status = PSA_ERROR_GENERIC_ERROR;
4120 psa_status_t expected_status = expected_status_arg;
Paul Elliott6f0e7202021-08-25 12:57:18 +01004121 unsigned char *output = NULL;
4122 unsigned char *ciphertext = NULL;
Paul Elliott4023ffd2021-09-10 16:21:22 +01004123 size_t nonce_length;
Paul Elliott863864a2021-07-23 17:28:31 +01004124 size_t output_size = 0;
Paul Elliott6f0e7202021-08-25 12:57:18 +01004125 size_t ciphertext_size = 0;
4126 size_t ciphertext_length = 0;
Paul Elliott863864a2021-07-23 17:28:31 +01004127 size_t tag_length = 0;
4128 uint8_t tag_buffer[PSA_AEAD_TAG_MAX_SIZE];
Paul Elliott4023ffd2021-09-10 16:21:22 +01004129 size_t index = 0;
Paul Elliott863864a2021-07-23 17:28:31 +01004130
4131 PSA_ASSERT( psa_crypto_init( ) );
4132
4133 psa_set_key_usage_flags( &attributes, PSA_KEY_USAGE_ENCRYPT );
4134 psa_set_key_algorithm( &attributes, alg );
4135 psa_set_key_type( &attributes, key_type );
4136
4137 PSA_ASSERT( psa_import_key( &attributes, key_data->x, key_data->len,
4138 &key ) );
4139
4140 PSA_ASSERT( psa_get_key_attributes( key, &attributes ) );
4141
4142 output_size = PSA_AEAD_UPDATE_OUTPUT_SIZE( key_type, alg, input_data->len );
4143
Paul Elliott6f0e7202021-08-25 12:57:18 +01004144 ASSERT_ALLOC( output, output_size );
Paul Elliott863864a2021-07-23 17:28:31 +01004145
Paul Elliott6f0e7202021-08-25 12:57:18 +01004146 ciphertext_size = PSA_AEAD_FINISH_OUTPUT_SIZE( key_type, alg );
Paul Elliott863864a2021-07-23 17:28:31 +01004147
Paul Elliott6f0e7202021-08-25 12:57:18 +01004148 TEST_ASSERT( ciphertext_size <= PSA_AEAD_FINISH_OUTPUT_MAX_SIZE );
Paul Elliott863864a2021-07-23 17:28:31 +01004149
Paul Elliott6f0e7202021-08-25 12:57:18 +01004150 ASSERT_ALLOC( ciphertext, ciphertext_size );
Paul Elliott863864a2021-07-23 17:28:31 +01004151
Paul Elliott863864a2021-07-23 17:28:31 +01004152 status = psa_aead_encrypt_setup( &operation, key, alg );
4153
4154 /* If the operation is not supported, just skip and not fail in case the
4155 * encryption involves a common limitation of cryptography hardwares and
4156 * an alternative implementation. */
4157 if( status == PSA_ERROR_NOT_SUPPORTED )
4158 {
4159 MBEDTLS_TEST_PSA_SKIP_IF_ALT_AES_192( key_type, key_data->len * 8 );
Paul Elliott4023ffd2021-09-10 16:21:22 +01004160 MBEDTLS_TEST_PSA_SKIP_IF_ALT_GCM_NOT_12BYTES_NONCE( alg, nonce_length_arg );
Paul Elliott863864a2021-07-23 17:28:31 +01004161 }
4162
4163 PSA_ASSERT( status );
4164
Paul Elliott4023ffd2021-09-10 16:21:22 +01004165 /* -1 == zero length and valid buffer, 0 = zero length and NULL buffer. */
4166 if( nonce_length_arg == -1 )
Paul Elliott863864a2021-07-23 17:28:31 +01004167 {
Paul Elliott5e69aa52021-08-25 17:24:37 +01004168 /* Arbitrary size buffer, to test zero length valid buffer. */
4169 ASSERT_ALLOC( nonce_buffer, 4 );
Paul Elliott4023ffd2021-09-10 16:21:22 +01004170 nonce_length = 0;
Paul Elliott66696b52021-08-16 18:42:41 +01004171 }
4172 else
4173 {
Paul Elliott4023ffd2021-09-10 16:21:22 +01004174 /* If length is zero, then this will return NULL. */
4175 nonce_length = ( size_t ) nonce_length_arg;
Paul Elliott6f0e7202021-08-25 12:57:18 +01004176 ASSERT_ALLOC( nonce_buffer, nonce_length );
Paul Elliott66696b52021-08-16 18:42:41 +01004177
Paul Elliott4023ffd2021-09-10 16:21:22 +01004178 if( nonce_buffer )
Paul Elliott66696b52021-08-16 18:42:41 +01004179 {
Paul Elliott4023ffd2021-09-10 16:21:22 +01004180 for( index = 0; index < nonce_length - 1; ++index )
4181 {
4182 nonce_buffer[index] = 'a' + index;
4183 }
Paul Elliott66696b52021-08-16 18:42:41 +01004184 }
Paul Elliott863864a2021-07-23 17:28:31 +01004185 }
4186
Paul Elliott6f0e7202021-08-25 12:57:18 +01004187 status = psa_aead_set_nonce( &operation, nonce_buffer, nonce_length );
Paul Elliott863864a2021-07-23 17:28:31 +01004188
Paul Elliott693bf312021-07-23 17:40:41 +01004189 TEST_EQUAL( status, expected_status );
Paul Elliott863864a2021-07-23 17:28:31 +01004190
4191 if( expected_status == PSA_SUCCESS )
4192 {
4193 /* Ensure we can still complete operation. */
4194
4195 PSA_ASSERT( psa_aead_update_ad( &operation, additional_data->x,
4196 additional_data->len ) );
4197
4198 PSA_ASSERT( psa_aead_update( &operation, input_data->x, input_data->len,
Paul Elliott6f0e7202021-08-25 12:57:18 +01004199 output, output_size,
4200 &ciphertext_length ) );
Paul Elliott863864a2021-07-23 17:28:31 +01004201
Paul Elliott6f0e7202021-08-25 12:57:18 +01004202 PSA_ASSERT( psa_aead_finish( &operation, ciphertext, ciphertext_size,
4203 &ciphertext_length, tag_buffer,
Paul Elliott863864a2021-07-23 17:28:31 +01004204 PSA_AEAD_TAG_MAX_SIZE, &tag_length ) );
4205 }
4206
4207exit:
4208 psa_destroy_key( key );
Paul Elliott6f0e7202021-08-25 12:57:18 +01004209 mbedtls_free( output );
4210 mbedtls_free( ciphertext );
Paul Elliott863864a2021-07-23 17:28:31 +01004211 mbedtls_free( nonce_buffer );
4212 psa_aead_abort( &operation );
4213 PSA_DONE( );
4214}
4215/* END_CASE */
4216
4217/* BEGIN_CASE */
Paul Elliott43fbda62021-07-23 18:30:59 +01004218void aead_multipart_update_buffer_test( int key_type_arg, data_t *key_data,
4219 int alg_arg,
Paul Elliottc6d11d02021-09-01 12:04:23 +01004220 int output_size_arg,
Paul Elliott43fbda62021-07-23 18:30:59 +01004221 data_t *nonce,
4222 data_t *additional_data,
4223 data_t *input_data,
4224 int expected_status_arg )
4225{
4226
4227 mbedtls_svc_key_id_t key = MBEDTLS_SVC_KEY_ID_INIT;
4228 psa_key_type_t key_type = key_type_arg;
4229 psa_algorithm_t alg = alg_arg;
Paul Elliottfbb4c6d2021-09-22 16:44:21 +01004230 psa_aead_operation_t operation = PSA_AEAD_OPERATION_INIT;
Paul Elliott43fbda62021-07-23 18:30:59 +01004231 psa_key_attributes_t attributes = PSA_KEY_ATTRIBUTES_INIT;
4232 psa_status_t status = PSA_ERROR_GENERIC_ERROR;
4233 psa_status_t expected_status = expected_status_arg;
Paul Elliottc6d11d02021-09-01 12:04:23 +01004234 unsigned char *output = NULL;
4235 unsigned char *ciphertext = NULL;
4236 size_t output_size = output_size_arg;
4237 size_t ciphertext_size = 0;
4238 size_t ciphertext_length = 0;
Paul Elliott43fbda62021-07-23 18:30:59 +01004239 size_t tag_length = 0;
4240 uint8_t tag_buffer[PSA_AEAD_TAG_MAX_SIZE];
4241
4242 PSA_ASSERT( psa_crypto_init( ) );
4243
4244 psa_set_key_usage_flags( &attributes, PSA_KEY_USAGE_ENCRYPT );
4245 psa_set_key_algorithm( &attributes, alg );
4246 psa_set_key_type( &attributes, key_type );
4247
4248 PSA_ASSERT( psa_import_key( &attributes, key_data->x, key_data->len,
4249 &key ) );
4250
4251 PSA_ASSERT( psa_get_key_attributes( key, &attributes ) );
4252
Paul Elliottc6d11d02021-09-01 12:04:23 +01004253 ASSERT_ALLOC( output, output_size );
Paul Elliott43fbda62021-07-23 18:30:59 +01004254
Paul Elliottc6d11d02021-09-01 12:04:23 +01004255 ciphertext_size = PSA_AEAD_FINISH_OUTPUT_SIZE( key_type, alg );
Paul Elliott43fbda62021-07-23 18:30:59 +01004256
Paul Elliottc6d11d02021-09-01 12:04:23 +01004257 ASSERT_ALLOC( ciphertext, ciphertext_size );
Paul Elliott43fbda62021-07-23 18:30:59 +01004258
Paul Elliott43fbda62021-07-23 18:30:59 +01004259 status = psa_aead_encrypt_setup( &operation, key, alg );
4260
4261 /* If the operation is not supported, just skip and not fail in case the
4262 * encryption involves a common limitation of cryptography hardwares and
4263 * an alternative implementation. */
4264 if( status == PSA_ERROR_NOT_SUPPORTED )
4265 {
4266 MBEDTLS_TEST_PSA_SKIP_IF_ALT_AES_192( key_type, key_data->len * 8 );
4267 MBEDTLS_TEST_PSA_SKIP_IF_ALT_GCM_NOT_12BYTES_NONCE( alg, nonce->len );
4268 }
4269
4270 PSA_ASSERT( status );
4271
4272 PSA_ASSERT( psa_aead_set_nonce( &operation, nonce->x, nonce->len ) );
4273
4274 PSA_ASSERT( psa_aead_update_ad( &operation, additional_data->x,
4275 additional_data->len ) );
4276
4277 status = psa_aead_update( &operation, input_data->x, input_data->len,
Paul Elliottc6d11d02021-09-01 12:04:23 +01004278 output, output_size, &ciphertext_length );
Paul Elliott43fbda62021-07-23 18:30:59 +01004279
4280 TEST_EQUAL( status, expected_status );
4281
4282 if( expected_status == PSA_SUCCESS )
4283 {
4284 /* Ensure we can still complete operation. */
Paul Elliottc6d11d02021-09-01 12:04:23 +01004285 PSA_ASSERT( psa_aead_finish( &operation, ciphertext, ciphertext_size,
4286 &ciphertext_length, tag_buffer,
Paul Elliott43fbda62021-07-23 18:30:59 +01004287 PSA_AEAD_TAG_MAX_SIZE, &tag_length ) );
4288 }
4289
4290exit:
4291 psa_destroy_key( key );
Paul Elliottc6d11d02021-09-01 12:04:23 +01004292 mbedtls_free( output );
4293 mbedtls_free( ciphertext );
Paul Elliott43fbda62021-07-23 18:30:59 +01004294 psa_aead_abort( &operation );
4295 PSA_DONE( );
4296}
4297/* END_CASE */
4298
Paul Elliott91b021e2021-07-23 18:52:31 +01004299/* BEGIN_CASE */
4300void aead_multipart_finish_buffer_test( int key_type_arg, data_t *key_data,
4301 int alg_arg,
Paul Elliotte58cb1e2021-09-10 18:36:00 +01004302 int finish_ciphertext_size_arg,
Paul Elliott719c1322021-09-13 18:27:22 +01004303 int tag_size_arg,
Paul Elliott91b021e2021-07-23 18:52:31 +01004304 data_t *nonce,
4305 data_t *additional_data,
4306 data_t *input_data,
4307 int expected_status_arg )
4308{
4309
4310 mbedtls_svc_key_id_t key = MBEDTLS_SVC_KEY_ID_INIT;
4311 psa_key_type_t key_type = key_type_arg;
4312 psa_algorithm_t alg = alg_arg;
Paul Elliottfbb4c6d2021-09-22 16:44:21 +01004313 psa_aead_operation_t operation = PSA_AEAD_OPERATION_INIT;
Paul Elliott91b021e2021-07-23 18:52:31 +01004314 psa_key_attributes_t attributes = PSA_KEY_ATTRIBUTES_INIT;
4315 psa_status_t status = PSA_ERROR_GENERIC_ERROR;
4316 psa_status_t expected_status = expected_status_arg;
Paul Elliotte58cb1e2021-09-10 18:36:00 +01004317 unsigned char *ciphertext = NULL;
4318 unsigned char *finish_ciphertext = NULL;
Paul Elliott719c1322021-09-13 18:27:22 +01004319 unsigned char *tag_buffer = NULL;
Paul Elliotte58cb1e2021-09-10 18:36:00 +01004320 size_t ciphertext_size = 0;
4321 size_t ciphertext_length = 0;
4322 size_t finish_ciphertext_size = ( size_t ) finish_ciphertext_size_arg;
Paul Elliott719c1322021-09-13 18:27:22 +01004323 size_t tag_size = ( size_t ) tag_size_arg;
Paul Elliott91b021e2021-07-23 18:52:31 +01004324 size_t tag_length = 0;
Paul Elliott91b021e2021-07-23 18:52:31 +01004325
4326 PSA_ASSERT( psa_crypto_init( ) );
4327
4328 psa_set_key_usage_flags( &attributes, PSA_KEY_USAGE_ENCRYPT );
4329 psa_set_key_algorithm( &attributes, alg );
4330 psa_set_key_type( &attributes, key_type );
4331
4332 PSA_ASSERT( psa_import_key( &attributes, key_data->x, key_data->len,
4333 &key ) );
4334
4335 PSA_ASSERT( psa_get_key_attributes( key, &attributes ) );
4336
Paul Elliotte58cb1e2021-09-10 18:36:00 +01004337 ciphertext_size = PSA_AEAD_UPDATE_OUTPUT_SIZE( key_type, alg, input_data->len );
Paul Elliott91b021e2021-07-23 18:52:31 +01004338
Paul Elliotte58cb1e2021-09-10 18:36:00 +01004339 ASSERT_ALLOC( ciphertext, ciphertext_size );
Paul Elliott91b021e2021-07-23 18:52:31 +01004340
Paul Elliotte58cb1e2021-09-10 18:36:00 +01004341 ASSERT_ALLOC( finish_ciphertext, finish_ciphertext_size );
Paul Elliott91b021e2021-07-23 18:52:31 +01004342
Paul Elliott719c1322021-09-13 18:27:22 +01004343 ASSERT_ALLOC( tag_buffer, tag_size );
4344
Paul Elliott91b021e2021-07-23 18:52:31 +01004345 status = psa_aead_encrypt_setup( &operation, key, alg );
4346
4347 /* If the operation is not supported, just skip and not fail in case the
4348 * encryption involves a common limitation of cryptography hardwares and
4349 * an alternative implementation. */
4350 if( status == PSA_ERROR_NOT_SUPPORTED )
4351 {
4352 MBEDTLS_TEST_PSA_SKIP_IF_ALT_AES_192( key_type, key_data->len * 8 );
4353 MBEDTLS_TEST_PSA_SKIP_IF_ALT_GCM_NOT_12BYTES_NONCE( alg, nonce->len );
4354 }
4355
4356 PSA_ASSERT( status );
4357
4358 PSA_ASSERT( psa_aead_set_nonce( &operation, nonce->x, nonce->len ) );
4359
4360 PSA_ASSERT( psa_aead_update_ad( &operation, additional_data->x,
4361 additional_data->len ) );
4362
4363 PSA_ASSERT( psa_aead_update( &operation, input_data->x, input_data->len,
Paul Elliotte58cb1e2021-09-10 18:36:00 +01004364 ciphertext, ciphertext_size, &ciphertext_length ) );
Paul Elliott91b021e2021-07-23 18:52:31 +01004365
4366 /* Ensure we can still complete operation. */
Paul Elliotte58cb1e2021-09-10 18:36:00 +01004367 status = psa_aead_finish( &operation, finish_ciphertext,
4368 finish_ciphertext_size,
4369 &ciphertext_length, tag_buffer,
Paul Elliott719c1322021-09-13 18:27:22 +01004370 tag_size, &tag_length );
Paul Elliott91b021e2021-07-23 18:52:31 +01004371
4372 TEST_EQUAL( status, expected_status );
4373
4374exit:
4375 psa_destroy_key( key );
Paul Elliotte58cb1e2021-09-10 18:36:00 +01004376 mbedtls_free( ciphertext );
4377 mbedtls_free( finish_ciphertext );
Paul Elliott4a760882021-09-20 09:42:21 +01004378 mbedtls_free( tag_buffer );
Paul Elliott91b021e2021-07-23 18:52:31 +01004379 psa_aead_abort( &operation );
4380 PSA_DONE( );
4381}
4382/* END_CASE */
Paul Elliott43fbda62021-07-23 18:30:59 +01004383
4384/* BEGIN_CASE */
Paul Elliott9961a662021-09-17 19:19:02 +01004385void aead_multipart_verify( int key_type_arg, data_t *key_data,
4386 int alg_arg,
4387 data_t *nonce,
4388 data_t *additional_data,
4389 data_t *input_data,
4390 data_t *tag,
Paul Elliott1c67e0b2021-09-19 13:11:50 +01004391 int tag_usage_arg,
Paul Elliott9961a662021-09-17 19:19:02 +01004392 int expected_status_arg )
4393{
4394 mbedtls_svc_key_id_t key = MBEDTLS_SVC_KEY_ID_INIT;
4395 psa_key_type_t key_type = key_type_arg;
4396 psa_algorithm_t alg = alg_arg;
Paul Elliottfbb4c6d2021-09-22 16:44:21 +01004397 psa_aead_operation_t operation = PSA_AEAD_OPERATION_INIT;
Paul Elliott9961a662021-09-17 19:19:02 +01004398 psa_key_attributes_t attributes = PSA_KEY_ATTRIBUTES_INIT;
4399 psa_status_t status = PSA_ERROR_GENERIC_ERROR;
4400 psa_status_t expected_status = expected_status_arg;
4401 unsigned char *plaintext = NULL;
4402 unsigned char *finish_plaintext = NULL;
4403 size_t plaintext_size = 0;
4404 size_t plaintext_length = 0;
4405 size_t verify_plaintext_size = 0;
Paul Elliottbb979e72021-09-22 12:54:42 +01004406 tag_usage_method_t tag_usage = tag_usage_arg;
Paul Elliott1c67e0b2021-09-19 13:11:50 +01004407 unsigned char *tag_buffer = NULL;
4408 size_t tag_size = 0;
Paul Elliott9961a662021-09-17 19:19:02 +01004409
4410 PSA_ASSERT( psa_crypto_init( ) );
4411
4412 psa_set_key_usage_flags( &attributes, PSA_KEY_USAGE_DECRYPT );
4413 psa_set_key_algorithm( &attributes, alg );
4414 psa_set_key_type( &attributes, key_type );
4415
4416 PSA_ASSERT( psa_import_key( &attributes, key_data->x, key_data->len,
4417 &key ) );
4418
4419 PSA_ASSERT( psa_get_key_attributes( key, &attributes ) );
4420
4421 plaintext_size = PSA_AEAD_UPDATE_OUTPUT_SIZE( key_type, alg,
4422 input_data->len );
4423
4424 ASSERT_ALLOC( plaintext, plaintext_size );
4425
4426 verify_plaintext_size = PSA_AEAD_VERIFY_OUTPUT_SIZE( key_type, alg );
4427
4428 ASSERT_ALLOC( finish_plaintext, verify_plaintext_size );
4429
Paul Elliott9961a662021-09-17 19:19:02 +01004430 status = psa_aead_decrypt_setup( &operation, key, alg );
4431
4432 /* If the operation is not supported, just skip and not fail in case the
4433 * encryption involves a common limitation of cryptography hardwares and
4434 * an alternative implementation. */
4435 if( status == PSA_ERROR_NOT_SUPPORTED )
4436 {
4437 MBEDTLS_TEST_PSA_SKIP_IF_ALT_AES_192( key_type, key_data->len * 8 );
4438 MBEDTLS_TEST_PSA_SKIP_IF_ALT_GCM_NOT_12BYTES_NONCE( alg, nonce->len );
4439 }
4440
4441 PSA_ASSERT( status );
4442
4443 PSA_ASSERT( psa_aead_set_nonce( &operation, nonce->x, nonce->len ) );
4444
4445 PSA_ASSERT( psa_aead_update_ad( &operation, additional_data->x,
4446 additional_data->len ) );
4447
4448 PSA_ASSERT( psa_aead_update( &operation, input_data->x,
4449 input_data->len,
4450 plaintext, plaintext_size,
4451 &plaintext_length ) );
4452
Paul Elliott1c67e0b2021-09-19 13:11:50 +01004453 if( tag_usage == USE_GIVEN_TAG )
4454 {
4455 tag_buffer = tag->x;
4456 tag_size = tag->len;
4457 }
4458
Paul Elliott9961a662021-09-17 19:19:02 +01004459 status = psa_aead_verify( &operation, finish_plaintext,
4460 verify_plaintext_size,
4461 &plaintext_length,
Paul Elliott1c67e0b2021-09-19 13:11:50 +01004462 tag_buffer, tag_size );
Paul Elliott9961a662021-09-17 19:19:02 +01004463
4464 TEST_EQUAL( status, expected_status );
4465
4466exit:
4467 psa_destroy_key( key );
4468 mbedtls_free( plaintext );
4469 mbedtls_free( finish_plaintext );
4470 psa_aead_abort( &operation );
4471 PSA_DONE( );
4472}
4473/* END_CASE */
4474
Paul Elliott9961a662021-09-17 19:19:02 +01004475/* BEGIN_CASE */
Paul Elliott5221ef62021-09-19 17:33:03 +01004476void aead_multipart_setup( int key_type_arg, data_t *key_data,
4477 int alg_arg, int expected_status_arg )
4478{
4479 mbedtls_svc_key_id_t key = MBEDTLS_SVC_KEY_ID_INIT;
4480 psa_key_type_t key_type = key_type_arg;
4481 psa_algorithm_t alg = alg_arg;
Paul Elliottfbb4c6d2021-09-22 16:44:21 +01004482 psa_aead_operation_t operation = PSA_AEAD_OPERATION_INIT;
Paul Elliott5221ef62021-09-19 17:33:03 +01004483 psa_key_attributes_t attributes = PSA_KEY_ATTRIBUTES_INIT;
4484 psa_status_t status = PSA_ERROR_GENERIC_ERROR;
4485 psa_status_t expected_status = expected_status_arg;
4486
4487 PSA_ASSERT( psa_crypto_init( ) );
4488
4489 psa_set_key_usage_flags( &attributes,
4490 PSA_KEY_USAGE_ENCRYPT | PSA_KEY_USAGE_DECRYPT );
4491 psa_set_key_algorithm( &attributes, alg );
4492 psa_set_key_type( &attributes, key_type );
4493
4494 PSA_ASSERT( psa_import_key( &attributes, key_data->x, key_data->len,
4495 &key ) );
4496
Paul Elliott5221ef62021-09-19 17:33:03 +01004497 status = psa_aead_encrypt_setup( &operation, key, alg );
4498
4499 TEST_EQUAL( status, expected_status );
4500
4501 psa_aead_abort( &operation );
4502
Paul Elliott5221ef62021-09-19 17:33:03 +01004503 status = psa_aead_decrypt_setup( &operation, key, alg );
4504
4505 TEST_EQUAL(status, expected_status );
4506
4507exit:
4508 psa_destroy_key( key );
4509 psa_aead_abort( &operation );
4510 PSA_DONE( );
4511}
4512/* END_CASE */
4513
4514/* BEGIN_CASE */
Paul Elliottc23a9a02021-06-21 18:32:46 +01004515void aead_multipart_state_test( int key_type_arg, data_t *key_data,
4516 int alg_arg,
4517 data_t *nonce,
4518 data_t *additional_data,
4519 data_t *input_data )
4520{
4521 mbedtls_svc_key_id_t key = MBEDTLS_SVC_KEY_ID_INIT;
4522 psa_key_type_t key_type = key_type_arg;
4523 psa_algorithm_t alg = alg_arg;
Paul Elliottfbb4c6d2021-09-22 16:44:21 +01004524 psa_aead_operation_t operation = PSA_AEAD_OPERATION_INIT;
Paul Elliottc23a9a02021-06-21 18:32:46 +01004525 unsigned char *output_data = NULL;
4526 unsigned char *final_data = NULL;
4527 size_t output_size = 0;
4528 size_t finish_output_size = 0;
4529 size_t output_length = 0;
4530 size_t key_bits = 0;
4531 size_t tag_length = 0;
4532 size_t tag_size = 0;
4533 size_t nonce_length = 0;
4534 uint8_t nonce_buffer[PSA_AEAD_NONCE_MAX_SIZE];
4535 uint8_t tag_buffer[PSA_AEAD_TAG_MAX_SIZE];
4536 size_t output_part_length = 0;
4537 psa_key_attributes_t attributes = PSA_KEY_ATTRIBUTES_INIT;
4538
4539 PSA_ASSERT( psa_crypto_init( ) );
4540
4541 psa_set_key_usage_flags( & attributes,
4542 PSA_KEY_USAGE_ENCRYPT | PSA_KEY_USAGE_DECRYPT );
4543 psa_set_key_algorithm( & attributes, alg );
4544 psa_set_key_type( & attributes, key_type );
4545
4546 PSA_ASSERT( psa_import_key( &attributes, key_data->x, key_data->len,
4547 &key ) );
4548
4549 PSA_ASSERT( psa_get_key_attributes( key, &attributes ) );
4550 key_bits = psa_get_key_bits( &attributes );
4551
4552 tag_length = PSA_AEAD_TAG_LENGTH( key_type, key_bits, alg );
4553
4554 TEST_ASSERT( tag_length <= PSA_AEAD_TAG_MAX_SIZE );
4555
4556 output_size = PSA_AEAD_UPDATE_OUTPUT_SIZE( key_type, alg, input_data->len );
4557
4558 ASSERT_ALLOC( output_data, output_size );
4559
4560 finish_output_size = PSA_AEAD_FINISH_OUTPUT_SIZE( key_type, alg );
4561
4562 TEST_ASSERT( finish_output_size <= PSA_AEAD_FINISH_OUTPUT_MAX_SIZE );
4563
4564 ASSERT_ALLOC( final_data, finish_output_size );
4565
4566 /* Test all operations error without calling setup first. */
4567
Paul Elliottc23a9a02021-06-21 18:32:46 +01004568 TEST_EQUAL( psa_aead_set_nonce( &operation, nonce->x, nonce->len ),
4569 PSA_ERROR_BAD_STATE );
4570
4571 psa_aead_abort( &operation );
4572
Paul Elliottc23a9a02021-06-21 18:32:46 +01004573 TEST_EQUAL( psa_aead_generate_nonce( &operation, nonce_buffer,
4574 PSA_AEAD_NONCE_MAX_SIZE,
4575 &nonce_length ),
4576 PSA_ERROR_BAD_STATE );
4577
4578 psa_aead_abort( &operation );
4579
Paul Elliott481be342021-07-16 17:38:47 +01004580 /* ------------------------------------------------------- */
4581
Paul Elliottc23a9a02021-06-21 18:32:46 +01004582 TEST_EQUAL( psa_aead_set_lengths( &operation, additional_data->len,
4583 input_data->len ),
4584 PSA_ERROR_BAD_STATE );
4585
4586 psa_aead_abort( &operation );
4587
Paul Elliott481be342021-07-16 17:38:47 +01004588 /* ------------------------------------------------------- */
4589
Paul Elliottc23a9a02021-06-21 18:32:46 +01004590 TEST_EQUAL( psa_aead_update_ad( &operation, additional_data->x,
4591 additional_data->len ),
4592 PSA_ERROR_BAD_STATE );
4593
4594 psa_aead_abort( &operation );
4595
Paul Elliott481be342021-07-16 17:38:47 +01004596 /* ------------------------------------------------------- */
4597
Paul Elliottc23a9a02021-06-21 18:32:46 +01004598 TEST_EQUAL( psa_aead_update( &operation, input_data->x,
4599 input_data->len, output_data,
4600 output_size, &output_length ),
4601 PSA_ERROR_BAD_STATE );
4602
4603 psa_aead_abort( &operation );
4604
Paul Elliott481be342021-07-16 17:38:47 +01004605 /* ------------------------------------------------------- */
4606
Paul Elliottc23a9a02021-06-21 18:32:46 +01004607 TEST_EQUAL( psa_aead_finish( &operation, final_data,
4608 finish_output_size,
4609 &output_part_length,
4610 tag_buffer, tag_length,
4611 &tag_size ),
4612 PSA_ERROR_BAD_STATE );
4613
4614 psa_aead_abort( &operation );
4615
Paul Elliott481be342021-07-16 17:38:47 +01004616 /* ------------------------------------------------------- */
4617
Paul Elliottc23a9a02021-06-21 18:32:46 +01004618 TEST_EQUAL( psa_aead_verify( &operation, final_data,
4619 finish_output_size,
4620 &output_part_length,
4621 tag_buffer,
4622 tag_length ),
4623 PSA_ERROR_BAD_STATE );
4624
4625 psa_aead_abort( &operation );
4626
4627 /* Test for double setups. */
4628
Paul Elliottc23a9a02021-06-21 18:32:46 +01004629 PSA_ASSERT( psa_aead_encrypt_setup( &operation, key, alg ) );
4630
4631 TEST_EQUAL( psa_aead_encrypt_setup( &operation, key, alg ),
4632 PSA_ERROR_BAD_STATE );
4633
4634 psa_aead_abort( &operation );
4635
Paul Elliott481be342021-07-16 17:38:47 +01004636 /* ------------------------------------------------------- */
4637
Paul Elliottc23a9a02021-06-21 18:32:46 +01004638 PSA_ASSERT( psa_aead_decrypt_setup( &operation, key, alg ) );
4639
4640 TEST_EQUAL( psa_aead_decrypt_setup( &operation, key, alg ),
4641 PSA_ERROR_BAD_STATE );
4642
4643 psa_aead_abort( &operation );
4644
Paul Elliott374a2be2021-07-16 17:53:40 +01004645 /* ------------------------------------------------------- */
4646
Paul Elliott374a2be2021-07-16 17:53:40 +01004647 PSA_ASSERT( psa_aead_encrypt_setup( &operation, key, alg ) );
4648
4649 TEST_EQUAL( psa_aead_decrypt_setup( &operation, key, alg ),
4650 PSA_ERROR_BAD_STATE );
4651
4652 psa_aead_abort( &operation );
4653
4654 /* ------------------------------------------------------- */
4655
Paul Elliott374a2be2021-07-16 17:53:40 +01004656 PSA_ASSERT( psa_aead_decrypt_setup( &operation, key, alg ) );
4657
4658 TEST_EQUAL( psa_aead_encrypt_setup( &operation, key, alg ),
4659 PSA_ERROR_BAD_STATE );
4660
4661 psa_aead_abort( &operation );
4662
Paul Elliottc23a9a02021-06-21 18:32:46 +01004663 /* Test for not setting a nonce. */
4664
Paul Elliottc23a9a02021-06-21 18:32:46 +01004665 PSA_ASSERT( psa_aead_encrypt_setup( &operation, key, alg ) );
4666
4667 TEST_EQUAL( psa_aead_update_ad( &operation, additional_data->x,
4668 additional_data->len ),
4669 PSA_ERROR_BAD_STATE );
4670
4671 psa_aead_abort( &operation );
4672
Paul Elliott7f628422021-09-01 12:08:29 +01004673 /* ------------------------------------------------------- */
4674
Paul Elliott7f628422021-09-01 12:08:29 +01004675 PSA_ASSERT( psa_aead_encrypt_setup( &operation, key, alg ) );
4676
4677 TEST_EQUAL( psa_aead_update( &operation, input_data->x,
4678 input_data->len, output_data,
4679 output_size, &output_length ),
4680 PSA_ERROR_BAD_STATE );
4681
4682 psa_aead_abort( &operation );
4683
Paul Elliottbdc2c682021-09-21 18:37:10 +01004684 /* ------------------------------------------------------- */
4685
Paul Elliottbdc2c682021-09-21 18:37:10 +01004686 PSA_ASSERT( psa_aead_encrypt_setup( &operation, key, alg ) );
4687
4688 TEST_EQUAL( psa_aead_finish( &operation, final_data,
4689 finish_output_size,
4690 &output_part_length,
4691 tag_buffer, tag_length,
4692 &tag_size ),
4693 PSA_ERROR_BAD_STATE );
4694
4695 psa_aead_abort( &operation );
4696
4697 /* ------------------------------------------------------- */
4698
Paul Elliottbdc2c682021-09-21 18:37:10 +01004699 PSA_ASSERT( psa_aead_decrypt_setup( &operation, key, alg ) );
4700
4701 TEST_EQUAL( psa_aead_verify( &operation, final_data,
4702 finish_output_size,
4703 &output_part_length,
4704 tag_buffer,
4705 tag_length ),
4706 PSA_ERROR_BAD_STATE );
4707
4708 psa_aead_abort( &operation );
4709
Paul Elliottc23a9a02021-06-21 18:32:46 +01004710 /* Test for double setting nonce. */
4711
Paul Elliottc23a9a02021-06-21 18:32:46 +01004712 PSA_ASSERT( psa_aead_encrypt_setup( &operation, key, alg ) );
4713
4714 PSA_ASSERT( psa_aead_set_nonce( &operation, nonce->x, nonce->len ) );
4715
4716 TEST_EQUAL( psa_aead_set_nonce( &operation, nonce->x, nonce->len ),
4717 PSA_ERROR_BAD_STATE );
4718
4719 psa_aead_abort( &operation );
4720
Paul Elliott374a2be2021-07-16 17:53:40 +01004721 /* Test for double generating nonce. */
4722
Paul Elliott374a2be2021-07-16 17:53:40 +01004723 PSA_ASSERT( psa_aead_encrypt_setup( &operation, key, alg ) );
4724
4725 PSA_ASSERT( psa_aead_generate_nonce( &operation, nonce_buffer,
4726 PSA_AEAD_NONCE_MAX_SIZE,
4727 &nonce_length ) );
4728
4729 TEST_EQUAL( psa_aead_generate_nonce( &operation, nonce_buffer,
4730 PSA_AEAD_NONCE_MAX_SIZE,
4731 &nonce_length ),
4732 PSA_ERROR_BAD_STATE );
4733
4734
4735 psa_aead_abort( &operation );
4736
4737 /* Test for generate nonce then set and vice versa */
4738
Paul Elliott374a2be2021-07-16 17:53:40 +01004739 PSA_ASSERT( psa_aead_encrypt_setup( &operation, key, alg ) );
4740
4741 PSA_ASSERT( psa_aead_generate_nonce( &operation, nonce_buffer,
4742 PSA_AEAD_NONCE_MAX_SIZE,
4743 &nonce_length ) );
4744
4745 TEST_EQUAL( psa_aead_set_nonce( &operation, nonce->x, nonce->len ),
4746 PSA_ERROR_BAD_STATE );
4747
4748 psa_aead_abort( &operation );
4749
4750 /* ------------------------------------------------------- */
4751
Paul Elliott374a2be2021-07-16 17:53:40 +01004752 PSA_ASSERT( psa_aead_encrypt_setup( &operation, key, alg ) );
4753
4754 PSA_ASSERT( psa_aead_set_nonce( &operation, nonce->x, nonce->len ) );
4755
4756 TEST_EQUAL( psa_aead_generate_nonce( &operation, nonce_buffer,
4757 PSA_AEAD_NONCE_MAX_SIZE,
4758 &nonce_length ),
4759 PSA_ERROR_BAD_STATE );
4760
4761 psa_aead_abort( &operation );
4762
Paul Elliott7220cae2021-06-22 17:25:57 +01004763 /* Test for generating nonce in decrypt setup. */
4764
Paul Elliott7220cae2021-06-22 17:25:57 +01004765 PSA_ASSERT( psa_aead_decrypt_setup( &operation, key, alg ) );
4766
4767 TEST_EQUAL( psa_aead_generate_nonce( &operation, nonce_buffer,
4768 PSA_AEAD_NONCE_MAX_SIZE,
4769 &nonce_length ),
4770 PSA_ERROR_BAD_STATE );
4771
4772 psa_aead_abort( &operation );
4773
Paul Elliottc23a9a02021-06-21 18:32:46 +01004774 /* Test for setting lengths twice. */
4775
Paul Elliottc23a9a02021-06-21 18:32:46 +01004776 PSA_ASSERT( psa_aead_encrypt_setup( &operation, key, alg ) );
4777
4778 PSA_ASSERT( psa_aead_set_nonce( &operation, nonce->x, nonce->len ) );
4779
4780 PSA_ASSERT( psa_aead_set_lengths( &operation, additional_data->len,
4781 input_data->len ) );
4782
4783 TEST_EQUAL( psa_aead_set_lengths( &operation, additional_data->len,
4784 input_data->len ),
4785 PSA_ERROR_BAD_STATE );
4786
4787 psa_aead_abort( &operation );
4788
4789 /* Test for setting lengths after already starting data. */
4790
Paul Elliottc23a9a02021-06-21 18:32:46 +01004791 PSA_ASSERT( psa_aead_encrypt_setup( &operation, key, alg ) );
4792
4793 PSA_ASSERT( psa_aead_set_nonce( &operation, nonce->x, nonce->len ) );
4794
Paul Elliottf94bd992021-09-19 18:15:59 +01004795 PSA_ASSERT( psa_aead_update_ad( &operation, additional_data->x,
4796 additional_data->len ) );
4797
4798 TEST_EQUAL( psa_aead_set_lengths( &operation, additional_data->len,
4799 input_data->len ),
4800 PSA_ERROR_BAD_STATE );
4801
4802 psa_aead_abort( &operation );
4803
4804 /* ------------------------------------------------------- */
4805
Paul Elliottf94bd992021-09-19 18:15:59 +01004806 PSA_ASSERT( psa_aead_encrypt_setup( &operation, key, alg ) );
4807
4808 PSA_ASSERT( psa_aead_set_nonce( &operation, nonce->x, nonce->len ) );
4809
Paul Elliottc23a9a02021-06-21 18:32:46 +01004810 PSA_ASSERT( psa_aead_update( &operation, input_data->x,
4811 input_data->len, output_data,
4812 output_size, &output_length ) );
4813
4814 TEST_EQUAL( psa_aead_set_lengths( &operation, additional_data->len,
4815 input_data->len ),
4816 PSA_ERROR_BAD_STATE );
4817
4818 psa_aead_abort( &operation );
4819
Paul Elliott243080c2021-07-21 19:01:17 +01004820 /* Test for not sending any additional data or data after setting non zero
4821 * lengths for them. (encrypt) */
Paul Elliottc23a9a02021-06-21 18:32:46 +01004822
Paul Elliottc23a9a02021-06-21 18:32:46 +01004823 PSA_ASSERT( psa_aead_encrypt_setup( &operation, key, alg ) );
4824
4825 PSA_ASSERT( psa_aead_set_nonce( &operation, nonce->x, nonce->len ) );
4826
4827 PSA_ASSERT( psa_aead_set_lengths( &operation, additional_data->len,
4828 input_data->len ) );
4829
4830 TEST_EQUAL( psa_aead_finish( &operation, final_data,
4831 finish_output_size,
4832 &output_part_length,
4833 tag_buffer, tag_length,
4834 &tag_size ),
4835 PSA_ERROR_INVALID_ARGUMENT );
4836
4837 psa_aead_abort( &operation );
4838
Paul Elliott243080c2021-07-21 19:01:17 +01004839 /* Test for not sending any additional data or data after setting non-zero
4840 * lengths for them. (decrypt) */
Paul Elliottc23a9a02021-06-21 18:32:46 +01004841
Paul Elliottc23a9a02021-06-21 18:32:46 +01004842 PSA_ASSERT( psa_aead_decrypt_setup( &operation, key, alg ) );
4843
4844 PSA_ASSERT( psa_aead_set_nonce( &operation, nonce->x, nonce->len ) );
4845
4846 PSA_ASSERT( psa_aead_set_lengths( &operation, additional_data->len,
4847 input_data->len ) );
4848
4849 TEST_EQUAL( psa_aead_verify( &operation, final_data,
4850 finish_output_size,
4851 &output_part_length,
4852 tag_buffer,
4853 tag_length ),
4854 PSA_ERROR_INVALID_ARGUMENT );
4855
4856 psa_aead_abort( &operation );
4857
Paul Elliott243080c2021-07-21 19:01:17 +01004858 /* Test for not sending any additional data after setting a non-zero length
4859 * for it. */
Paul Elliottc23a9a02021-06-21 18:32:46 +01004860
Paul Elliottc23a9a02021-06-21 18:32:46 +01004861 PSA_ASSERT( psa_aead_encrypt_setup( &operation, key, alg ) );
4862
4863 PSA_ASSERT( psa_aead_set_nonce( &operation, nonce->x, nonce->len ) );
4864
4865 PSA_ASSERT( psa_aead_set_lengths( &operation, additional_data->len,
4866 input_data->len ) );
4867
4868 TEST_EQUAL( psa_aead_update( &operation, input_data->x,
4869 input_data->len, output_data,
4870 output_size, &output_length ),
4871 PSA_ERROR_INVALID_ARGUMENT );
4872
4873 psa_aead_abort( &operation );
4874
Paul Elliottf94bd992021-09-19 18:15:59 +01004875 /* Test for not sending any data after setting a non-zero length for it.*/
4876
Paul Elliottf94bd992021-09-19 18:15:59 +01004877 PSA_ASSERT( psa_aead_encrypt_setup( &operation, key, alg ) );
4878
4879 PSA_ASSERT( psa_aead_set_nonce( &operation, nonce->x, nonce->len ) );
4880
4881 PSA_ASSERT( psa_aead_set_lengths( &operation, additional_data->len,
4882 input_data->len ) );
4883
4884 PSA_ASSERT( psa_aead_update_ad( &operation, additional_data->x,
4885 additional_data->len ) );
4886
4887 TEST_EQUAL( psa_aead_finish( &operation, final_data,
4888 finish_output_size,
4889 &output_part_length,
4890 tag_buffer, tag_length,
4891 &tag_size ),
4892 PSA_ERROR_INVALID_ARGUMENT );
4893
4894 psa_aead_abort( &operation );
4895
Paul Elliottb0450fe2021-09-01 15:06:26 +01004896 /* Test for sending too much additional data after setting lengths. */
4897
Paul Elliottb0450fe2021-09-01 15:06:26 +01004898 PSA_ASSERT( psa_aead_encrypt_setup( &operation, key, alg ) );
4899
4900 PSA_ASSERT( psa_aead_set_nonce( &operation, nonce->x, nonce->len ) );
4901
4902 PSA_ASSERT( psa_aead_set_lengths( &operation, 0, 0 ) );
4903
4904
4905 TEST_EQUAL( psa_aead_update_ad( &operation, additional_data->x,
4906 additional_data->len ),
4907 PSA_ERROR_INVALID_ARGUMENT );
4908
4909 psa_aead_abort( &operation );
4910
Paul Elliotta2a09b02021-09-22 14:56:40 +01004911 /* ------------------------------------------------------- */
Paul Elliottfd0c154c2021-09-17 18:03:52 +01004912
4913 PSA_ASSERT( psa_aead_encrypt_setup( &operation, key, alg ) );
4914
4915 PSA_ASSERT( psa_aead_set_nonce( &operation, nonce->x, nonce->len ) );
4916
4917 PSA_ASSERT( psa_aead_set_lengths( &operation, additional_data->len,
4918 input_data->len ) );
4919
4920 PSA_ASSERT( psa_aead_update_ad( &operation, additional_data->x,
4921 additional_data->len ) );
4922
4923 TEST_EQUAL( psa_aead_update_ad( &operation, additional_data->x,
4924 1 ),
4925 PSA_ERROR_INVALID_ARGUMENT );
4926
4927 psa_aead_abort( &operation );
4928
Paul Elliottb0450fe2021-09-01 15:06:26 +01004929 /* Test for sending too much data after setting lengths. */
4930
Paul Elliottb0450fe2021-09-01 15:06:26 +01004931 PSA_ASSERT( psa_aead_encrypt_setup( &operation, key, alg ) );
4932
4933 PSA_ASSERT( psa_aead_set_nonce( &operation, nonce->x, nonce->len ) );
4934
4935 PSA_ASSERT( psa_aead_set_lengths( &operation, 0, 0 ) );
4936
4937 TEST_EQUAL( psa_aead_update( &operation, input_data->x,
4938 input_data->len, output_data,
4939 output_size, &output_length ),
4940 PSA_ERROR_INVALID_ARGUMENT );
4941
4942 psa_aead_abort( &operation );
4943
Paul Elliotta2a09b02021-09-22 14:56:40 +01004944 /* ------------------------------------------------------- */
Paul Elliottfd0c154c2021-09-17 18:03:52 +01004945
4946 PSA_ASSERT( psa_aead_encrypt_setup( &operation, key, alg ) );
4947
4948 PSA_ASSERT( psa_aead_set_nonce( &operation, nonce->x, nonce->len ) );
4949
4950 PSA_ASSERT( psa_aead_set_lengths( &operation, additional_data->len,
4951 input_data->len ) );
4952
4953 PSA_ASSERT( psa_aead_update_ad( &operation, additional_data->x,
4954 additional_data->len ) );
4955
4956 PSA_ASSERT( psa_aead_update( &operation, input_data->x,
4957 input_data->len, output_data,
4958 output_size, &output_length ) );
4959
4960 TEST_EQUAL( psa_aead_update( &operation, input_data->x,
4961 1, output_data,
4962 output_size, &output_length ),
4963 PSA_ERROR_INVALID_ARGUMENT );
4964
4965 psa_aead_abort( &operation );
4966
Paul Elliottc23a9a02021-06-21 18:32:46 +01004967 /* Test sending additional data after data. */
4968
Paul Elliottc23a9a02021-06-21 18:32:46 +01004969 PSA_ASSERT( psa_aead_encrypt_setup( &operation, key, alg ) );
4970
4971 PSA_ASSERT( psa_aead_set_nonce( &operation, nonce->x, nonce->len ) );
4972
4973 PSA_ASSERT( psa_aead_update( &operation, input_data->x,
4974 input_data->len, output_data,
4975 output_size, &output_length ) );
4976
4977 TEST_EQUAL( psa_aead_update_ad( &operation, additional_data->x,
4978 additional_data->len ),
4979 PSA_ERROR_BAD_STATE );
4980
4981 psa_aead_abort( &operation );
4982
Paul Elliott534d0b42021-06-22 19:15:20 +01004983 /* Test calling finish on decryption. */
4984
Paul Elliott534d0b42021-06-22 19:15:20 +01004985 PSA_ASSERT( psa_aead_decrypt_setup( &operation, key, alg ) );
4986
4987 PSA_ASSERT( psa_aead_set_nonce( &operation, nonce->x, nonce->len ) );
4988
4989 TEST_EQUAL( psa_aead_finish( &operation, final_data,
4990 finish_output_size,
4991 &output_part_length,
4992 tag_buffer, tag_length,
4993 &tag_size ),
4994 PSA_ERROR_BAD_STATE );
4995
4996 psa_aead_abort( &operation );
4997
4998 /* Test calling verify on encryption. */
4999
Paul Elliott534d0b42021-06-22 19:15:20 +01005000 PSA_ASSERT( psa_aead_encrypt_setup( &operation, key, alg ) );
5001
5002 PSA_ASSERT( psa_aead_set_nonce( &operation, nonce->x, nonce->len ) );
5003
5004 TEST_EQUAL( psa_aead_verify( &operation, final_data,
5005 finish_output_size,
5006 &output_part_length,
5007 tag_buffer,
5008 tag_length ),
Paul Elliott5b065cb2021-06-23 08:33:22 +01005009 PSA_ERROR_BAD_STATE );
Paul Elliott534d0b42021-06-22 19:15:20 +01005010
5011 psa_aead_abort( &operation );
5012
5013
Paul Elliottc23a9a02021-06-21 18:32:46 +01005014exit:
5015 psa_destroy_key( key );
5016 psa_aead_abort( &operation );
5017 mbedtls_free( output_data );
5018 mbedtls_free( final_data );
5019 PSA_DONE( );
5020}
5021/* END_CASE */
5022
5023/* BEGIN_CASE */
Gilles Peskinec1bb6c82018-06-18 16:04:39 +02005024void signature_size( int type_arg,
5025 int bits,
5026 int alg_arg,
5027 int expected_size_arg )
Gilles Peskinee59236f2018-01-27 23:32:46 +01005028{
5029 psa_key_type_t type = type_arg;
5030 psa_algorithm_t alg = alg_arg;
Gilles Peskine89d8c5c2019-11-26 17:01:59 +01005031 size_t actual_size = PSA_SIGN_OUTPUT_SIZE( type, bits, alg );
Gilles Peskine841b14b2019-11-26 17:37:37 +01005032
Gilles Peskinefe11b722018-12-18 00:24:04 +01005033 TEST_EQUAL( actual_size, (size_t) expected_size_arg );
Gilles Peskine841b14b2019-11-26 17:37:37 +01005034
Gilles Peskinee59236f2018-01-27 23:32:46 +01005035exit:
5036 ;
5037}
5038/* END_CASE */
5039
5040/* BEGIN_CASE */
gabor-mezei-armb9530232021-04-16 14:21:21 +02005041void sign_hash_deterministic( int key_type_arg, data_t *key_data,
5042 int alg_arg, data_t *input_data,
5043 data_t *output_data )
Gilles Peskinee59236f2018-01-27 23:32:46 +01005044{
Ronald Cron5425a212020-08-04 14:58:35 +02005045 mbedtls_svc_key_id_t key = MBEDTLS_SVC_KEY_ID_INIT;
Gilles Peskinee59236f2018-01-27 23:32:46 +01005046 psa_key_type_t key_type = key_type_arg;
5047 psa_algorithm_t alg = alg_arg;
Gilles Peskine20035e32018-02-03 22:44:14 +01005048 size_t key_bits;
Gilles Peskine20035e32018-02-03 22:44:14 +01005049 unsigned char *signature = NULL;
5050 size_t signature_size;
5051 size_t signature_length = 0xdeadbeef;
Gilles Peskine8c8f2ab2019-04-18 21:44:46 +02005052 psa_key_attributes_t attributes = PSA_KEY_ATTRIBUTES_INIT;
Gilles Peskine20035e32018-02-03 22:44:14 +01005053
Gilles Peskine8817f612018-12-18 00:18:46 +01005054 PSA_ASSERT( psa_crypto_init( ) );
Gilles Peskine20035e32018-02-03 22:44:14 +01005055
Gilles Peskine89d8c5c2019-11-26 17:01:59 +01005056 psa_set_key_usage_flags( &attributes, PSA_KEY_USAGE_SIGN_HASH );
Gilles Peskine2c2cf0e2019-04-19 19:58:20 +02005057 psa_set_key_algorithm( &attributes, alg );
5058 psa_set_key_type( &attributes, key_type );
mohammad1603a97cb8c2018-03-28 03:46:26 -07005059
Gilles Peskine049c7532019-05-15 20:22:09 +02005060 PSA_ASSERT( psa_import_key( &attributes, key_data->x, key_data->len,
Ronald Cron5425a212020-08-04 14:58:35 +02005061 &key ) );
5062 PSA_ASSERT( psa_get_key_attributes( key, &attributes ) );
Gilles Peskine8c8f2ab2019-04-18 21:44:46 +02005063 key_bits = psa_get_key_bits( &attributes );
Gilles Peskine20035e32018-02-03 22:44:14 +01005064
Gilles Peskine860ce9d2018-06-28 12:23:00 +02005065 /* Allocate a buffer which has the size advertized by the
5066 * library. */
Gilles Peskine89d8c5c2019-11-26 17:01:59 +01005067 signature_size = PSA_SIGN_OUTPUT_SIZE( key_type,
Gilles Peskinec1bb6c82018-06-18 16:04:39 +02005068 key_bits, alg );
Gilles Peskine20035e32018-02-03 22:44:14 +01005069 TEST_ASSERT( signature_size != 0 );
Gilles Peskine89d8c5c2019-11-26 17:01:59 +01005070 TEST_ASSERT( signature_size <= PSA_SIGNATURE_MAX_SIZE );
Gilles Peskine8cebbba2018-09-27 13:54:18 +02005071 ASSERT_ALLOC( signature, signature_size );
Gilles Peskine20035e32018-02-03 22:44:14 +01005072
Gilles Peskine860ce9d2018-06-28 12:23:00 +02005073 /* Perform the signature. */
Ronald Cron5425a212020-08-04 14:58:35 +02005074 PSA_ASSERT( psa_sign_hash( key, alg,
Gilles Peskine89d8c5c2019-11-26 17:01:59 +01005075 input_data->x, input_data->len,
5076 signature, signature_size,
5077 &signature_length ) );
Gilles Peskine9911b022018-06-29 17:30:48 +02005078 /* Verify that the signature is what is expected. */
Gilles Peskinebd7dea92018-09-27 13:57:19 +02005079 ASSERT_COMPARE( output_data->x, output_data->len,
5080 signature, signature_length );
Gilles Peskine20035e32018-02-03 22:44:14 +01005081
5082exit:
Ronald Cron3a4f0e32020-11-19 17:55:23 +01005083 /*
5084 * Key attributes may have been returned by psa_get_key_attributes()
5085 * thus reset them as required.
5086 */
Gilles Peskinea1ace9c2019-04-26 16:03:33 +02005087 psa_reset_key_attributes( &attributes );
Ronald Cron3a4f0e32020-11-19 17:55:23 +01005088
Ronald Cron5425a212020-08-04 14:58:35 +02005089 psa_destroy_key( key );
Gilles Peskine0189e752018-02-03 23:57:22 +01005090 mbedtls_free( signature );
Gilles Peskine1153e7b2019-05-28 15:10:21 +02005091 PSA_DONE( );
Gilles Peskine20035e32018-02-03 22:44:14 +01005092}
5093/* END_CASE */
5094
5095/* BEGIN_CASE */
gabor-mezei-armb9530232021-04-16 14:21:21 +02005096void sign_hash_fail( int key_type_arg, data_t *key_data,
5097 int alg_arg, data_t *input_data,
5098 int signature_size_arg, int expected_status_arg )
Gilles Peskine20035e32018-02-03 22:44:14 +01005099{
Ronald Cron5425a212020-08-04 14:58:35 +02005100 mbedtls_svc_key_id_t key = MBEDTLS_SVC_KEY_ID_INIT;
Gilles Peskine20035e32018-02-03 22:44:14 +01005101 psa_key_type_t key_type = key_type_arg;
5102 psa_algorithm_t alg = alg_arg;
Gilles Peskine860ce9d2018-06-28 12:23:00 +02005103 size_t signature_size = signature_size_arg;
Gilles Peskine20035e32018-02-03 22:44:14 +01005104 psa_status_t actual_status;
5105 psa_status_t expected_status = expected_status_arg;
Gilles Peskine40f68b92018-03-07 16:43:36 +01005106 unsigned char *signature = NULL;
Gilles Peskine93aa0332018-02-03 23:58:03 +01005107 size_t signature_length = 0xdeadbeef;
Gilles Peskine2c2cf0e2019-04-19 19:58:20 +02005108 psa_key_attributes_t attributes = PSA_KEY_ATTRIBUTES_INIT;
Gilles Peskine20035e32018-02-03 22:44:14 +01005109
Gilles Peskine8cebbba2018-09-27 13:54:18 +02005110 ASSERT_ALLOC( signature, signature_size );
Gilles Peskine20035e32018-02-03 22:44:14 +01005111
Gilles Peskine8817f612018-12-18 00:18:46 +01005112 PSA_ASSERT( psa_crypto_init( ) );
Gilles Peskine20035e32018-02-03 22:44:14 +01005113
Gilles Peskine89d8c5c2019-11-26 17:01:59 +01005114 psa_set_key_usage_flags( &attributes, PSA_KEY_USAGE_SIGN_HASH );
Gilles Peskine2c2cf0e2019-04-19 19:58:20 +02005115 psa_set_key_algorithm( &attributes, alg );
5116 psa_set_key_type( &attributes, key_type );
mohammad1603a97cb8c2018-03-28 03:46:26 -07005117
Gilles Peskine049c7532019-05-15 20:22:09 +02005118 PSA_ASSERT( psa_import_key( &attributes, key_data->x, key_data->len,
Ronald Cron5425a212020-08-04 14:58:35 +02005119 &key ) );
Gilles Peskine20035e32018-02-03 22:44:14 +01005120
Ronald Cron5425a212020-08-04 14:58:35 +02005121 actual_status = psa_sign_hash( key, alg,
Gilles Peskine89d8c5c2019-11-26 17:01:59 +01005122 input_data->x, input_data->len,
5123 signature, signature_size,
5124 &signature_length );
Gilles Peskinefe11b722018-12-18 00:24:04 +01005125 TEST_EQUAL( actual_status, expected_status );
Gilles Peskine860ce9d2018-06-28 12:23:00 +02005126 /* The value of *signature_length is unspecified on error, but
5127 * whatever it is, it should be less than signature_size, so that
5128 * if the caller tries to read *signature_length bytes without
5129 * checking the error code then they don't overflow a buffer. */
5130 TEST_ASSERT( signature_length <= signature_size );
Gilles Peskine20035e32018-02-03 22:44:14 +01005131
5132exit:
Gilles Peskinea1ace9c2019-04-26 16:03:33 +02005133 psa_reset_key_attributes( &attributes );
Ronald Cron5425a212020-08-04 14:58:35 +02005134 psa_destroy_key( key );
Gilles Peskine20035e32018-02-03 22:44:14 +01005135 mbedtls_free( signature );
Gilles Peskine1153e7b2019-05-28 15:10:21 +02005136 PSA_DONE( );
Gilles Peskine20035e32018-02-03 22:44:14 +01005137}
5138/* END_CASE */
mohammad16038cc1cee2018-03-28 01:21:33 +03005139
5140/* BEGIN_CASE */
gabor-mezei-armb9530232021-04-16 14:21:21 +02005141void sign_verify_hash( int key_type_arg, data_t *key_data,
5142 int alg_arg, data_t *input_data )
Gilles Peskine9911b022018-06-29 17:30:48 +02005143{
Ronald Cron5425a212020-08-04 14:58:35 +02005144 mbedtls_svc_key_id_t key = MBEDTLS_SVC_KEY_ID_INIT;
Gilles Peskine9911b022018-06-29 17:30:48 +02005145 psa_key_type_t key_type = key_type_arg;
5146 psa_algorithm_t alg = alg_arg;
5147 size_t key_bits;
5148 unsigned char *signature = NULL;
5149 size_t signature_size;
5150 size_t signature_length = 0xdeadbeef;
Gilles Peskine8c8f2ab2019-04-18 21:44:46 +02005151 psa_key_attributes_t attributes = PSA_KEY_ATTRIBUTES_INIT;
Gilles Peskine9911b022018-06-29 17:30:48 +02005152
Gilles Peskine8817f612018-12-18 00:18:46 +01005153 PSA_ASSERT( psa_crypto_init( ) );
Gilles Peskine9911b022018-06-29 17:30:48 +02005154
Gilles Peskine89d8c5c2019-11-26 17:01:59 +01005155 psa_set_key_usage_flags( &attributes, PSA_KEY_USAGE_SIGN_HASH | PSA_KEY_USAGE_VERIFY_HASH );
Gilles Peskine2c2cf0e2019-04-19 19:58:20 +02005156 psa_set_key_algorithm( &attributes, alg );
5157 psa_set_key_type( &attributes, key_type );
Gilles Peskine9911b022018-06-29 17:30:48 +02005158
Gilles Peskine049c7532019-05-15 20:22:09 +02005159 PSA_ASSERT( psa_import_key( &attributes, key_data->x, key_data->len,
Ronald Cron5425a212020-08-04 14:58:35 +02005160 &key ) );
5161 PSA_ASSERT( psa_get_key_attributes( key, &attributes ) );
Gilles Peskine8c8f2ab2019-04-18 21:44:46 +02005162 key_bits = psa_get_key_bits( &attributes );
Gilles Peskine9911b022018-06-29 17:30:48 +02005163
5164 /* Allocate a buffer which has the size advertized by the
5165 * library. */
Gilles Peskine89d8c5c2019-11-26 17:01:59 +01005166 signature_size = PSA_SIGN_OUTPUT_SIZE( key_type,
Gilles Peskine9911b022018-06-29 17:30:48 +02005167 key_bits, alg );
5168 TEST_ASSERT( signature_size != 0 );
Gilles Peskine89d8c5c2019-11-26 17:01:59 +01005169 TEST_ASSERT( signature_size <= PSA_SIGNATURE_MAX_SIZE );
Gilles Peskine8cebbba2018-09-27 13:54:18 +02005170 ASSERT_ALLOC( signature, signature_size );
Gilles Peskine9911b022018-06-29 17:30:48 +02005171
5172 /* Perform the signature. */
Ronald Cron5425a212020-08-04 14:58:35 +02005173 PSA_ASSERT( psa_sign_hash( key, alg,
Gilles Peskine89d8c5c2019-11-26 17:01:59 +01005174 input_data->x, input_data->len,
5175 signature, signature_size,
5176 &signature_length ) );
Gilles Peskine9911b022018-06-29 17:30:48 +02005177 /* Check that the signature length looks sensible. */
5178 TEST_ASSERT( signature_length <= signature_size );
5179 TEST_ASSERT( signature_length > 0 );
5180
5181 /* Use the library to verify that the signature is correct. */
Ronald Cron5425a212020-08-04 14:58:35 +02005182 PSA_ASSERT( psa_verify_hash( key, alg,
Gilles Peskine89d8c5c2019-11-26 17:01:59 +01005183 input_data->x, input_data->len,
5184 signature, signature_length ) );
Gilles Peskine9911b022018-06-29 17:30:48 +02005185
5186 if( input_data->len != 0 )
5187 {
5188 /* Flip a bit in the input and verify that the signature is now
5189 * detected as invalid. Flip a bit at the beginning, not at the end,
5190 * because ECDSA may ignore the last few bits of the input. */
5191 input_data->x[0] ^= 1;
Ronald Cron5425a212020-08-04 14:58:35 +02005192 TEST_EQUAL( psa_verify_hash( key, alg,
Gilles Peskine89d8c5c2019-11-26 17:01:59 +01005193 input_data->x, input_data->len,
5194 signature, signature_length ),
Gilles Peskinef812dcf2018-12-18 00:33:25 +01005195 PSA_ERROR_INVALID_SIGNATURE );
Gilles Peskine9911b022018-06-29 17:30:48 +02005196 }
5197
5198exit:
Ronald Cron3a4f0e32020-11-19 17:55:23 +01005199 /*
5200 * Key attributes may have been returned by psa_get_key_attributes()
5201 * thus reset them as required.
5202 */
Gilles Peskinea1ace9c2019-04-26 16:03:33 +02005203 psa_reset_key_attributes( &attributes );
Ronald Cron3a4f0e32020-11-19 17:55:23 +01005204
Ronald Cron5425a212020-08-04 14:58:35 +02005205 psa_destroy_key( key );
Gilles Peskine9911b022018-06-29 17:30:48 +02005206 mbedtls_free( signature );
Gilles Peskine1153e7b2019-05-28 15:10:21 +02005207 PSA_DONE( );
Gilles Peskine9911b022018-06-29 17:30:48 +02005208}
5209/* END_CASE */
5210
5211/* BEGIN_CASE */
gabor-mezei-armb9530232021-04-16 14:21:21 +02005212void verify_hash( int key_type_arg, data_t *key_data,
5213 int alg_arg, data_t *hash_data,
5214 data_t *signature_data )
itayzafrir5c753392018-05-08 11:18:38 +03005215{
Ronald Cron5425a212020-08-04 14:58:35 +02005216 mbedtls_svc_key_id_t key = MBEDTLS_SVC_KEY_ID_INIT;
itayzafrir5c753392018-05-08 11:18:38 +03005217 psa_key_type_t key_type = key_type_arg;
5218 psa_algorithm_t alg = alg_arg;
Gilles Peskine2c2cf0e2019-04-19 19:58:20 +02005219 psa_key_attributes_t attributes = PSA_KEY_ATTRIBUTES_INIT;
itayzafrir5c753392018-05-08 11:18:38 +03005220
Gilles Peskine89d8c5c2019-11-26 17:01:59 +01005221 TEST_ASSERT( signature_data->len <= PSA_SIGNATURE_MAX_SIZE );
Gilles Peskine69c12672018-06-28 00:07:19 +02005222
Gilles Peskine8817f612018-12-18 00:18:46 +01005223 PSA_ASSERT( psa_crypto_init( ) );
itayzafrir5c753392018-05-08 11:18:38 +03005224
Gilles Peskine89d8c5c2019-11-26 17:01:59 +01005225 psa_set_key_usage_flags( &attributes, PSA_KEY_USAGE_VERIFY_HASH );
Gilles Peskine2c2cf0e2019-04-19 19:58:20 +02005226 psa_set_key_algorithm( &attributes, alg );
5227 psa_set_key_type( &attributes, key_type );
itayzafrir5c753392018-05-08 11:18:38 +03005228
Gilles Peskine049c7532019-05-15 20:22:09 +02005229 PSA_ASSERT( psa_import_key( &attributes, key_data->x, key_data->len,
Ronald Cron5425a212020-08-04 14:58:35 +02005230 &key ) );
itayzafrir5c753392018-05-08 11:18:38 +03005231
Ronald Cron5425a212020-08-04 14:58:35 +02005232 PSA_ASSERT( psa_verify_hash( key, alg,
Gilles Peskine89d8c5c2019-11-26 17:01:59 +01005233 hash_data->x, hash_data->len,
5234 signature_data->x, signature_data->len ) );
Gilles Peskine0627f982019-11-26 19:12:16 +01005235
itayzafrir5c753392018-05-08 11:18:38 +03005236exit:
Gilles Peskinea1ace9c2019-04-26 16:03:33 +02005237 psa_reset_key_attributes( &attributes );
Ronald Cron5425a212020-08-04 14:58:35 +02005238 psa_destroy_key( key );
Gilles Peskine1153e7b2019-05-28 15:10:21 +02005239 PSA_DONE( );
itayzafrir5c753392018-05-08 11:18:38 +03005240}
5241/* END_CASE */
Nir Sonnenschein39e59142018-05-02 23:16:26 +03005242
5243/* BEGIN_CASE */
gabor-mezei-armb9530232021-04-16 14:21:21 +02005244void verify_hash_fail( int key_type_arg, data_t *key_data,
5245 int alg_arg, data_t *hash_data,
5246 data_t *signature_data,
5247 int expected_status_arg )
Nir Sonnenschein39e59142018-05-02 23:16:26 +03005248{
Ronald Cron5425a212020-08-04 14:58:35 +02005249 mbedtls_svc_key_id_t key = MBEDTLS_SVC_KEY_ID_INIT;
Nir Sonnenschein39e59142018-05-02 23:16:26 +03005250 psa_key_type_t key_type = key_type_arg;
5251 psa_algorithm_t alg = alg_arg;
Nir Sonnenschein39e59142018-05-02 23:16:26 +03005252 psa_status_t actual_status;
5253 psa_status_t expected_status = expected_status_arg;
Gilles Peskine2c2cf0e2019-04-19 19:58:20 +02005254 psa_key_attributes_t attributes = PSA_KEY_ATTRIBUTES_INIT;
Nir Sonnenschein39e59142018-05-02 23:16:26 +03005255
Gilles Peskine8817f612018-12-18 00:18:46 +01005256 PSA_ASSERT( psa_crypto_init( ) );
Nir Sonnenschein39e59142018-05-02 23:16:26 +03005257
Gilles Peskine89d8c5c2019-11-26 17:01:59 +01005258 psa_set_key_usage_flags( &attributes, PSA_KEY_USAGE_VERIFY_HASH );
Gilles Peskine2c2cf0e2019-04-19 19:58:20 +02005259 psa_set_key_algorithm( &attributes, alg );
5260 psa_set_key_type( &attributes, key_type );
Nir Sonnenscheind7082602018-06-04 16:45:27 +03005261
Gilles Peskine049c7532019-05-15 20:22:09 +02005262 PSA_ASSERT( psa_import_key( &attributes, key_data->x, key_data->len,
Ronald Cron5425a212020-08-04 14:58:35 +02005263 &key ) );
Nir Sonnenschein39e59142018-05-02 23:16:26 +03005264
Ronald Cron5425a212020-08-04 14:58:35 +02005265 actual_status = psa_verify_hash( key, alg,
Gilles Peskine89d8c5c2019-11-26 17:01:59 +01005266 hash_data->x, hash_data->len,
5267 signature_data->x, signature_data->len );
Gilles Peskinefe11b722018-12-18 00:24:04 +01005268 TEST_EQUAL( actual_status, expected_status );
Nir Sonnenschein39e59142018-05-02 23:16:26 +03005269
5270exit:
Gilles Peskinea1ace9c2019-04-26 16:03:33 +02005271 psa_reset_key_attributes( &attributes );
Ronald Cron5425a212020-08-04 14:58:35 +02005272 psa_destroy_key( key );
Gilles Peskine1153e7b2019-05-28 15:10:21 +02005273 PSA_DONE( );
Nir Sonnenschein39e59142018-05-02 23:16:26 +03005274}
5275/* END_CASE */
5276
Nir Sonnenschein39e59142018-05-02 23:16:26 +03005277/* BEGIN_CASE */
gabor-mezei-arm53028482021-04-15 18:19:50 +02005278void sign_message_deterministic( int key_type_arg,
5279 data_t *key_data,
5280 int alg_arg,
5281 data_t *input_data,
5282 data_t *output_data )
5283{
5284 mbedtls_svc_key_id_t key = MBEDTLS_SVC_KEY_ID_INIT;
5285 psa_key_type_t key_type = key_type_arg;
5286 psa_algorithm_t alg = alg_arg;
5287 size_t key_bits;
5288 unsigned char *signature = NULL;
5289 size_t signature_size;
5290 size_t signature_length = 0xdeadbeef;
5291 psa_key_attributes_t attributes = PSA_KEY_ATTRIBUTES_INIT;
5292
5293 PSA_ASSERT( psa_crypto_init( ) );
5294
5295 psa_set_key_usage_flags( &attributes, PSA_KEY_USAGE_SIGN_MESSAGE );
5296 psa_set_key_algorithm( &attributes, alg );
5297 psa_set_key_type( &attributes, key_type );
5298
5299 PSA_ASSERT( psa_import_key( &attributes, key_data->x, key_data->len,
5300 &key ) );
5301 PSA_ASSERT( psa_get_key_attributes( key, &attributes ) );
5302 key_bits = psa_get_key_bits( &attributes );
5303
5304 signature_size = PSA_SIGN_OUTPUT_SIZE( key_type, key_bits, alg );
5305 TEST_ASSERT( signature_size != 0 );
5306 TEST_ASSERT( signature_size <= PSA_SIGNATURE_MAX_SIZE );
5307 ASSERT_ALLOC( signature, signature_size );
5308
5309 PSA_ASSERT( psa_sign_message( key, alg,
5310 input_data->x, input_data->len,
5311 signature, signature_size,
5312 &signature_length ) );
5313
5314 ASSERT_COMPARE( output_data->x, output_data->len,
5315 signature, signature_length );
5316
5317exit:
5318 psa_reset_key_attributes( &attributes );
5319
5320 psa_destroy_key( key );
5321 mbedtls_free( signature );
5322 PSA_DONE( );
5323
5324}
5325/* END_CASE */
5326
5327/* BEGIN_CASE */
5328void sign_message_fail( int key_type_arg,
5329 data_t *key_data,
5330 int alg_arg,
5331 data_t *input_data,
5332 int signature_size_arg,
5333 int expected_status_arg )
5334{
5335 mbedtls_svc_key_id_t key = MBEDTLS_SVC_KEY_ID_INIT;
5336 psa_key_type_t key_type = key_type_arg;
5337 psa_algorithm_t alg = alg_arg;
5338 size_t signature_size = signature_size_arg;
5339 psa_status_t actual_status;
5340 psa_status_t expected_status = expected_status_arg;
5341 unsigned char *signature = NULL;
5342 size_t signature_length = 0xdeadbeef;
5343 psa_key_attributes_t attributes = PSA_KEY_ATTRIBUTES_INIT;
5344
5345 ASSERT_ALLOC( signature, signature_size );
5346
5347 PSA_ASSERT( psa_crypto_init( ) );
5348
5349 psa_set_key_usage_flags( &attributes, PSA_KEY_USAGE_SIGN_MESSAGE );
5350 psa_set_key_algorithm( &attributes, alg );
5351 psa_set_key_type( &attributes, key_type );
5352
5353 PSA_ASSERT( psa_import_key( &attributes, key_data->x, key_data->len,
5354 &key ) );
5355
5356 actual_status = psa_sign_message( key, alg,
5357 input_data->x, input_data->len,
5358 signature, signature_size,
5359 &signature_length );
5360 TEST_EQUAL( actual_status, expected_status );
5361 /* The value of *signature_length is unspecified on error, but
5362 * whatever it is, it should be less than signature_size, so that
5363 * if the caller tries to read *signature_length bytes without
5364 * checking the error code then they don't overflow a buffer. */
5365 TEST_ASSERT( signature_length <= signature_size );
5366
5367exit:
5368 psa_reset_key_attributes( &attributes );
5369 psa_destroy_key( key );
5370 mbedtls_free( signature );
5371 PSA_DONE( );
5372}
5373/* END_CASE */
5374
5375/* BEGIN_CASE */
5376void sign_verify_message( int key_type_arg,
5377 data_t *key_data,
5378 int alg_arg,
5379 data_t *input_data )
5380{
5381 mbedtls_svc_key_id_t key = MBEDTLS_SVC_KEY_ID_INIT;
5382 psa_key_type_t key_type = key_type_arg;
5383 psa_algorithm_t alg = alg_arg;
5384 size_t key_bits;
5385 unsigned char *signature = NULL;
5386 size_t signature_size;
5387 size_t signature_length = 0xdeadbeef;
5388 psa_key_attributes_t attributes = PSA_KEY_ATTRIBUTES_INIT;
5389
5390 PSA_ASSERT( psa_crypto_init( ) );
5391
5392 psa_set_key_usage_flags( &attributes, PSA_KEY_USAGE_SIGN_MESSAGE |
5393 PSA_KEY_USAGE_VERIFY_MESSAGE );
5394 psa_set_key_algorithm( &attributes, alg );
5395 psa_set_key_type( &attributes, key_type );
5396
5397 PSA_ASSERT( psa_import_key( &attributes, key_data->x, key_data->len,
5398 &key ) );
5399 PSA_ASSERT( psa_get_key_attributes( key, &attributes ) );
5400 key_bits = psa_get_key_bits( &attributes );
5401
5402 signature_size = PSA_SIGN_OUTPUT_SIZE( key_type, key_bits, alg );
5403 TEST_ASSERT( signature_size != 0 );
5404 TEST_ASSERT( signature_size <= PSA_SIGNATURE_MAX_SIZE );
5405 ASSERT_ALLOC( signature, signature_size );
5406
5407 PSA_ASSERT( psa_sign_message( key, alg,
5408 input_data->x, input_data->len,
5409 signature, signature_size,
5410 &signature_length ) );
5411 TEST_ASSERT( signature_length <= signature_size );
5412 TEST_ASSERT( signature_length > 0 );
5413
5414 PSA_ASSERT( psa_verify_message( key, alg,
5415 input_data->x, input_data->len,
5416 signature, signature_length ) );
5417
5418 if( input_data->len != 0 )
5419 {
5420 /* Flip a bit in the input and verify that the signature is now
5421 * detected as invalid. Flip a bit at the beginning, not at the end,
5422 * because ECDSA may ignore the last few bits of the input. */
5423 input_data->x[0] ^= 1;
5424 TEST_EQUAL( psa_verify_message( key, alg,
5425 input_data->x, input_data->len,
5426 signature, signature_length ),
5427 PSA_ERROR_INVALID_SIGNATURE );
5428 }
5429
5430exit:
5431 psa_reset_key_attributes( &attributes );
5432
5433 psa_destroy_key( key );
5434 mbedtls_free( signature );
5435 PSA_DONE( );
5436}
5437/* END_CASE */
5438
5439/* BEGIN_CASE */
5440void verify_message( int key_type_arg,
5441 data_t *key_data,
5442 int alg_arg,
5443 data_t *input_data,
5444 data_t *signature_data )
5445{
5446 mbedtls_svc_key_id_t key = MBEDTLS_SVC_KEY_ID_INIT;
5447 psa_key_type_t key_type = key_type_arg;
5448 psa_algorithm_t alg = alg_arg;
5449 psa_key_attributes_t attributes = PSA_KEY_ATTRIBUTES_INIT;
5450
5451 TEST_ASSERT( signature_data->len <= PSA_SIGNATURE_MAX_SIZE );
5452
5453 PSA_ASSERT( psa_crypto_init( ) );
5454
5455 psa_set_key_usage_flags( &attributes, PSA_KEY_USAGE_VERIFY_MESSAGE );
5456 psa_set_key_algorithm( &attributes, alg );
5457 psa_set_key_type( &attributes, key_type );
5458
5459 PSA_ASSERT( psa_import_key( &attributes, key_data->x, key_data->len,
5460 &key ) );
5461
5462 PSA_ASSERT( psa_verify_message( key, alg,
5463 input_data->x, input_data->len,
5464 signature_data->x, signature_data->len ) );
5465
5466exit:
5467 psa_reset_key_attributes( &attributes );
5468 psa_destroy_key( key );
5469 PSA_DONE( );
5470}
5471/* END_CASE */
5472
5473/* BEGIN_CASE */
5474void verify_message_fail( int key_type_arg,
5475 data_t *key_data,
5476 int alg_arg,
5477 data_t *hash_data,
5478 data_t *signature_data,
5479 int expected_status_arg )
5480{
5481 mbedtls_svc_key_id_t key = MBEDTLS_SVC_KEY_ID_INIT;
5482 psa_key_type_t key_type = key_type_arg;
5483 psa_algorithm_t alg = alg_arg;
5484 psa_status_t actual_status;
5485 psa_status_t expected_status = expected_status_arg;
5486 psa_key_attributes_t attributes = PSA_KEY_ATTRIBUTES_INIT;
5487
5488 PSA_ASSERT( psa_crypto_init( ) );
5489
5490 psa_set_key_usage_flags( &attributes, PSA_KEY_USAGE_VERIFY_MESSAGE );
5491 psa_set_key_algorithm( &attributes, alg );
5492 psa_set_key_type( &attributes, key_type );
5493
5494 PSA_ASSERT( psa_import_key( &attributes, key_data->x, key_data->len,
5495 &key ) );
5496
5497 actual_status = psa_verify_message( key, alg,
5498 hash_data->x, hash_data->len,
5499 signature_data->x,
5500 signature_data->len );
5501 TEST_EQUAL( actual_status, expected_status );
5502
5503exit:
5504 psa_reset_key_attributes( &attributes );
5505 psa_destroy_key( key );
5506 PSA_DONE( );
5507}
5508/* END_CASE */
5509
5510/* BEGIN_CASE */
Gilles Peskine656896e2018-06-29 19:12:28 +02005511void asymmetric_encrypt( int key_type_arg,
5512 data_t *key_data,
5513 int alg_arg,
5514 data_t *input_data,
Gilles Peskine68428122018-06-30 18:42:41 +02005515 data_t *label,
Gilles Peskine656896e2018-06-29 19:12:28 +02005516 int expected_output_length_arg,
5517 int expected_status_arg )
5518{
Ronald Cron5425a212020-08-04 14:58:35 +02005519 mbedtls_svc_key_id_t key = MBEDTLS_SVC_KEY_ID_INIT;
Gilles Peskine656896e2018-06-29 19:12:28 +02005520 psa_key_type_t key_type = key_type_arg;
5521 psa_algorithm_t alg = alg_arg;
5522 size_t expected_output_length = expected_output_length_arg;
5523 size_t key_bits;
5524 unsigned char *output = NULL;
5525 size_t output_size;
5526 size_t output_length = ~0;
5527 psa_status_t actual_status;
5528 psa_status_t expected_status = expected_status_arg;
Gilles Peskine8c8f2ab2019-04-18 21:44:46 +02005529 psa_key_attributes_t attributes = PSA_KEY_ATTRIBUTES_INIT;
Gilles Peskine656896e2018-06-29 19:12:28 +02005530
Gilles Peskine8817f612018-12-18 00:18:46 +01005531 PSA_ASSERT( psa_crypto_init( ) );
Gilles Peskinebdf309c2018-12-03 15:36:32 +01005532
Gilles Peskine656896e2018-06-29 19:12:28 +02005533 /* Import the key */
Gilles Peskine2c2cf0e2019-04-19 19:58:20 +02005534 psa_set_key_usage_flags( &attributes, PSA_KEY_USAGE_ENCRYPT );
5535 psa_set_key_algorithm( &attributes, alg );
5536 psa_set_key_type( &attributes, key_type );
Gilles Peskine049c7532019-05-15 20:22:09 +02005537 PSA_ASSERT( psa_import_key( &attributes, key_data->x, key_data->len,
Ronald Cron5425a212020-08-04 14:58:35 +02005538 &key ) );
Gilles Peskine656896e2018-06-29 19:12:28 +02005539
5540 /* Determine the maximum output length */
Ronald Cron5425a212020-08-04 14:58:35 +02005541 PSA_ASSERT( psa_get_key_attributes( key, &attributes ) );
Gilles Peskine8c8f2ab2019-04-18 21:44:46 +02005542 key_bits = psa_get_key_bits( &attributes );
gabor-mezei-armceface22021-01-21 12:26:17 +01005543
Gilles Peskine656896e2018-06-29 19:12:28 +02005544 output_size = PSA_ASYMMETRIC_ENCRYPT_OUTPUT_SIZE( key_type, key_bits, alg );
gabor-mezei-armceface22021-01-21 12:26:17 +01005545 TEST_ASSERT( output_size <= PSA_ASYMMETRIC_ENCRYPT_OUTPUT_MAX_SIZE );
Gilles Peskine8cebbba2018-09-27 13:54:18 +02005546 ASSERT_ALLOC( output, output_size );
Gilles Peskine656896e2018-06-29 19:12:28 +02005547
5548 /* Encrypt the input */
Ronald Cron5425a212020-08-04 14:58:35 +02005549 actual_status = psa_asymmetric_encrypt( key, alg,
Gilles Peskine656896e2018-06-29 19:12:28 +02005550 input_data->x, input_data->len,
Gilles Peskine68428122018-06-30 18:42:41 +02005551 label->x, label->len,
Gilles Peskine656896e2018-06-29 19:12:28 +02005552 output, output_size,
5553 &output_length );
Gilles Peskinefe11b722018-12-18 00:24:04 +01005554 TEST_EQUAL( actual_status, expected_status );
5555 TEST_EQUAL( output_length, expected_output_length );
Gilles Peskine656896e2018-06-29 19:12:28 +02005556
Gilles Peskine68428122018-06-30 18:42:41 +02005557 /* If the label is empty, the test framework puts a non-null pointer
5558 * in label->x. Test that a null pointer works as well. */
5559 if( label->len == 0 )
5560 {
5561 output_length = ~0;
Gilles Peskinef7ab5ad2018-09-26 18:19:24 +02005562 if( output_size != 0 )
5563 memset( output, 0, output_size );
Ronald Cron5425a212020-08-04 14:58:35 +02005564 actual_status = psa_asymmetric_encrypt( key, alg,
Gilles Peskine68428122018-06-30 18:42:41 +02005565 input_data->x, input_data->len,
5566 NULL, label->len,
5567 output, output_size,
5568 &output_length );
Gilles Peskinefe11b722018-12-18 00:24:04 +01005569 TEST_EQUAL( actual_status, expected_status );
5570 TEST_EQUAL( output_length, expected_output_length );
Gilles Peskine68428122018-06-30 18:42:41 +02005571 }
5572
Gilles Peskine656896e2018-06-29 19:12:28 +02005573exit:
Ronald Cron3a4f0e32020-11-19 17:55:23 +01005574 /*
5575 * Key attributes may have been returned by psa_get_key_attributes()
5576 * thus reset them as required.
5577 */
Gilles Peskinea1ace9c2019-04-26 16:03:33 +02005578 psa_reset_key_attributes( &attributes );
Ronald Cron3a4f0e32020-11-19 17:55:23 +01005579
Ronald Cron5425a212020-08-04 14:58:35 +02005580 psa_destroy_key( key );
Gilles Peskine656896e2018-06-29 19:12:28 +02005581 mbedtls_free( output );
Gilles Peskine1153e7b2019-05-28 15:10:21 +02005582 PSA_DONE( );
Gilles Peskine656896e2018-06-29 19:12:28 +02005583}
5584/* END_CASE */
5585
5586/* BEGIN_CASE */
Gilles Peskine68428122018-06-30 18:42:41 +02005587void asymmetric_encrypt_decrypt( int key_type_arg,
5588 data_t *key_data,
5589 int alg_arg,
5590 data_t *input_data,
5591 data_t *label )
Nir Sonnenschein39e59142018-05-02 23:16:26 +03005592{
Ronald Cron5425a212020-08-04 14:58:35 +02005593 mbedtls_svc_key_id_t key = MBEDTLS_SVC_KEY_ID_INIT;
Nir Sonnenschein39e59142018-05-02 23:16:26 +03005594 psa_key_type_t key_type = key_type_arg;
5595 psa_algorithm_t alg = alg_arg;
Gilles Peskine55c94dd2018-06-30 18:54:48 +02005596 size_t key_bits;
Nir Sonnenschein39e59142018-05-02 23:16:26 +03005597 unsigned char *output = NULL;
Gilles Peskine55c94dd2018-06-30 18:54:48 +02005598 size_t output_size;
5599 size_t output_length = ~0;
Nir Sonnenschein0f3bdbd2018-05-02 23:56:12 +03005600 unsigned char *output2 = NULL;
Gilles Peskine55c94dd2018-06-30 18:54:48 +02005601 size_t output2_size;
5602 size_t output2_length = ~0;
Gilles Peskine8c8f2ab2019-04-18 21:44:46 +02005603 psa_key_attributes_t attributes = PSA_KEY_ATTRIBUTES_INIT;
Nir Sonnenschein39e59142018-05-02 23:16:26 +03005604
Gilles Peskine8817f612018-12-18 00:18:46 +01005605 PSA_ASSERT( psa_crypto_init( ) );
Nir Sonnenschein39e59142018-05-02 23:16:26 +03005606
Gilles Peskine2c2cf0e2019-04-19 19:58:20 +02005607 psa_set_key_usage_flags( &attributes, PSA_KEY_USAGE_ENCRYPT | PSA_KEY_USAGE_DECRYPT );
5608 psa_set_key_algorithm( &attributes, alg );
5609 psa_set_key_type( &attributes, key_type );
Nir Sonnenscheind7082602018-06-04 16:45:27 +03005610
Gilles Peskine049c7532019-05-15 20:22:09 +02005611 PSA_ASSERT( psa_import_key( &attributes, key_data->x, key_data->len,
Ronald Cron5425a212020-08-04 14:58:35 +02005612 &key ) );
Gilles Peskine55c94dd2018-06-30 18:54:48 +02005613
5614 /* Determine the maximum ciphertext length */
Ronald Cron5425a212020-08-04 14:58:35 +02005615 PSA_ASSERT( psa_get_key_attributes( key, &attributes ) );
Gilles Peskine8c8f2ab2019-04-18 21:44:46 +02005616 key_bits = psa_get_key_bits( &attributes );
gabor-mezei-armceface22021-01-21 12:26:17 +01005617
Gilles Peskine55c94dd2018-06-30 18:54:48 +02005618 output_size = PSA_ASYMMETRIC_ENCRYPT_OUTPUT_SIZE( key_type, key_bits, alg );
gabor-mezei-armceface22021-01-21 12:26:17 +01005619 TEST_ASSERT( output_size <= PSA_ASYMMETRIC_ENCRYPT_OUTPUT_MAX_SIZE );
Gilles Peskine8cebbba2018-09-27 13:54:18 +02005620 ASSERT_ALLOC( output, output_size );
gabor-mezei-armceface22021-01-21 12:26:17 +01005621
Gilles Peskine55c94dd2018-06-30 18:54:48 +02005622 output2_size = input_data->len;
gabor-mezei-armceface22021-01-21 12:26:17 +01005623 TEST_ASSERT( output2_size <=
5624 PSA_ASYMMETRIC_DECRYPT_OUTPUT_SIZE( key_type, key_bits, alg ) );
5625 TEST_ASSERT( output2_size <= PSA_ASYMMETRIC_DECRYPT_OUTPUT_MAX_SIZE );
Gilles Peskine8cebbba2018-09-27 13:54:18 +02005626 ASSERT_ALLOC( output2, output2_size );
Gilles Peskine55c94dd2018-06-30 18:54:48 +02005627
Gilles Peskineeebd7382018-06-08 18:11:54 +02005628 /* We test encryption by checking that encrypt-then-decrypt gives back
5629 * the original plaintext because of the non-optional random
5630 * part of encryption process which prevents using fixed vectors. */
Ronald Cron5425a212020-08-04 14:58:35 +02005631 PSA_ASSERT( psa_asymmetric_encrypt( key, alg,
Gilles Peskine8817f612018-12-18 00:18:46 +01005632 input_data->x, input_data->len,
5633 label->x, label->len,
5634 output, output_size,
5635 &output_length ) );
Gilles Peskine55c94dd2018-06-30 18:54:48 +02005636 /* We don't know what ciphertext length to expect, but check that
5637 * it looks sensible. */
5638 TEST_ASSERT( output_length <= output_size );
Nir Sonnenschein0f3bdbd2018-05-02 23:56:12 +03005639
Ronald Cron5425a212020-08-04 14:58:35 +02005640 PSA_ASSERT( psa_asymmetric_decrypt( key, alg,
Gilles Peskine8817f612018-12-18 00:18:46 +01005641 output, output_length,
5642 label->x, label->len,
5643 output2, output2_size,
5644 &output2_length ) );
Gilles Peskinebd7dea92018-09-27 13:57:19 +02005645 ASSERT_COMPARE( input_data->x, input_data->len,
5646 output2, output2_length );
Nir Sonnenschein39e59142018-05-02 23:16:26 +03005647
5648exit:
Ronald Cron3a4f0e32020-11-19 17:55:23 +01005649 /*
5650 * Key attributes may have been returned by psa_get_key_attributes()
5651 * thus reset them as required.
5652 */
Gilles Peskinea1ace9c2019-04-26 16:03:33 +02005653 psa_reset_key_attributes( &attributes );
Ronald Cron3a4f0e32020-11-19 17:55:23 +01005654
Ronald Cron5425a212020-08-04 14:58:35 +02005655 psa_destroy_key( key );
itayzafrir3e02b3b2018-06-12 17:06:52 +03005656 mbedtls_free( output );
5657 mbedtls_free( output2 );
Gilles Peskine1153e7b2019-05-28 15:10:21 +02005658 PSA_DONE( );
Nir Sonnenschein39e59142018-05-02 23:16:26 +03005659}
5660/* END_CASE */
5661
Nir Sonnenschein39e59142018-05-02 23:16:26 +03005662/* BEGIN_CASE */
Gilles Peskine68428122018-06-30 18:42:41 +02005663void asymmetric_decrypt( int key_type_arg,
5664 data_t *key_data,
5665 int alg_arg,
5666 data_t *input_data,
5667 data_t *label,
Gilles Peskine66763a02018-06-29 21:54:10 +02005668 data_t *expected_data )
Nir Sonnenschein39e59142018-05-02 23:16:26 +03005669{
Ronald Cron5425a212020-08-04 14:58:35 +02005670 mbedtls_svc_key_id_t key = MBEDTLS_SVC_KEY_ID_INIT;
Nir Sonnenschein39e59142018-05-02 23:16:26 +03005671 psa_key_type_t key_type = key_type_arg;
5672 psa_algorithm_t alg = alg_arg;
gabor-mezei-armceface22021-01-21 12:26:17 +01005673 size_t key_bits;
Nir Sonnenschein39e59142018-05-02 23:16:26 +03005674 unsigned char *output = NULL;
Nir Sonnenscheind70bc482018-06-04 16:31:13 +03005675 size_t output_size = 0;
Gilles Peskine55c94dd2018-06-30 18:54:48 +02005676 size_t output_length = ~0;
Gilles Peskine2c2cf0e2019-04-19 19:58:20 +02005677 psa_key_attributes_t attributes = PSA_KEY_ATTRIBUTES_INIT;
Nir Sonnenschein39e59142018-05-02 23:16:26 +03005678
Gilles Peskine8817f612018-12-18 00:18:46 +01005679 PSA_ASSERT( psa_crypto_init( ) );
Nir Sonnenschein39e59142018-05-02 23:16:26 +03005680
Gilles Peskine2c2cf0e2019-04-19 19:58:20 +02005681 psa_set_key_usage_flags( &attributes, PSA_KEY_USAGE_DECRYPT );
5682 psa_set_key_algorithm( &attributes, alg );
5683 psa_set_key_type( &attributes, key_type );
Nir Sonnenscheind7082602018-06-04 16:45:27 +03005684
Gilles Peskine049c7532019-05-15 20:22:09 +02005685 PSA_ASSERT( psa_import_key( &attributes, key_data->x, key_data->len,
Ronald Cron5425a212020-08-04 14:58:35 +02005686 &key ) );
Nir Sonnenschein39e59142018-05-02 23:16:26 +03005687
gabor-mezei-armceface22021-01-21 12:26:17 +01005688 PSA_ASSERT( psa_get_key_attributes( key, &attributes ) );
5689 key_bits = psa_get_key_bits( &attributes );
5690
5691 /* Determine the maximum ciphertext length */
5692 output_size = PSA_ASYMMETRIC_DECRYPT_OUTPUT_SIZE( key_type, key_bits, alg );
5693 TEST_ASSERT( output_size <= PSA_ASYMMETRIC_DECRYPT_OUTPUT_MAX_SIZE );
5694 ASSERT_ALLOC( output, output_size );
5695
Ronald Cron5425a212020-08-04 14:58:35 +02005696 PSA_ASSERT( psa_asymmetric_decrypt( key, alg,
Gilles Peskine8817f612018-12-18 00:18:46 +01005697 input_data->x, input_data->len,
5698 label->x, label->len,
5699 output,
5700 output_size,
5701 &output_length ) );
Gilles Peskinebd7dea92018-09-27 13:57:19 +02005702 ASSERT_COMPARE( expected_data->x, expected_data->len,
5703 output, output_length );
Nir Sonnenschein39e59142018-05-02 23:16:26 +03005704
Gilles Peskine68428122018-06-30 18:42:41 +02005705 /* If the label is empty, the test framework puts a non-null pointer
5706 * in label->x. Test that a null pointer works as well. */
5707 if( label->len == 0 )
5708 {
5709 output_length = ~0;
Gilles Peskinef7ab5ad2018-09-26 18:19:24 +02005710 if( output_size != 0 )
5711 memset( output, 0, output_size );
Ronald Cron5425a212020-08-04 14:58:35 +02005712 PSA_ASSERT( psa_asymmetric_decrypt( key, alg,
Gilles Peskine8817f612018-12-18 00:18:46 +01005713 input_data->x, input_data->len,
5714 NULL, label->len,
5715 output,
5716 output_size,
5717 &output_length ) );
Gilles Peskinebd7dea92018-09-27 13:57:19 +02005718 ASSERT_COMPARE( expected_data->x, expected_data->len,
5719 output, output_length );
Gilles Peskine68428122018-06-30 18:42:41 +02005720 }
5721
Nir Sonnenschein39e59142018-05-02 23:16:26 +03005722exit:
Gilles Peskinea1ace9c2019-04-26 16:03:33 +02005723 psa_reset_key_attributes( &attributes );
Ronald Cron5425a212020-08-04 14:58:35 +02005724 psa_destroy_key( key );
itayzafrir3e02b3b2018-06-12 17:06:52 +03005725 mbedtls_free( output );
Gilles Peskine1153e7b2019-05-28 15:10:21 +02005726 PSA_DONE( );
Nir Sonnenschein39e59142018-05-02 23:16:26 +03005727}
5728/* END_CASE */
5729
Nir Sonnenschein39e59142018-05-02 23:16:26 +03005730/* BEGIN_CASE */
Gilles Peskine68428122018-06-30 18:42:41 +02005731void asymmetric_decrypt_fail( int key_type_arg,
5732 data_t *key_data,
5733 int alg_arg,
5734 data_t *input_data,
5735 data_t *label,
Jaeden Amerof8daab72019-02-06 12:57:46 +00005736 int output_size_arg,
Gilles Peskine2d277862018-06-18 15:41:12 +02005737 int expected_status_arg )
Nir Sonnenschein39e59142018-05-02 23:16:26 +03005738{
Ronald Cron5425a212020-08-04 14:58:35 +02005739 mbedtls_svc_key_id_t key = MBEDTLS_SVC_KEY_ID_INIT;
Nir Sonnenschein39e59142018-05-02 23:16:26 +03005740 psa_key_type_t key_type = key_type_arg;
5741 psa_algorithm_t alg = alg_arg;
Nir Sonnenschein39e59142018-05-02 23:16:26 +03005742 unsigned char *output = NULL;
Jaeden Amerof8daab72019-02-06 12:57:46 +00005743 size_t output_size = output_size_arg;
Gilles Peskine55c94dd2018-06-30 18:54:48 +02005744 size_t output_length = ~0;
Nir Sonnenschein39e59142018-05-02 23:16:26 +03005745 psa_status_t actual_status;
5746 psa_status_t expected_status = expected_status_arg;
Gilles Peskine2c2cf0e2019-04-19 19:58:20 +02005747 psa_key_attributes_t attributes = PSA_KEY_ATTRIBUTES_INIT;
Nir Sonnenschein39e59142018-05-02 23:16:26 +03005748
Gilles Peskine8cebbba2018-09-27 13:54:18 +02005749 ASSERT_ALLOC( output, output_size );
Gilles Peskine5b051bc2018-05-31 13:25:48 +02005750
Gilles Peskine8817f612018-12-18 00:18:46 +01005751 PSA_ASSERT( psa_crypto_init( ) );
Nir Sonnenschein39e59142018-05-02 23:16:26 +03005752
Gilles Peskine2c2cf0e2019-04-19 19:58:20 +02005753 psa_set_key_usage_flags( &attributes, PSA_KEY_USAGE_DECRYPT );
5754 psa_set_key_algorithm( &attributes, alg );
5755 psa_set_key_type( &attributes, key_type );
Nir Sonnenscheind7082602018-06-04 16:45:27 +03005756
Gilles Peskine049c7532019-05-15 20:22:09 +02005757 PSA_ASSERT( psa_import_key( &attributes, key_data->x, key_data->len,
Ronald Cron5425a212020-08-04 14:58:35 +02005758 &key ) );
Nir Sonnenschein39e59142018-05-02 23:16:26 +03005759
Ronald Cron5425a212020-08-04 14:58:35 +02005760 actual_status = psa_asymmetric_decrypt( key, alg,
Gilles Peskine4abf7412018-06-18 16:35:34 +02005761 input_data->x, input_data->len,
Gilles Peskine68428122018-06-30 18:42:41 +02005762 label->x, label->len,
Gilles Peskine4abf7412018-06-18 16:35:34 +02005763 output, output_size,
Gilles Peskine2d277862018-06-18 15:41:12 +02005764 &output_length );
Gilles Peskinefe11b722018-12-18 00:24:04 +01005765 TEST_EQUAL( actual_status, expected_status );
Gilles Peskine55c94dd2018-06-30 18:54:48 +02005766 TEST_ASSERT( output_length <= output_size );
Nir Sonnenschein39e59142018-05-02 23:16:26 +03005767
Gilles Peskine68428122018-06-30 18:42:41 +02005768 /* If the label is empty, the test framework puts a non-null pointer
5769 * in label->x. Test that a null pointer works as well. */
5770 if( label->len == 0 )
5771 {
5772 output_length = ~0;
Gilles Peskinef7ab5ad2018-09-26 18:19:24 +02005773 if( output_size != 0 )
5774 memset( output, 0, output_size );
Ronald Cron5425a212020-08-04 14:58:35 +02005775 actual_status = psa_asymmetric_decrypt( key, alg,
Gilles Peskine68428122018-06-30 18:42:41 +02005776 input_data->x, input_data->len,
5777 NULL, label->len,
5778 output, output_size,
5779 &output_length );
Gilles Peskinefe11b722018-12-18 00:24:04 +01005780 TEST_EQUAL( actual_status, expected_status );
Gilles Peskine55c94dd2018-06-30 18:54:48 +02005781 TEST_ASSERT( output_length <= output_size );
Gilles Peskine68428122018-06-30 18:42:41 +02005782 }
5783
Nir Sonnenschein39e59142018-05-02 23:16:26 +03005784exit:
Gilles Peskinea1ace9c2019-04-26 16:03:33 +02005785 psa_reset_key_attributes( &attributes );
Ronald Cron5425a212020-08-04 14:58:35 +02005786 psa_destroy_key( key );
Gilles Peskine2d277862018-06-18 15:41:12 +02005787 mbedtls_free( output );
Gilles Peskine1153e7b2019-05-28 15:10:21 +02005788 PSA_DONE( );
Nir Sonnenschein39e59142018-05-02 23:16:26 +03005789}
Gilles Peskine5b051bc2018-05-31 13:25:48 +02005790/* END_CASE */
Gilles Peskine05d69892018-06-19 22:00:52 +02005791
5792/* BEGIN_CASE */
Gilles Peskinecbe66502019-05-16 16:59:18 +02005793void key_derivation_init( )
Jaeden Amerod94d6712019-01-04 14:11:48 +00005794{
5795 /* Test each valid way of initializing the object, except for `= {0}`, as
5796 * Clang 5 complains when `-Wmissing-field-initializers` is used, even
5797 * though it's OK by the C standard. We could test for this, but we'd need
5798 * to supress the Clang warning for the test. */
Jaeden Amero5229bbb2019-02-07 16:33:37 +00005799 size_t capacity;
Gilles Peskinea99d3fb2019-05-16 15:28:51 +02005800 psa_key_derivation_operation_t func = psa_key_derivation_operation_init( );
5801 psa_key_derivation_operation_t init = PSA_KEY_DERIVATION_OPERATION_INIT;
5802 psa_key_derivation_operation_t zero;
Jaeden Amerod94d6712019-01-04 14:11:48 +00005803
5804 memset( &zero, 0, sizeof( zero ) );
5805
Gilles Peskine51ae0e42019-05-16 17:31:03 +02005806 /* A default operation should not be able to report its capacity. */
Gilles Peskinea99d3fb2019-05-16 15:28:51 +02005807 TEST_EQUAL( psa_key_derivation_get_capacity( &func, &capacity ),
Jaeden Amerocf2010c2019-02-15 13:05:49 +00005808 PSA_ERROR_BAD_STATE );
Gilles Peskinea99d3fb2019-05-16 15:28:51 +02005809 TEST_EQUAL( psa_key_derivation_get_capacity( &init, &capacity ),
Jaeden Amerocf2010c2019-02-15 13:05:49 +00005810 PSA_ERROR_BAD_STATE );
Gilles Peskinea99d3fb2019-05-16 15:28:51 +02005811 TEST_EQUAL( psa_key_derivation_get_capacity( &zero, &capacity ),
Jaeden Amerocf2010c2019-02-15 13:05:49 +00005812 PSA_ERROR_BAD_STATE );
Jaeden Amero5229bbb2019-02-07 16:33:37 +00005813
Gilles Peskine51ae0e42019-05-16 17:31:03 +02005814 /* A default operation should be abortable without error. */
Gilles Peskinea99d3fb2019-05-16 15:28:51 +02005815 PSA_ASSERT( psa_key_derivation_abort(&func) );
5816 PSA_ASSERT( psa_key_derivation_abort(&init) );
5817 PSA_ASSERT( psa_key_derivation_abort(&zero) );
Jaeden Amerod94d6712019-01-04 14:11:48 +00005818}
5819/* END_CASE */
5820
Janos Follath16de4a42019-06-13 16:32:24 +01005821/* BEGIN_CASE */
5822void derive_setup( int alg_arg, int expected_status_arg )
Gilles Peskineea0fb492018-07-12 17:17:20 +02005823{
Gilles Peskineea0fb492018-07-12 17:17:20 +02005824 psa_algorithm_t alg = alg_arg;
Gilles Peskineea0fb492018-07-12 17:17:20 +02005825 psa_status_t expected_status = expected_status_arg;
Gilles Peskine51ae0e42019-05-16 17:31:03 +02005826 psa_key_derivation_operation_t operation = PSA_KEY_DERIVATION_OPERATION_INIT;
Gilles Peskineea0fb492018-07-12 17:17:20 +02005827
Gilles Peskine8817f612018-12-18 00:18:46 +01005828 PSA_ASSERT( psa_crypto_init( ) );
Gilles Peskineea0fb492018-07-12 17:17:20 +02005829
Janos Follath16de4a42019-06-13 16:32:24 +01005830 TEST_EQUAL( psa_key_derivation_setup( &operation, alg ),
Gilles Peskinef812dcf2018-12-18 00:33:25 +01005831 expected_status );
Gilles Peskineea0fb492018-07-12 17:17:20 +02005832
5833exit:
Gilles Peskine51ae0e42019-05-16 17:31:03 +02005834 psa_key_derivation_abort( &operation );
Gilles Peskine1153e7b2019-05-28 15:10:21 +02005835 PSA_DONE( );
Gilles Peskineea0fb492018-07-12 17:17:20 +02005836}
5837/* END_CASE */
5838
Janos Follathaf3c2a02019-06-12 12:34:34 +01005839/* BEGIN_CASE */
Janos Follatha27c9272019-06-14 09:59:36 +01005840void derive_set_capacity( int alg_arg, int capacity_arg,
5841 int expected_status_arg )
5842{
5843 psa_algorithm_t alg = alg_arg;
5844 size_t capacity = capacity_arg;
5845 psa_status_t expected_status = expected_status_arg;
5846 psa_key_derivation_operation_t operation = PSA_KEY_DERIVATION_OPERATION_INIT;
5847
5848 PSA_ASSERT( psa_crypto_init( ) );
5849
5850 PSA_ASSERT( psa_key_derivation_setup( &operation, alg ) );
5851
5852 TEST_EQUAL( psa_key_derivation_set_capacity( &operation, capacity ),
5853 expected_status );
5854
5855exit:
5856 psa_key_derivation_abort( &operation );
5857 PSA_DONE( );
5858}
5859/* END_CASE */
5860
5861/* BEGIN_CASE */
Janos Follathaf3c2a02019-06-12 12:34:34 +01005862void derive_input( int alg_arg,
Gilles Peskine6842ba42019-09-23 13:49:33 +02005863 int step_arg1, int key_type_arg1, data_t *input1,
Janos Follathaf3c2a02019-06-12 12:34:34 +01005864 int expected_status_arg1,
Gilles Peskine2058c072019-09-24 17:19:33 +02005865 int step_arg2, int key_type_arg2, data_t *input2,
Janos Follathaf3c2a02019-06-12 12:34:34 +01005866 int expected_status_arg2,
Gilles Peskine2058c072019-09-24 17:19:33 +02005867 int step_arg3, int key_type_arg3, data_t *input3,
Gilles Peskine1a2904c2019-09-24 17:45:07 +02005868 int expected_status_arg3,
5869 int output_key_type_arg, int expected_output_status_arg )
Janos Follathaf3c2a02019-06-12 12:34:34 +01005870{
5871 psa_algorithm_t alg = alg_arg;
Gilles Peskine6842ba42019-09-23 13:49:33 +02005872 psa_key_derivation_step_t steps[] = {step_arg1, step_arg2, step_arg3};
5873 psa_key_type_t key_types[] = {key_type_arg1, key_type_arg2, key_type_arg3};
Janos Follathaf3c2a02019-06-12 12:34:34 +01005874 psa_status_t expected_statuses[] = {expected_status_arg1,
5875 expected_status_arg2,
5876 expected_status_arg3};
5877 data_t *inputs[] = {input1, input2, input3};
Ronald Cron5425a212020-08-04 14:58:35 +02005878 mbedtls_svc_key_id_t keys[] = { MBEDTLS_SVC_KEY_ID_INIT,
5879 MBEDTLS_SVC_KEY_ID_INIT,
5880 MBEDTLS_SVC_KEY_ID_INIT };
Janos Follathaf3c2a02019-06-12 12:34:34 +01005881 psa_key_derivation_operation_t operation = PSA_KEY_DERIVATION_OPERATION_INIT;
5882 psa_key_attributes_t attributes = PSA_KEY_ATTRIBUTES_INIT;
5883 size_t i;
Gilles Peskine1a2904c2019-09-24 17:45:07 +02005884 psa_key_type_t output_key_type = output_key_type_arg;
Ronald Cron5425a212020-08-04 14:58:35 +02005885 mbedtls_svc_key_id_t output_key = MBEDTLS_SVC_KEY_ID_INIT;
Gilles Peskine1a2904c2019-09-24 17:45:07 +02005886 psa_status_t expected_output_status = expected_output_status_arg;
5887 psa_status_t actual_output_status;
Janos Follathaf3c2a02019-06-12 12:34:34 +01005888
5889 PSA_ASSERT( psa_crypto_init( ) );
5890
5891 psa_set_key_usage_flags( &attributes, PSA_KEY_USAGE_DERIVE );
5892 psa_set_key_algorithm( &attributes, alg );
Janos Follathaf3c2a02019-06-12 12:34:34 +01005893
5894 PSA_ASSERT( psa_key_derivation_setup( &operation, alg ) );
5895
5896 for( i = 0; i < ARRAY_LENGTH( steps ); i++ )
5897 {
Gilles Peskine4023c012021-05-27 13:21:20 +02005898 mbedtls_test_set_step( i );
5899 if( steps[i] == 0 )
5900 {
5901 /* Skip this step */
5902 }
5903 else if( key_types[i] != PSA_KEY_TYPE_NONE )
Janos Follathaf3c2a02019-06-12 12:34:34 +01005904 {
Gilles Peskine6842ba42019-09-23 13:49:33 +02005905 psa_set_key_type( &attributes, key_types[i] );
5906 PSA_ASSERT( psa_import_key( &attributes,
5907 inputs[i]->x, inputs[i]->len,
Ronald Cron5425a212020-08-04 14:58:35 +02005908 &keys[i] ) );
Steven Cooreman0ee0d522020-10-05 16:03:42 +02005909 if( PSA_KEY_TYPE_IS_KEY_PAIR( key_types[i] ) &&
5910 steps[i] == PSA_KEY_DERIVATION_INPUT_SECRET )
5911 {
5912 // When taking a private key as secret input, use key agreement
5913 // to add the shared secret to the derivation
Gilles Peskinec18e25f2021-02-12 23:48:20 +01005914 TEST_EQUAL( mbedtls_test_psa_key_agreement_with_self(
5915 &operation, keys[i] ),
Steven Cooreman0ee0d522020-10-05 16:03:42 +02005916 expected_statuses[i] );
5917 }
5918 else
5919 {
5920 TEST_EQUAL( psa_key_derivation_input_key( &operation, steps[i],
Ronald Cron5425a212020-08-04 14:58:35 +02005921 keys[i] ),
Steven Cooreman0ee0d522020-10-05 16:03:42 +02005922 expected_statuses[i] );
5923 }
Gilles Peskine6842ba42019-09-23 13:49:33 +02005924 }
5925 else
5926 {
5927 TEST_EQUAL( psa_key_derivation_input_bytes(
5928 &operation, steps[i],
5929 inputs[i]->x, inputs[i]->len ),
5930 expected_statuses[i] );
Janos Follathaf3c2a02019-06-12 12:34:34 +01005931 }
5932 }
5933
Gilles Peskine1a2904c2019-09-24 17:45:07 +02005934 if( output_key_type != PSA_KEY_TYPE_NONE )
5935 {
5936 psa_reset_key_attributes( &attributes );
Dave Rodgman491d8492021-11-16 12:12:49 +00005937 psa_set_key_type( &attributes, output_key_type );
Gilles Peskine1a2904c2019-09-24 17:45:07 +02005938 psa_set_key_bits( &attributes, 8 );
5939 actual_output_status =
5940 psa_key_derivation_output_key( &attributes, &operation,
Ronald Cron5425a212020-08-04 14:58:35 +02005941 &output_key );
Gilles Peskine1a2904c2019-09-24 17:45:07 +02005942 }
5943 else
5944 {
5945 uint8_t buffer[1];
5946 actual_output_status =
5947 psa_key_derivation_output_bytes( &operation,
5948 buffer, sizeof( buffer ) );
5949 }
5950 TEST_EQUAL( actual_output_status, expected_output_status );
5951
Janos Follathaf3c2a02019-06-12 12:34:34 +01005952exit:
5953 psa_key_derivation_abort( &operation );
Ronald Cron5425a212020-08-04 14:58:35 +02005954 for( i = 0; i < ARRAY_LENGTH( keys ); i++ )
5955 psa_destroy_key( keys[i] );
5956 psa_destroy_key( output_key );
Janos Follathaf3c2a02019-06-12 12:34:34 +01005957 PSA_DONE( );
5958}
5959/* END_CASE */
5960
Janos Follathd958bb72019-07-03 15:02:16 +01005961/* BEGIN_CASE */
Gilles Peskine1c77edd2021-05-27 11:55:02 +02005962void derive_over_capacity( int alg_arg )
Nir Sonnenscheine5204c92018-10-22 17:24:55 +03005963{
Janos Follathd958bb72019-07-03 15:02:16 +01005964 psa_algorithm_t alg = alg_arg;
Ronald Cron5425a212020-08-04 14:58:35 +02005965 mbedtls_svc_key_id_t key = MBEDTLS_SVC_KEY_ID_INIT;
Nir Sonnenschein4eda37b2018-10-31 12:15:58 +02005966 size_t key_type = PSA_KEY_TYPE_DERIVE;
Gilles Peskine51ae0e42019-05-16 17:31:03 +02005967 psa_key_derivation_operation_t operation = PSA_KEY_DERIVATION_OPERATION_INIT;
Janos Follathd958bb72019-07-03 15:02:16 +01005968 unsigned char input1[] = "Input 1";
5969 size_t input1_length = sizeof( input1 );
5970 unsigned char input2[] = "Input 2";
5971 size_t input2_length = sizeof( input2 );
Nir Sonnenscheinb46e7ca2018-10-25 14:46:09 +03005972 uint8_t buffer[42];
Nir Sonnenschein1caf6d22018-11-01 12:27:20 +02005973 size_t capacity = sizeof( buffer );
Nir Sonnenscheindd69d8b2018-11-01 12:24:23 +02005974 const uint8_t key_data[22] = { 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b,
5975 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b,
5976 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b};
Gilles Peskine2c2cf0e2019-04-19 19:58:20 +02005977 psa_key_attributes_t attributes = PSA_KEY_ATTRIBUTES_INIT;
Nir Sonnenscheine5204c92018-10-22 17:24:55 +03005978
Gilles Peskine8817f612018-12-18 00:18:46 +01005979 PSA_ASSERT( psa_crypto_init( ) );
Nir Sonnenscheinb46e7ca2018-10-25 14:46:09 +03005980
Gilles Peskine2c2cf0e2019-04-19 19:58:20 +02005981 psa_set_key_usage_flags( &attributes, PSA_KEY_USAGE_DERIVE );
5982 psa_set_key_algorithm( &attributes, alg );
5983 psa_set_key_type( &attributes, key_type );
Nir Sonnenscheinb46e7ca2018-10-25 14:46:09 +03005984
Gilles Peskine73676cb2019-05-15 20:15:10 +02005985 PSA_ASSERT( psa_import_key( &attributes,
5986 key_data, sizeof( key_data ),
Ronald Cron5425a212020-08-04 14:58:35 +02005987 &key ) );
Nir Sonnenscheinb46e7ca2018-10-25 14:46:09 +03005988
5989 /* valid key derivation */
Gilles Peskinec18e25f2021-02-12 23:48:20 +01005990 if( !mbedtls_test_psa_setup_key_derivation_wrap( &operation, key, alg,
5991 input1, input1_length,
5992 input2, input2_length,
5993 capacity ) )
Janos Follathd958bb72019-07-03 15:02:16 +01005994 goto exit;
Nir Sonnenscheinb46e7ca2018-10-25 14:46:09 +03005995
Gilles Peskine51ae0e42019-05-16 17:31:03 +02005996 /* state of operation shouldn't allow additional generation */
Janos Follathd958bb72019-07-03 15:02:16 +01005997 TEST_EQUAL( psa_key_derivation_setup( &operation, alg ),
Gilles Peskinef812dcf2018-12-18 00:33:25 +01005998 PSA_ERROR_BAD_STATE );
Nir Sonnenscheinb46e7ca2018-10-25 14:46:09 +03005999
Gilles Peskine51ae0e42019-05-16 17:31:03 +02006000 PSA_ASSERT( psa_key_derivation_output_bytes( &operation, buffer, capacity ) );
Nir Sonnenscheinb46e7ca2018-10-25 14:46:09 +03006001
Gilles Peskine51ae0e42019-05-16 17:31:03 +02006002 TEST_EQUAL( psa_key_derivation_output_bytes( &operation, buffer, capacity ),
David Saadab4ecc272019-02-14 13:48:10 +02006003 PSA_ERROR_INSUFFICIENT_DATA );
Nir Sonnenscheinb46e7ca2018-10-25 14:46:09 +03006004
Nir Sonnenscheinb46e7ca2018-10-25 14:46:09 +03006005exit:
Gilles Peskine51ae0e42019-05-16 17:31:03 +02006006 psa_key_derivation_abort( &operation );
Ronald Cron5425a212020-08-04 14:58:35 +02006007 psa_destroy_key( key );
Gilles Peskine1153e7b2019-05-28 15:10:21 +02006008 PSA_DONE( );
Nir Sonnenscheinb46e7ca2018-10-25 14:46:09 +03006009}
6010/* END_CASE */
6011
Nir Sonnenscheinb46e7ca2018-10-25 14:46:09 +03006012/* BEGIN_CASE */
Gilles Peskine1c77edd2021-05-27 11:55:02 +02006013void derive_actions_without_setup( )
Nir Sonnenscheinb46e7ca2018-10-25 14:46:09 +03006014{
6015 uint8_t output_buffer[16];
6016 size_t buffer_size = 16;
6017 size_t capacity = 0;
Gilles Peskine51ae0e42019-05-16 17:31:03 +02006018 psa_key_derivation_operation_t operation = PSA_KEY_DERIVATION_OPERATION_INIT;
Nir Sonnenscheinb46e7ca2018-10-25 14:46:09 +03006019
Gilles Peskinecf7292e2019-05-16 17:53:40 +02006020 TEST_ASSERT( psa_key_derivation_output_bytes( &operation,
6021 output_buffer, buffer_size )
Jaeden Amerocf2010c2019-02-15 13:05:49 +00006022 == PSA_ERROR_BAD_STATE );
Nir Sonnenscheinb46e7ca2018-10-25 14:46:09 +03006023
Gilles Peskine51ae0e42019-05-16 17:31:03 +02006024 TEST_ASSERT( psa_key_derivation_get_capacity( &operation, &capacity )
Jaeden Amerocf2010c2019-02-15 13:05:49 +00006025 == PSA_ERROR_BAD_STATE );
Nir Sonnenscheinb46e7ca2018-10-25 14:46:09 +03006026
Gilles Peskine51ae0e42019-05-16 17:31:03 +02006027 PSA_ASSERT( psa_key_derivation_abort( &operation ) );
Nir Sonnenscheinb46e7ca2018-10-25 14:46:09 +03006028
Gilles Peskinecf7292e2019-05-16 17:53:40 +02006029 TEST_ASSERT( psa_key_derivation_output_bytes( &operation,
6030 output_buffer, buffer_size )
Jaeden Amerocf2010c2019-02-15 13:05:49 +00006031 == PSA_ERROR_BAD_STATE );
Nir Sonnenscheinb46e7ca2018-10-25 14:46:09 +03006032
Gilles Peskine51ae0e42019-05-16 17:31:03 +02006033 TEST_ASSERT( psa_key_derivation_get_capacity( &operation, &capacity )
Jaeden Amerocf2010c2019-02-15 13:05:49 +00006034 == PSA_ERROR_BAD_STATE );
Nir Sonnenscheinb46e7ca2018-10-25 14:46:09 +03006035
6036exit:
Gilles Peskine51ae0e42019-05-16 17:31:03 +02006037 psa_key_derivation_abort( &operation );
Nir Sonnenscheine5204c92018-10-22 17:24:55 +03006038}
6039/* END_CASE */
6040
6041/* BEGIN_CASE */
Gilles Peskine96ee5c72018-07-12 17:24:54 +02006042void derive_output( int alg_arg,
Gilles Peskine1468da72019-05-29 17:35:49 +02006043 int step1_arg, data_t *input1,
6044 int step2_arg, data_t *input2,
6045 int step3_arg, data_t *input3,
Gilles Peskine96ee5c72018-07-12 17:24:54 +02006046 int requested_capacity_arg,
6047 data_t *expected_output1,
6048 data_t *expected_output2 )
6049{
Gilles Peskine96ee5c72018-07-12 17:24:54 +02006050 psa_algorithm_t alg = alg_arg;
Gilles Peskine1468da72019-05-29 17:35:49 +02006051 psa_key_derivation_step_t steps[] = {step1_arg, step2_arg, step3_arg};
6052 data_t *inputs[] = {input1, input2, input3};
Ronald Cron5425a212020-08-04 14:58:35 +02006053 mbedtls_svc_key_id_t keys[] = { MBEDTLS_SVC_KEY_ID_INIT,
6054 MBEDTLS_SVC_KEY_ID_INIT,
6055 MBEDTLS_SVC_KEY_ID_INIT };
Gilles Peskine96ee5c72018-07-12 17:24:54 +02006056 size_t requested_capacity = requested_capacity_arg;
Gilles Peskine51ae0e42019-05-16 17:31:03 +02006057 psa_key_derivation_operation_t operation = PSA_KEY_DERIVATION_OPERATION_INIT;
Gilles Peskine96ee5c72018-07-12 17:24:54 +02006058 uint8_t *expected_outputs[2] =
6059 {expected_output1->x, expected_output2->x};
6060 size_t output_sizes[2] =
6061 {expected_output1->len, expected_output2->len};
6062 size_t output_buffer_size = 0;
6063 uint8_t *output_buffer = NULL;
6064 size_t expected_capacity;
6065 size_t current_capacity;
Gilles Peskineff5f0e72019-04-18 12:53:30 +02006066 psa_key_attributes_t attributes = PSA_KEY_ATTRIBUTES_INIT;
Gilles Peskine96ee5c72018-07-12 17:24:54 +02006067 psa_status_t status;
Gilles Peskine1468da72019-05-29 17:35:49 +02006068 size_t i;
Gilles Peskine96ee5c72018-07-12 17:24:54 +02006069
6070 for( i = 0; i < ARRAY_LENGTH( expected_outputs ); i++ )
6071 {
6072 if( output_sizes[i] > output_buffer_size )
6073 output_buffer_size = output_sizes[i];
6074 if( output_sizes[i] == 0 )
6075 expected_outputs[i] = NULL;
6076 }
Gilles Peskine8cebbba2018-09-27 13:54:18 +02006077 ASSERT_ALLOC( output_buffer, output_buffer_size );
Gilles Peskine8817f612018-12-18 00:18:46 +01006078 PSA_ASSERT( psa_crypto_init( ) );
Gilles Peskine96ee5c72018-07-12 17:24:54 +02006079
Gilles Peskineff5f0e72019-04-18 12:53:30 +02006080 psa_set_key_usage_flags( &attributes, PSA_KEY_USAGE_DERIVE );
6081 psa_set_key_algorithm( &attributes, alg );
6082 psa_set_key_type( &attributes, PSA_KEY_TYPE_DERIVE );
Gilles Peskine96ee5c72018-07-12 17:24:54 +02006083
Gilles Peskine96ee5c72018-07-12 17:24:54 +02006084 /* Extraction phase. */
Gilles Peskine1468da72019-05-29 17:35:49 +02006085 PSA_ASSERT( psa_key_derivation_setup( &operation, alg ) );
6086 PSA_ASSERT( psa_key_derivation_set_capacity( &operation,
6087 requested_capacity ) );
6088 for( i = 0; i < ARRAY_LENGTH( steps ); i++ )
Gilles Peskineb70a0fd2019-01-07 22:59:38 +01006089 {
Gilles Peskine1468da72019-05-29 17:35:49 +02006090 switch( steps[i] )
6091 {
6092 case 0:
6093 break;
6094 case PSA_KEY_DERIVATION_INPUT_SECRET:
6095 PSA_ASSERT( psa_import_key( &attributes,
6096 inputs[i]->x, inputs[i]->len,
Ronald Cron5425a212020-08-04 14:58:35 +02006097 &keys[i] ) );
gabor-mezei-armceface22021-01-21 12:26:17 +01006098
6099 if ( PSA_ALG_IS_TLS12_PSK_TO_MS( alg ) )
6100 {
6101 PSA_ASSERT( psa_get_key_attributes( keys[i], &attributes ) );
6102 TEST_ASSERT( PSA_BITS_TO_BYTES( psa_get_key_bits( &attributes ) ) <=
6103 PSA_TLS12_PSK_TO_MS_PSK_MAX_SIZE );
6104 }
6105
Gilles Peskine1468da72019-05-29 17:35:49 +02006106 PSA_ASSERT( psa_key_derivation_input_key(
Ronald Cron5425a212020-08-04 14:58:35 +02006107 &operation, steps[i], keys[i] ) );
Gilles Peskine1468da72019-05-29 17:35:49 +02006108 break;
6109 default:
6110 PSA_ASSERT( psa_key_derivation_input_bytes(
6111 &operation, steps[i],
6112 inputs[i]->x, inputs[i]->len ) );
6113 break;
6114 }
Gilles Peskineb70a0fd2019-01-07 22:59:38 +01006115 }
Gilles Peskine1468da72019-05-29 17:35:49 +02006116
Gilles Peskine51ae0e42019-05-16 17:31:03 +02006117 PSA_ASSERT( psa_key_derivation_get_capacity( &operation,
Gilles Peskinecf7292e2019-05-16 17:53:40 +02006118 &current_capacity ) );
Gilles Peskinefe11b722018-12-18 00:24:04 +01006119 TEST_EQUAL( current_capacity, requested_capacity );
Gilles Peskine96ee5c72018-07-12 17:24:54 +02006120 expected_capacity = requested_capacity;
6121
6122 /* Expansion phase. */
6123 for( i = 0; i < ARRAY_LENGTH( expected_outputs ); i++ )
6124 {
6125 /* Read some bytes. */
Gilles Peskine51ae0e42019-05-16 17:31:03 +02006126 status = psa_key_derivation_output_bytes( &operation,
Gilles Peskinecf7292e2019-05-16 17:53:40 +02006127 output_buffer, output_sizes[i] );
Gilles Peskine96ee5c72018-07-12 17:24:54 +02006128 if( expected_capacity == 0 && output_sizes[i] == 0 )
6129 {
6130 /* Reading 0 bytes when 0 bytes are available can go either way. */
6131 TEST_ASSERT( status == PSA_SUCCESS ||
David Saadab4ecc272019-02-14 13:48:10 +02006132 status == PSA_ERROR_INSUFFICIENT_DATA );
Gilles Peskine96ee5c72018-07-12 17:24:54 +02006133 continue;
6134 }
6135 else if( expected_capacity == 0 ||
6136 output_sizes[i] > expected_capacity )
6137 {
6138 /* Capacity exceeded. */
David Saadab4ecc272019-02-14 13:48:10 +02006139 TEST_EQUAL( status, PSA_ERROR_INSUFFICIENT_DATA );
Gilles Peskine96ee5c72018-07-12 17:24:54 +02006140 expected_capacity = 0;
6141 continue;
6142 }
6143 /* Success. Check the read data. */
Gilles Peskine8817f612018-12-18 00:18:46 +01006144 PSA_ASSERT( status );
Gilles Peskine96ee5c72018-07-12 17:24:54 +02006145 if( output_sizes[i] != 0 )
Gilles Peskine0dfba2d2018-12-18 00:40:50 +01006146 ASSERT_COMPARE( output_buffer, output_sizes[i],
6147 expected_outputs[i], output_sizes[i] );
Gilles Peskine51ae0e42019-05-16 17:31:03 +02006148 /* Check the operation status. */
Gilles Peskine96ee5c72018-07-12 17:24:54 +02006149 expected_capacity -= output_sizes[i];
Gilles Peskine51ae0e42019-05-16 17:31:03 +02006150 PSA_ASSERT( psa_key_derivation_get_capacity( &operation,
Gilles Peskinecf7292e2019-05-16 17:53:40 +02006151 &current_capacity ) );
Gilles Peskinefe11b722018-12-18 00:24:04 +01006152 TEST_EQUAL( expected_capacity, current_capacity );
Gilles Peskine96ee5c72018-07-12 17:24:54 +02006153 }
Gilles Peskine51ae0e42019-05-16 17:31:03 +02006154 PSA_ASSERT( psa_key_derivation_abort( &operation ) );
Gilles Peskine96ee5c72018-07-12 17:24:54 +02006155
6156exit:
6157 mbedtls_free( output_buffer );
Gilles Peskine51ae0e42019-05-16 17:31:03 +02006158 psa_key_derivation_abort( &operation );
Ronald Cron5425a212020-08-04 14:58:35 +02006159 for( i = 0; i < ARRAY_LENGTH( keys ); i++ )
6160 psa_destroy_key( keys[i] );
Gilles Peskine1153e7b2019-05-28 15:10:21 +02006161 PSA_DONE( );
Gilles Peskine96ee5c72018-07-12 17:24:54 +02006162}
6163/* END_CASE */
6164
6165/* BEGIN_CASE */
Gilles Peskined54931c2018-07-17 21:06:59 +02006166void derive_full( int alg_arg,
6167 data_t *key_data,
Janos Follath47f27ed2019-06-25 13:24:52 +01006168 data_t *input1,
6169 data_t *input2,
Gilles Peskined54931c2018-07-17 21:06:59 +02006170 int requested_capacity_arg )
6171{
Ronald Cron5425a212020-08-04 14:58:35 +02006172 mbedtls_svc_key_id_t key = MBEDTLS_SVC_KEY_ID_INIT;
Gilles Peskined54931c2018-07-17 21:06:59 +02006173 psa_algorithm_t alg = alg_arg;
6174 size_t requested_capacity = requested_capacity_arg;
Gilles Peskine51ae0e42019-05-16 17:31:03 +02006175 psa_key_derivation_operation_t operation = PSA_KEY_DERIVATION_OPERATION_INIT;
Gilles Peskined54931c2018-07-17 21:06:59 +02006176 unsigned char output_buffer[16];
6177 size_t expected_capacity = requested_capacity;
6178 size_t current_capacity;
Gilles Peskineff5f0e72019-04-18 12:53:30 +02006179 psa_key_attributes_t attributes = PSA_KEY_ATTRIBUTES_INIT;
Gilles Peskined54931c2018-07-17 21:06:59 +02006180
Gilles Peskine8817f612018-12-18 00:18:46 +01006181 PSA_ASSERT( psa_crypto_init( ) );
Gilles Peskined54931c2018-07-17 21:06:59 +02006182
Gilles Peskineff5f0e72019-04-18 12:53:30 +02006183 psa_set_key_usage_flags( &attributes, PSA_KEY_USAGE_DERIVE );
6184 psa_set_key_algorithm( &attributes, alg );
6185 psa_set_key_type( &attributes, PSA_KEY_TYPE_DERIVE );
Gilles Peskined54931c2018-07-17 21:06:59 +02006186
Gilles Peskine049c7532019-05-15 20:22:09 +02006187 PSA_ASSERT( psa_import_key( &attributes, key_data->x, key_data->len,
Ronald Cron5425a212020-08-04 14:58:35 +02006188 &key ) );
Gilles Peskined54931c2018-07-17 21:06:59 +02006189
Gilles Peskinec18e25f2021-02-12 23:48:20 +01006190 if( !mbedtls_test_psa_setup_key_derivation_wrap( &operation, key, alg,
6191 input1->x, input1->len,
6192 input2->x, input2->len,
6193 requested_capacity ) )
Janos Follathf2815ea2019-07-03 12:41:36 +01006194 goto exit;
Janos Follath47f27ed2019-06-25 13:24:52 +01006195
Gilles Peskine51ae0e42019-05-16 17:31:03 +02006196 PSA_ASSERT( psa_key_derivation_get_capacity( &operation,
Gilles Peskinecf7292e2019-05-16 17:53:40 +02006197 &current_capacity ) );
Gilles Peskinefe11b722018-12-18 00:24:04 +01006198 TEST_EQUAL( current_capacity, expected_capacity );
Gilles Peskined54931c2018-07-17 21:06:59 +02006199
6200 /* Expansion phase. */
6201 while( current_capacity > 0 )
6202 {
6203 size_t read_size = sizeof( output_buffer );
6204 if( read_size > current_capacity )
6205 read_size = current_capacity;
Gilles Peskine51ae0e42019-05-16 17:31:03 +02006206 PSA_ASSERT( psa_key_derivation_output_bytes( &operation,
Gilles Peskinecf7292e2019-05-16 17:53:40 +02006207 output_buffer,
6208 read_size ) );
Gilles Peskined54931c2018-07-17 21:06:59 +02006209 expected_capacity -= read_size;
Gilles Peskine51ae0e42019-05-16 17:31:03 +02006210 PSA_ASSERT( psa_key_derivation_get_capacity( &operation,
Gilles Peskinecf7292e2019-05-16 17:53:40 +02006211 &current_capacity ) );
Gilles Peskinefe11b722018-12-18 00:24:04 +01006212 TEST_EQUAL( current_capacity, expected_capacity );
Gilles Peskined54931c2018-07-17 21:06:59 +02006213 }
6214
Gilles Peskine51ae0e42019-05-16 17:31:03 +02006215 /* Check that the operation refuses to go over capacity. */
6216 TEST_EQUAL( psa_key_derivation_output_bytes( &operation, output_buffer, 1 ),
David Saadab4ecc272019-02-14 13:48:10 +02006217 PSA_ERROR_INSUFFICIENT_DATA );
Gilles Peskined54931c2018-07-17 21:06:59 +02006218
Gilles Peskine51ae0e42019-05-16 17:31:03 +02006219 PSA_ASSERT( psa_key_derivation_abort( &operation ) );
Gilles Peskined54931c2018-07-17 21:06:59 +02006220
6221exit:
Gilles Peskine51ae0e42019-05-16 17:31:03 +02006222 psa_key_derivation_abort( &operation );
Ronald Cron5425a212020-08-04 14:58:35 +02006223 psa_destroy_key( key );
Gilles Peskine1153e7b2019-05-28 15:10:21 +02006224 PSA_DONE( );
Gilles Peskined54931c2018-07-17 21:06:59 +02006225}
6226/* END_CASE */
6227
Janos Follathe60c9052019-07-03 13:51:30 +01006228/* BEGIN_CASE */
Gilles Peskine0386fba2018-07-12 17:29:22 +02006229void derive_key_exercise( int alg_arg,
6230 data_t *key_data,
Janos Follathe60c9052019-07-03 13:51:30 +01006231 data_t *input1,
6232 data_t *input2,
Gilles Peskine0386fba2018-07-12 17:29:22 +02006233 int derived_type_arg,
6234 int derived_bits_arg,
6235 int derived_usage_arg,
6236 int derived_alg_arg )
6237{
Ronald Cron5425a212020-08-04 14:58:35 +02006238 mbedtls_svc_key_id_t base_key = MBEDTLS_SVC_KEY_ID_INIT;
6239 mbedtls_svc_key_id_t derived_key = MBEDTLS_SVC_KEY_ID_INIT;
Gilles Peskine0386fba2018-07-12 17:29:22 +02006240 psa_algorithm_t alg = alg_arg;
6241 psa_key_type_t derived_type = derived_type_arg;
6242 size_t derived_bits = derived_bits_arg;
6243 psa_key_usage_t derived_usage = derived_usage_arg;
6244 psa_algorithm_t derived_alg = derived_alg_arg;
6245 size_t capacity = PSA_BITS_TO_BYTES( derived_bits );
Gilles Peskine51ae0e42019-05-16 17:31:03 +02006246 psa_key_derivation_operation_t operation = PSA_KEY_DERIVATION_OPERATION_INIT;
Gilles Peskineff5f0e72019-04-18 12:53:30 +02006247 psa_key_attributes_t attributes = PSA_KEY_ATTRIBUTES_INIT;
Gilles Peskine8c8f2ab2019-04-18 21:44:46 +02006248 psa_key_attributes_t got_attributes = PSA_KEY_ATTRIBUTES_INIT;
Gilles Peskine0386fba2018-07-12 17:29:22 +02006249
Gilles Peskine8817f612018-12-18 00:18:46 +01006250 PSA_ASSERT( psa_crypto_init( ) );
Gilles Peskine0386fba2018-07-12 17:29:22 +02006251
Gilles Peskineff5f0e72019-04-18 12:53:30 +02006252 psa_set_key_usage_flags( &attributes, PSA_KEY_USAGE_DERIVE );
6253 psa_set_key_algorithm( &attributes, alg );
6254 psa_set_key_type( &attributes, PSA_KEY_TYPE_DERIVE );
Gilles Peskine049c7532019-05-15 20:22:09 +02006255 PSA_ASSERT( psa_import_key( &attributes, key_data->x, key_data->len,
Ronald Cron5425a212020-08-04 14:58:35 +02006256 &base_key ) );
Gilles Peskine0386fba2018-07-12 17:29:22 +02006257
6258 /* Derive a key. */
Gilles Peskinec18e25f2021-02-12 23:48:20 +01006259 if ( mbedtls_test_psa_setup_key_derivation_wrap( &operation, base_key, alg,
6260 input1->x, input1->len,
6261 input2->x, input2->len,
6262 capacity ) )
Janos Follathe60c9052019-07-03 13:51:30 +01006263 goto exit;
6264
Gilles Peskineff5f0e72019-04-18 12:53:30 +02006265 psa_set_key_usage_flags( &attributes, derived_usage );
6266 psa_set_key_algorithm( &attributes, derived_alg );
6267 psa_set_key_type( &attributes, derived_type );
Gilles Peskine3a4f1f82019-04-26 13:49:28 +02006268 psa_set_key_bits( &attributes, derived_bits );
Gilles Peskine51ae0e42019-05-16 17:31:03 +02006269 PSA_ASSERT( psa_key_derivation_output_key( &attributes, &operation,
Ronald Cron5425a212020-08-04 14:58:35 +02006270 &derived_key ) );
Gilles Peskine0386fba2018-07-12 17:29:22 +02006271
6272 /* Test the key information */
Ronald Cron5425a212020-08-04 14:58:35 +02006273 PSA_ASSERT( psa_get_key_attributes( derived_key, &got_attributes ) );
Gilles Peskine8c8f2ab2019-04-18 21:44:46 +02006274 TEST_EQUAL( psa_get_key_type( &got_attributes ), derived_type );
6275 TEST_EQUAL( psa_get_key_bits( &got_attributes ), derived_bits );
Gilles Peskine0386fba2018-07-12 17:29:22 +02006276
6277 /* Exercise the derived key. */
Gilles Peskinec18e25f2021-02-12 23:48:20 +01006278 if( ! mbedtls_test_psa_exercise_key( derived_key, derived_usage, derived_alg ) )
Gilles Peskine0386fba2018-07-12 17:29:22 +02006279 goto exit;
6280
6281exit:
Ronald Cron3a4f0e32020-11-19 17:55:23 +01006282 /*
6283 * Key attributes may have been returned by psa_get_key_attributes()
6284 * thus reset them as required.
6285 */
Gilles Peskinea1ace9c2019-04-26 16:03:33 +02006286 psa_reset_key_attributes( &got_attributes );
Ronald Cron3a4f0e32020-11-19 17:55:23 +01006287
6288 psa_key_derivation_abort( &operation );
Ronald Cron5425a212020-08-04 14:58:35 +02006289 psa_destroy_key( base_key );
6290 psa_destroy_key( derived_key );
Gilles Peskine1153e7b2019-05-28 15:10:21 +02006291 PSA_DONE( );
Gilles Peskine0386fba2018-07-12 17:29:22 +02006292}
6293/* END_CASE */
6294
Janos Follath42fd8882019-07-03 14:17:09 +01006295/* BEGIN_CASE */
Gilles Peskine0386fba2018-07-12 17:29:22 +02006296void derive_key_export( int alg_arg,
6297 data_t *key_data,
Janos Follath42fd8882019-07-03 14:17:09 +01006298 data_t *input1,
6299 data_t *input2,
Gilles Peskine0386fba2018-07-12 17:29:22 +02006300 int bytes1_arg,
6301 int bytes2_arg )
6302{
Ronald Cron5425a212020-08-04 14:58:35 +02006303 mbedtls_svc_key_id_t base_key = MBEDTLS_SVC_KEY_ID_INIT;
6304 mbedtls_svc_key_id_t derived_key = MBEDTLS_SVC_KEY_ID_INIT;
Gilles Peskine0386fba2018-07-12 17:29:22 +02006305 psa_algorithm_t alg = alg_arg;
6306 size_t bytes1 = bytes1_arg;
6307 size_t bytes2 = bytes2_arg;
6308 size_t capacity = bytes1 + bytes2;
Gilles Peskine51ae0e42019-05-16 17:31:03 +02006309 psa_key_derivation_operation_t operation = PSA_KEY_DERIVATION_OPERATION_INIT;
Gilles Peskine8cebbba2018-09-27 13:54:18 +02006310 uint8_t *output_buffer = NULL;
6311 uint8_t *export_buffer = NULL;
Gilles Peskineff5f0e72019-04-18 12:53:30 +02006312 psa_key_attributes_t base_attributes = PSA_KEY_ATTRIBUTES_INIT;
6313 psa_key_attributes_t derived_attributes = PSA_KEY_ATTRIBUTES_INIT;
Gilles Peskine0386fba2018-07-12 17:29:22 +02006314 size_t length;
6315
Gilles Peskine8cebbba2018-09-27 13:54:18 +02006316 ASSERT_ALLOC( output_buffer, capacity );
6317 ASSERT_ALLOC( export_buffer, capacity );
Gilles Peskine8817f612018-12-18 00:18:46 +01006318 PSA_ASSERT( psa_crypto_init( ) );
Gilles Peskine0386fba2018-07-12 17:29:22 +02006319
Gilles Peskineff5f0e72019-04-18 12:53:30 +02006320 psa_set_key_usage_flags( &base_attributes, PSA_KEY_USAGE_DERIVE );
6321 psa_set_key_algorithm( &base_attributes, alg );
6322 psa_set_key_type( &base_attributes, PSA_KEY_TYPE_DERIVE );
Gilles Peskine049c7532019-05-15 20:22:09 +02006323 PSA_ASSERT( psa_import_key( &base_attributes, key_data->x, key_data->len,
Ronald Cron5425a212020-08-04 14:58:35 +02006324 &base_key ) );
Gilles Peskine0386fba2018-07-12 17:29:22 +02006325
6326 /* Derive some material and output it. */
Gilles Peskinec18e25f2021-02-12 23:48:20 +01006327 if( !mbedtls_test_psa_setup_key_derivation_wrap( &operation, base_key, alg,
6328 input1->x, input1->len,
6329 input2->x, input2->len,
6330 capacity ) )
Janos Follath42fd8882019-07-03 14:17:09 +01006331 goto exit;
6332
Gilles Peskine51ae0e42019-05-16 17:31:03 +02006333 PSA_ASSERT( psa_key_derivation_output_bytes( &operation,
Gilles Peskinecf7292e2019-05-16 17:53:40 +02006334 output_buffer,
6335 capacity ) );
Gilles Peskine51ae0e42019-05-16 17:31:03 +02006336 PSA_ASSERT( psa_key_derivation_abort( &operation ) );
Gilles Peskine0386fba2018-07-12 17:29:22 +02006337
6338 /* Derive the same output again, but this time store it in key objects. */
Gilles Peskinec18e25f2021-02-12 23:48:20 +01006339 if( !mbedtls_test_psa_setup_key_derivation_wrap( &operation, base_key, alg,
6340 input1->x, input1->len,
6341 input2->x, input2->len,
6342 capacity ) )
Janos Follath42fd8882019-07-03 14:17:09 +01006343 goto exit;
6344
Gilles Peskineff5f0e72019-04-18 12:53:30 +02006345 psa_set_key_usage_flags( &derived_attributes, PSA_KEY_USAGE_EXPORT );
6346 psa_set_key_algorithm( &derived_attributes, 0 );
6347 psa_set_key_type( &derived_attributes, PSA_KEY_TYPE_RAW_DATA );
Gilles Peskine3a4f1f82019-04-26 13:49:28 +02006348 psa_set_key_bits( &derived_attributes, PSA_BYTES_TO_BITS( bytes1 ) );
Gilles Peskine51ae0e42019-05-16 17:31:03 +02006349 PSA_ASSERT( psa_key_derivation_output_key( &derived_attributes, &operation,
Ronald Cron5425a212020-08-04 14:58:35 +02006350 &derived_key ) );
6351 PSA_ASSERT( psa_export_key( derived_key,
Gilles Peskine8817f612018-12-18 00:18:46 +01006352 export_buffer, bytes1,
6353 &length ) );
Gilles Peskinefe11b722018-12-18 00:24:04 +01006354 TEST_EQUAL( length, bytes1 );
Ronald Cron5425a212020-08-04 14:58:35 +02006355 PSA_ASSERT( psa_destroy_key( derived_key ) );
Gilles Peskine3a4f1f82019-04-26 13:49:28 +02006356 psa_set_key_bits( &derived_attributes, PSA_BYTES_TO_BITS( bytes2 ) );
Gilles Peskine51ae0e42019-05-16 17:31:03 +02006357 PSA_ASSERT( psa_key_derivation_output_key( &derived_attributes, &operation,
Ronald Cron5425a212020-08-04 14:58:35 +02006358 &derived_key ) );
6359 PSA_ASSERT( psa_export_key( derived_key,
Gilles Peskine8817f612018-12-18 00:18:46 +01006360 export_buffer + bytes1, bytes2,
6361 &length ) );
Gilles Peskinefe11b722018-12-18 00:24:04 +01006362 TEST_EQUAL( length, bytes2 );
Gilles Peskine0386fba2018-07-12 17:29:22 +02006363
6364 /* Compare the outputs from the two runs. */
Gilles Peskine0dfba2d2018-12-18 00:40:50 +01006365 ASSERT_COMPARE( output_buffer, bytes1 + bytes2,
6366 export_buffer, capacity );
Gilles Peskine0386fba2018-07-12 17:29:22 +02006367
6368exit:
6369 mbedtls_free( output_buffer );
6370 mbedtls_free( export_buffer );
Gilles Peskine51ae0e42019-05-16 17:31:03 +02006371 psa_key_derivation_abort( &operation );
Ronald Cron5425a212020-08-04 14:58:35 +02006372 psa_destroy_key( base_key );
6373 psa_destroy_key( derived_key );
Gilles Peskine1153e7b2019-05-28 15:10:21 +02006374 PSA_DONE( );
Gilles Peskine0386fba2018-07-12 17:29:22 +02006375}
6376/* END_CASE */
6377
6378/* BEGIN_CASE */
Gilles Peskine7c227ae2019-07-31 15:14:44 +02006379void derive_key( int alg_arg,
6380 data_t *key_data, data_t *input1, data_t *input2,
6381 int type_arg, int bits_arg,
Steven Cooreman83fdb702021-01-21 14:24:39 +01006382 int expected_status_arg,
6383 int is_large_output )
Gilles Peskinec744d992019-07-30 17:26:54 +02006384{
Ronald Cron5425a212020-08-04 14:58:35 +02006385 mbedtls_svc_key_id_t base_key = MBEDTLS_SVC_KEY_ID_INIT;
6386 mbedtls_svc_key_id_t derived_key = MBEDTLS_SVC_KEY_ID_INIT;
Gilles Peskinec744d992019-07-30 17:26:54 +02006387 psa_algorithm_t alg = alg_arg;
Gilles Peskine7c227ae2019-07-31 15:14:44 +02006388 psa_key_type_t type = type_arg;
Gilles Peskinec744d992019-07-30 17:26:54 +02006389 size_t bits = bits_arg;
6390 psa_status_t expected_status = expected_status_arg;
6391 psa_key_derivation_operation_t operation = PSA_KEY_DERIVATION_OPERATION_INIT;
6392 psa_key_attributes_t base_attributes = PSA_KEY_ATTRIBUTES_INIT;
6393 psa_key_attributes_t derived_attributes = PSA_KEY_ATTRIBUTES_INIT;
6394
6395 PSA_ASSERT( psa_crypto_init( ) );
6396
6397 psa_set_key_usage_flags( &base_attributes, PSA_KEY_USAGE_DERIVE );
6398 psa_set_key_algorithm( &base_attributes, alg );
6399 psa_set_key_type( &base_attributes, PSA_KEY_TYPE_DERIVE );
6400 PSA_ASSERT( psa_import_key( &base_attributes, key_data->x, key_data->len,
Ronald Cron5425a212020-08-04 14:58:35 +02006401 &base_key ) );
Gilles Peskinec744d992019-07-30 17:26:54 +02006402
Gilles Peskinec18e25f2021-02-12 23:48:20 +01006403 if( !mbedtls_test_psa_setup_key_derivation_wrap( &operation, base_key, alg,
6404 input1->x, input1->len,
6405 input2->x, input2->len,
6406 SIZE_MAX ) )
Gilles Peskinec744d992019-07-30 17:26:54 +02006407 goto exit;
6408
6409 psa_set_key_usage_flags( &derived_attributes, PSA_KEY_USAGE_EXPORT );
6410 psa_set_key_algorithm( &derived_attributes, 0 );
Gilles Peskine7c227ae2019-07-31 15:14:44 +02006411 psa_set_key_type( &derived_attributes, type );
Gilles Peskinec744d992019-07-30 17:26:54 +02006412 psa_set_key_bits( &derived_attributes, bits );
Steven Cooreman83fdb702021-01-21 14:24:39 +01006413
6414 psa_status_t status =
6415 psa_key_derivation_output_key( &derived_attributes,
6416 &operation,
6417 &derived_key );
6418 if( is_large_output > 0 )
6419 TEST_ASSUME( status != PSA_ERROR_INSUFFICIENT_MEMORY );
6420 TEST_EQUAL( status, expected_status );
Gilles Peskinec744d992019-07-30 17:26:54 +02006421
6422exit:
6423 psa_key_derivation_abort( &operation );
Ronald Cron5425a212020-08-04 14:58:35 +02006424 psa_destroy_key( base_key );
6425 psa_destroy_key( derived_key );
Gilles Peskinec744d992019-07-30 17:26:54 +02006426 PSA_DONE( );
6427}
6428/* END_CASE */
6429
6430/* BEGIN_CASE */
Gilles Peskine01d718c2018-09-18 12:01:02 +02006431void key_agreement_setup( int alg_arg,
Steven Cooremance48e852020-10-05 16:02:45 +02006432 int our_key_type_arg, int our_key_alg_arg,
6433 data_t *our_key_data, data_t *peer_key_data,
Gilles Peskine01d718c2018-09-18 12:01:02 +02006434 int expected_status_arg )
6435{
Ronald Cron5425a212020-08-04 14:58:35 +02006436 mbedtls_svc_key_id_t our_key = MBEDTLS_SVC_KEY_ID_INIT;
Gilles Peskine01d718c2018-09-18 12:01:02 +02006437 psa_algorithm_t alg = alg_arg;
Steven Cooremanfa5e6312020-10-15 17:07:12 +02006438 psa_algorithm_t our_key_alg = our_key_alg_arg;
Gilles Peskine01d718c2018-09-18 12:01:02 +02006439 psa_key_type_t our_key_type = our_key_type_arg;
Gilles Peskine51ae0e42019-05-16 17:31:03 +02006440 psa_key_derivation_operation_t operation = PSA_KEY_DERIVATION_OPERATION_INIT;
Gilles Peskineff5f0e72019-04-18 12:53:30 +02006441 psa_key_attributes_t attributes = PSA_KEY_ATTRIBUTES_INIT;
Gilles Peskine77f40d82019-04-11 21:27:06 +02006442 psa_status_t expected_status = expected_status_arg;
6443 psa_status_t status;
Gilles Peskine01d718c2018-09-18 12:01:02 +02006444
Gilles Peskine8817f612018-12-18 00:18:46 +01006445 PSA_ASSERT( psa_crypto_init( ) );
Gilles Peskine01d718c2018-09-18 12:01:02 +02006446
Gilles Peskineff5f0e72019-04-18 12:53:30 +02006447 psa_set_key_usage_flags( &attributes, PSA_KEY_USAGE_DERIVE );
Steven Cooremanfa5e6312020-10-15 17:07:12 +02006448 psa_set_key_algorithm( &attributes, our_key_alg );
Gilles Peskineff5f0e72019-04-18 12:53:30 +02006449 psa_set_key_type( &attributes, our_key_type );
Gilles Peskine049c7532019-05-15 20:22:09 +02006450 PSA_ASSERT( psa_import_key( &attributes,
6451 our_key_data->x, our_key_data->len,
6452 &our_key ) );
Gilles Peskine01d718c2018-09-18 12:01:02 +02006453
Gilles Peskine77f40d82019-04-11 21:27:06 +02006454 /* The tests currently include inputs that should fail at either step.
6455 * Test cases that fail at the setup step should be changed to call
6456 * key_derivation_setup instead, and this function should be renamed
6457 * to key_agreement_fail. */
Gilles Peskine51ae0e42019-05-16 17:31:03 +02006458 status = psa_key_derivation_setup( &operation, alg );
Gilles Peskine77f40d82019-04-11 21:27:06 +02006459 if( status == PSA_SUCCESS )
6460 {
Gilles Peskinecf7292e2019-05-16 17:53:40 +02006461 TEST_EQUAL( psa_key_derivation_key_agreement(
6462 &operation, PSA_KEY_DERIVATION_INPUT_SECRET,
6463 our_key,
6464 peer_key_data->x, peer_key_data->len ),
Gilles Peskine77f40d82019-04-11 21:27:06 +02006465 expected_status );
6466 }
6467 else
6468 {
6469 TEST_ASSERT( status == expected_status );
6470 }
Gilles Peskine01d718c2018-09-18 12:01:02 +02006471
6472exit:
Gilles Peskine51ae0e42019-05-16 17:31:03 +02006473 psa_key_derivation_abort( &operation );
Gilles Peskine01d718c2018-09-18 12:01:02 +02006474 psa_destroy_key( our_key );
Gilles Peskine1153e7b2019-05-28 15:10:21 +02006475 PSA_DONE( );
Gilles Peskine01d718c2018-09-18 12:01:02 +02006476}
6477/* END_CASE */
6478
6479/* BEGIN_CASE */
Gilles Peskinef0cba732019-04-11 22:12:38 +02006480void raw_key_agreement( int alg_arg,
6481 int our_key_type_arg, data_t *our_key_data,
6482 data_t *peer_key_data,
6483 data_t *expected_output )
6484{
Ronald Cron5425a212020-08-04 14:58:35 +02006485 mbedtls_svc_key_id_t our_key = MBEDTLS_SVC_KEY_ID_INIT;
Gilles Peskinef0cba732019-04-11 22:12:38 +02006486 psa_algorithm_t alg = alg_arg;
6487 psa_key_type_t our_key_type = our_key_type_arg;
Gilles Peskineff5f0e72019-04-18 12:53:30 +02006488 psa_key_attributes_t attributes = PSA_KEY_ATTRIBUTES_INIT;
Gilles Peskinef0cba732019-04-11 22:12:38 +02006489 unsigned char *output = NULL;
6490 size_t output_length = ~0;
gabor-mezei-armceface22021-01-21 12:26:17 +01006491 size_t key_bits;
Gilles Peskinef0cba732019-04-11 22:12:38 +02006492
6493 ASSERT_ALLOC( output, expected_output->len );
6494 PSA_ASSERT( psa_crypto_init( ) );
6495
Gilles Peskineff5f0e72019-04-18 12:53:30 +02006496 psa_set_key_usage_flags( &attributes, PSA_KEY_USAGE_DERIVE );
6497 psa_set_key_algorithm( &attributes, alg );
6498 psa_set_key_type( &attributes, our_key_type );
Gilles Peskine049c7532019-05-15 20:22:09 +02006499 PSA_ASSERT( psa_import_key( &attributes,
6500 our_key_data->x, our_key_data->len,
6501 &our_key ) );
Gilles Peskinef0cba732019-04-11 22:12:38 +02006502
gabor-mezei-armceface22021-01-21 12:26:17 +01006503 PSA_ASSERT( psa_get_key_attributes( our_key, &attributes ) );
6504 key_bits = psa_get_key_bits( &attributes );
6505
Gilles Peskinebe697d82019-05-16 18:00:41 +02006506 PSA_ASSERT( psa_raw_key_agreement( alg, our_key,
6507 peer_key_data->x, peer_key_data->len,
6508 output, expected_output->len,
6509 &output_length ) );
Gilles Peskinef0cba732019-04-11 22:12:38 +02006510 ASSERT_COMPARE( output, output_length,
6511 expected_output->x, expected_output->len );
gabor-mezei-armceface22021-01-21 12:26:17 +01006512 TEST_ASSERT( output_length <=
6513 PSA_RAW_KEY_AGREEMENT_OUTPUT_SIZE( our_key_type, key_bits ) );
6514 TEST_ASSERT( output_length <=
6515 PSA_RAW_KEY_AGREEMENT_OUTPUT_MAX_SIZE );
Gilles Peskinef0cba732019-04-11 22:12:38 +02006516
6517exit:
6518 mbedtls_free( output );
6519 psa_destroy_key( our_key );
Gilles Peskine1153e7b2019-05-28 15:10:21 +02006520 PSA_DONE( );
Gilles Peskinef0cba732019-04-11 22:12:38 +02006521}
6522/* END_CASE */
6523
6524/* BEGIN_CASE */
Gilles Peskine59685592018-09-18 12:11:34 +02006525void key_agreement_capacity( int alg_arg,
6526 int our_key_type_arg, data_t *our_key_data,
6527 data_t *peer_key_data,
6528 int expected_capacity_arg )
6529{
Ronald Cron5425a212020-08-04 14:58:35 +02006530 mbedtls_svc_key_id_t our_key = MBEDTLS_SVC_KEY_ID_INIT;
Gilles Peskine59685592018-09-18 12:11:34 +02006531 psa_algorithm_t alg = alg_arg;
6532 psa_key_type_t our_key_type = our_key_type_arg;
Gilles Peskine51ae0e42019-05-16 17:31:03 +02006533 psa_key_derivation_operation_t operation = PSA_KEY_DERIVATION_OPERATION_INIT;
Gilles Peskineff5f0e72019-04-18 12:53:30 +02006534 psa_key_attributes_t attributes = PSA_KEY_ATTRIBUTES_INIT;
Gilles Peskine59685592018-09-18 12:11:34 +02006535 size_t actual_capacity;
Gilles Peskinebf491972018-10-25 22:36:12 +02006536 unsigned char output[16];
Gilles Peskine59685592018-09-18 12:11:34 +02006537
Gilles Peskine8817f612018-12-18 00:18:46 +01006538 PSA_ASSERT( psa_crypto_init( ) );
Gilles Peskine59685592018-09-18 12:11:34 +02006539
Gilles Peskineff5f0e72019-04-18 12:53:30 +02006540 psa_set_key_usage_flags( &attributes, PSA_KEY_USAGE_DERIVE );
6541 psa_set_key_algorithm( &attributes, alg );
6542 psa_set_key_type( &attributes, our_key_type );
Gilles Peskine049c7532019-05-15 20:22:09 +02006543 PSA_ASSERT( psa_import_key( &attributes,
6544 our_key_data->x, our_key_data->len,
6545 &our_key ) );
Gilles Peskine59685592018-09-18 12:11:34 +02006546
Gilles Peskine51ae0e42019-05-16 17:31:03 +02006547 PSA_ASSERT( psa_key_derivation_setup( &operation, alg ) );
Gilles Peskinecf7292e2019-05-16 17:53:40 +02006548 PSA_ASSERT( psa_key_derivation_key_agreement(
6549 &operation,
6550 PSA_KEY_DERIVATION_INPUT_SECRET, our_key,
6551 peer_key_data->x, peer_key_data->len ) );
Gilles Peskinef8a9d942019-04-11 22:13:20 +02006552 if( PSA_ALG_IS_HKDF( PSA_ALG_KEY_AGREEMENT_GET_KDF( alg ) ) )
6553 {
6554 /* The test data is for info="" */
Gilles Peskine51ae0e42019-05-16 17:31:03 +02006555 PSA_ASSERT( psa_key_derivation_input_bytes( &operation,
Gilles Peskine03410b52019-05-16 16:05:19 +02006556 PSA_KEY_DERIVATION_INPUT_INFO,
Gilles Peskinef8a9d942019-04-11 22:13:20 +02006557 NULL, 0 ) );
6558 }
Gilles Peskine59685592018-09-18 12:11:34 +02006559
Gilles Peskinebf491972018-10-25 22:36:12 +02006560 /* Test the advertized capacity. */
Gilles Peskinea99d3fb2019-05-16 15:28:51 +02006561 PSA_ASSERT( psa_key_derivation_get_capacity(
Gilles Peskine51ae0e42019-05-16 17:31:03 +02006562 &operation, &actual_capacity ) );
Gilles Peskinefe11b722018-12-18 00:24:04 +01006563 TEST_EQUAL( actual_capacity, (size_t) expected_capacity_arg );
Gilles Peskine59685592018-09-18 12:11:34 +02006564
Gilles Peskinebf491972018-10-25 22:36:12 +02006565 /* Test the actual capacity by reading the output. */
6566 while( actual_capacity > sizeof( output ) )
6567 {
Gilles Peskine51ae0e42019-05-16 17:31:03 +02006568 PSA_ASSERT( psa_key_derivation_output_bytes( &operation,
Gilles Peskinecf7292e2019-05-16 17:53:40 +02006569 output, sizeof( output ) ) );
Gilles Peskinebf491972018-10-25 22:36:12 +02006570 actual_capacity -= sizeof( output );
6571 }
Gilles Peskine51ae0e42019-05-16 17:31:03 +02006572 PSA_ASSERT( psa_key_derivation_output_bytes( &operation,
Gilles Peskinecf7292e2019-05-16 17:53:40 +02006573 output, actual_capacity ) );
Gilles Peskine51ae0e42019-05-16 17:31:03 +02006574 TEST_EQUAL( psa_key_derivation_output_bytes( &operation, output, 1 ),
David Saadab4ecc272019-02-14 13:48:10 +02006575 PSA_ERROR_INSUFFICIENT_DATA );
Gilles Peskinebf491972018-10-25 22:36:12 +02006576
Gilles Peskine59685592018-09-18 12:11:34 +02006577exit:
Gilles Peskine51ae0e42019-05-16 17:31:03 +02006578 psa_key_derivation_abort( &operation );
Gilles Peskine59685592018-09-18 12:11:34 +02006579 psa_destroy_key( our_key );
Gilles Peskine1153e7b2019-05-28 15:10:21 +02006580 PSA_DONE( );
Gilles Peskine59685592018-09-18 12:11:34 +02006581}
6582/* END_CASE */
6583
6584/* BEGIN_CASE */
6585void key_agreement_output( int alg_arg,
6586 int our_key_type_arg, data_t *our_key_data,
6587 data_t *peer_key_data,
Gilles Peskine3ec8ed82018-10-25 22:37:15 +02006588 data_t *expected_output1, data_t *expected_output2 )
Gilles Peskine59685592018-09-18 12:11:34 +02006589{
Ronald Cron5425a212020-08-04 14:58:35 +02006590 mbedtls_svc_key_id_t our_key = MBEDTLS_SVC_KEY_ID_INIT;
Gilles Peskine59685592018-09-18 12:11:34 +02006591 psa_algorithm_t alg = alg_arg;
6592 psa_key_type_t our_key_type = our_key_type_arg;
Gilles Peskine51ae0e42019-05-16 17:31:03 +02006593 psa_key_derivation_operation_t operation = PSA_KEY_DERIVATION_OPERATION_INIT;
Gilles Peskineff5f0e72019-04-18 12:53:30 +02006594 psa_key_attributes_t attributes = PSA_KEY_ATTRIBUTES_INIT;
Gilles Peskine3ec8ed82018-10-25 22:37:15 +02006595 uint8_t *actual_output = NULL;
Gilles Peskine59685592018-09-18 12:11:34 +02006596
Gilles Peskine3ec8ed82018-10-25 22:37:15 +02006597 ASSERT_ALLOC( actual_output, MAX( expected_output1->len,
6598 expected_output2->len ) );
Gilles Peskine59685592018-09-18 12:11:34 +02006599
Gilles Peskine8817f612018-12-18 00:18:46 +01006600 PSA_ASSERT( psa_crypto_init( ) );
Gilles Peskine59685592018-09-18 12:11:34 +02006601
Gilles Peskineff5f0e72019-04-18 12:53:30 +02006602 psa_set_key_usage_flags( &attributes, PSA_KEY_USAGE_DERIVE );
6603 psa_set_key_algorithm( &attributes, alg );
6604 psa_set_key_type( &attributes, our_key_type );
Gilles Peskine049c7532019-05-15 20:22:09 +02006605 PSA_ASSERT( psa_import_key( &attributes,
6606 our_key_data->x, our_key_data->len,
6607 &our_key ) );
Gilles Peskine59685592018-09-18 12:11:34 +02006608
Gilles Peskine51ae0e42019-05-16 17:31:03 +02006609 PSA_ASSERT( psa_key_derivation_setup( &operation, alg ) );
Gilles Peskinecf7292e2019-05-16 17:53:40 +02006610 PSA_ASSERT( psa_key_derivation_key_agreement(
6611 &operation,
6612 PSA_KEY_DERIVATION_INPUT_SECRET, our_key,
6613 peer_key_data->x, peer_key_data->len ) );
Gilles Peskinef8a9d942019-04-11 22:13:20 +02006614 if( PSA_ALG_IS_HKDF( PSA_ALG_KEY_AGREEMENT_GET_KDF( alg ) ) )
6615 {
6616 /* The test data is for info="" */
Gilles Peskine51ae0e42019-05-16 17:31:03 +02006617 PSA_ASSERT( psa_key_derivation_input_bytes( &operation,
Gilles Peskine03410b52019-05-16 16:05:19 +02006618 PSA_KEY_DERIVATION_INPUT_INFO,
Gilles Peskinef8a9d942019-04-11 22:13:20 +02006619 NULL, 0 ) );
6620 }
Gilles Peskine59685592018-09-18 12:11:34 +02006621
Gilles Peskine51ae0e42019-05-16 17:31:03 +02006622 PSA_ASSERT( psa_key_derivation_output_bytes( &operation,
Gilles Peskinecf7292e2019-05-16 17:53:40 +02006623 actual_output,
6624 expected_output1->len ) );
Gilles Peskine0dfba2d2018-12-18 00:40:50 +01006625 ASSERT_COMPARE( actual_output, expected_output1->len,
6626 expected_output1->x, expected_output1->len );
Gilles Peskine3ec8ed82018-10-25 22:37:15 +02006627 if( expected_output2->len != 0 )
6628 {
Gilles Peskine51ae0e42019-05-16 17:31:03 +02006629 PSA_ASSERT( psa_key_derivation_output_bytes( &operation,
Gilles Peskinecf7292e2019-05-16 17:53:40 +02006630 actual_output,
6631 expected_output2->len ) );
Gilles Peskine0dfba2d2018-12-18 00:40:50 +01006632 ASSERT_COMPARE( actual_output, expected_output2->len,
6633 expected_output2->x, expected_output2->len );
Gilles Peskine3ec8ed82018-10-25 22:37:15 +02006634 }
Gilles Peskine59685592018-09-18 12:11:34 +02006635
6636exit:
Gilles Peskine51ae0e42019-05-16 17:31:03 +02006637 psa_key_derivation_abort( &operation );
Gilles Peskine59685592018-09-18 12:11:34 +02006638 psa_destroy_key( our_key );
Gilles Peskine1153e7b2019-05-28 15:10:21 +02006639 PSA_DONE( );
Gilles Peskine59685592018-09-18 12:11:34 +02006640 mbedtls_free( actual_output );
6641}
6642/* END_CASE */
6643
6644/* BEGIN_CASE */
Gilles Peskinea50d7392018-06-21 10:22:13 +02006645void generate_random( int bytes_arg )
Gilles Peskine05d69892018-06-19 22:00:52 +02006646{
Gilles Peskinea50d7392018-06-21 10:22:13 +02006647 size_t bytes = bytes_arg;
Gilles Peskine8cebbba2018-09-27 13:54:18 +02006648 unsigned char *output = NULL;
6649 unsigned char *changed = NULL;
Gilles Peskinea50d7392018-06-21 10:22:13 +02006650 size_t i;
6651 unsigned run;
Gilles Peskine05d69892018-06-19 22:00:52 +02006652
Simon Butcher49f8e312020-03-03 15:51:50 +00006653 TEST_ASSERT( bytes_arg >= 0 );
6654
Gilles Peskine91892022021-02-08 19:50:26 +01006655 ASSERT_ALLOC( output, bytes );
Gilles Peskine8cebbba2018-09-27 13:54:18 +02006656 ASSERT_ALLOC( changed, bytes );
Gilles Peskine05d69892018-06-19 22:00:52 +02006657
Gilles Peskine8817f612018-12-18 00:18:46 +01006658 PSA_ASSERT( psa_crypto_init( ) );
Gilles Peskine05d69892018-06-19 22:00:52 +02006659
Gilles Peskinea50d7392018-06-21 10:22:13 +02006660 /* Run several times, to ensure that every output byte will be
6661 * nonzero at least once with overwhelming probability
6662 * (2^(-8*number_of_runs)). */
6663 for( run = 0; run < 10; run++ )
Gilles Peskine05d69892018-06-19 22:00:52 +02006664 {
Gilles Peskinef7ab5ad2018-09-26 18:19:24 +02006665 if( bytes != 0 )
6666 memset( output, 0, bytes );
Gilles Peskine8817f612018-12-18 00:18:46 +01006667 PSA_ASSERT( psa_generate_random( output, bytes ) );
Gilles Peskinea50d7392018-06-21 10:22:13 +02006668
Gilles Peskinea50d7392018-06-21 10:22:13 +02006669 for( i = 0; i < bytes; i++ )
6670 {
6671 if( output[i] != 0 )
6672 ++changed[i];
6673 }
Gilles Peskine05d69892018-06-19 22:00:52 +02006674 }
Gilles Peskinea50d7392018-06-21 10:22:13 +02006675
6676 /* Check that every byte was changed to nonzero at least once. This
6677 * validates that psa_generate_random is overwriting every byte of
6678 * the output buffer. */
6679 for( i = 0; i < bytes; i++ )
6680 {
6681 TEST_ASSERT( changed[i] != 0 );
6682 }
Gilles Peskine05d69892018-06-19 22:00:52 +02006683
6684exit:
Gilles Peskine1153e7b2019-05-28 15:10:21 +02006685 PSA_DONE( );
Gilles Peskinea50d7392018-06-21 10:22:13 +02006686 mbedtls_free( output );
6687 mbedtls_free( changed );
Gilles Peskine05d69892018-06-19 22:00:52 +02006688}
6689/* END_CASE */
Gilles Peskine12313cd2018-06-20 00:20:32 +02006690
6691/* BEGIN_CASE */
6692void generate_key( int type_arg,
6693 int bits_arg,
6694 int usage_arg,
6695 int alg_arg,
Steven Cooreman83fdb702021-01-21 14:24:39 +01006696 int expected_status_arg,
6697 int is_large_key )
Gilles Peskine12313cd2018-06-20 00:20:32 +02006698{
Ronald Cron5425a212020-08-04 14:58:35 +02006699 mbedtls_svc_key_id_t key = MBEDTLS_SVC_KEY_ID_INIT;
Gilles Peskine12313cd2018-06-20 00:20:32 +02006700 psa_key_type_t type = type_arg;
6701 psa_key_usage_t usage = usage_arg;
6702 size_t bits = bits_arg;
6703 psa_algorithm_t alg = alg_arg;
6704 psa_status_t expected_status = expected_status_arg;
Gilles Peskineff5f0e72019-04-18 12:53:30 +02006705 psa_key_attributes_t attributes = PSA_KEY_ATTRIBUTES_INIT;
Gilles Peskine8c8f2ab2019-04-18 21:44:46 +02006706 psa_key_attributes_t got_attributes = PSA_KEY_ATTRIBUTES_INIT;
Gilles Peskine12313cd2018-06-20 00:20:32 +02006707
Gilles Peskine8817f612018-12-18 00:18:46 +01006708 PSA_ASSERT( psa_crypto_init( ) );
Gilles Peskine12313cd2018-06-20 00:20:32 +02006709
Gilles Peskineff5f0e72019-04-18 12:53:30 +02006710 psa_set_key_usage_flags( &attributes, usage );
6711 psa_set_key_algorithm( &attributes, alg );
6712 psa_set_key_type( &attributes, type );
Gilles Peskine3a4f1f82019-04-26 13:49:28 +02006713 psa_set_key_bits( &attributes, bits );
Gilles Peskine12313cd2018-06-20 00:20:32 +02006714
6715 /* Generate a key */
Steven Cooreman83fdb702021-01-21 14:24:39 +01006716 psa_status_t status = psa_generate_key( &attributes, &key );
6717
6718 if( is_large_key > 0 )
6719 TEST_ASSUME( status != PSA_ERROR_INSUFFICIENT_MEMORY );
6720 TEST_EQUAL( status , expected_status );
Gilles Peskinee56e8782019-04-26 17:34:02 +02006721 if( expected_status != PSA_SUCCESS )
Gilles Peskineff5f0e72019-04-18 12:53:30 +02006722 goto exit;
Gilles Peskine12313cd2018-06-20 00:20:32 +02006723
6724 /* Test the key information */
Ronald Cron5425a212020-08-04 14:58:35 +02006725 PSA_ASSERT( psa_get_key_attributes( key, &got_attributes ) );
Gilles Peskine8c8f2ab2019-04-18 21:44:46 +02006726 TEST_EQUAL( psa_get_key_type( &got_attributes ), type );
6727 TEST_EQUAL( psa_get_key_bits( &got_attributes ), bits );
Gilles Peskine12313cd2018-06-20 00:20:32 +02006728
Gilles Peskine818ca122018-06-20 18:16:48 +02006729 /* Do something with the key according to its type and permitted usage. */
Gilles Peskinec18e25f2021-02-12 23:48:20 +01006730 if( ! mbedtls_test_psa_exercise_key( key, usage, alg ) )
Gilles Peskine02b75072018-07-01 22:31:34 +02006731 goto exit;
Gilles Peskine12313cd2018-06-20 00:20:32 +02006732
6733exit:
Ronald Cron3a4f0e32020-11-19 17:55:23 +01006734 /*
6735 * Key attributes may have been returned by psa_get_key_attributes()
6736 * thus reset them as required.
6737 */
Gilles Peskinea1ace9c2019-04-26 16:03:33 +02006738 psa_reset_key_attributes( &got_attributes );
Ronald Cron3a4f0e32020-11-19 17:55:23 +01006739
Ronald Cron5425a212020-08-04 14:58:35 +02006740 psa_destroy_key( key );
Gilles Peskine1153e7b2019-05-28 15:10:21 +02006741 PSA_DONE( );
Gilles Peskine12313cd2018-06-20 00:20:32 +02006742}
6743/* END_CASE */
itayzafrir0adf0fc2018-09-06 16:24:41 +03006744
Ronald Cronee414c72021-03-18 18:50:08 +01006745/* 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 +02006746void generate_key_rsa( int bits_arg,
6747 data_t *e_arg,
6748 int expected_status_arg )
6749{
Ronald Cron5425a212020-08-04 14:58:35 +02006750 mbedtls_svc_key_id_t key = MBEDTLS_SVC_KEY_ID_INIT;
Gilles Peskinec93b80c2019-05-16 19:39:54 +02006751 psa_key_type_t type = PSA_KEY_TYPE_RSA_KEY_PAIR;
Gilles Peskinee56e8782019-04-26 17:34:02 +02006752 size_t bits = bits_arg;
6753 psa_key_usage_t usage = PSA_KEY_USAGE_ENCRYPT | PSA_KEY_USAGE_DECRYPT;
6754 psa_algorithm_t alg = PSA_ALG_RSA_PKCS1V15_SIGN_RAW;
6755 psa_status_t expected_status = expected_status_arg;
6756 psa_key_attributes_t attributes = PSA_KEY_ATTRIBUTES_INIT;
6757 uint8_t *exported = NULL;
6758 size_t exported_size =
gabor-mezei-armcbcec212020-12-18 14:23:51 +01006759 PSA_EXPORT_KEY_OUTPUT_SIZE( PSA_KEY_TYPE_RSA_PUBLIC_KEY, bits );
Gilles Peskinee56e8782019-04-26 17:34:02 +02006760 size_t exported_length = SIZE_MAX;
6761 uint8_t *e_read_buffer = NULL;
6762 int is_default_public_exponent = 0;
Gilles Peskineaa02c172019-04-28 11:44:17 +02006763 size_t e_read_size = PSA_KEY_DOMAIN_PARAMETERS_SIZE( type, bits );
Gilles Peskinee56e8782019-04-26 17:34:02 +02006764 size_t e_read_length = SIZE_MAX;
6765
6766 if( e_arg->len == 0 ||
6767 ( e_arg->len == 3 &&
6768 e_arg->x[0] == 1 && e_arg->x[1] == 0 && e_arg->x[2] == 1 ) )
6769 {
6770 is_default_public_exponent = 1;
6771 e_read_size = 0;
6772 }
6773 ASSERT_ALLOC( e_read_buffer, e_read_size );
6774 ASSERT_ALLOC( exported, exported_size );
6775
6776 PSA_ASSERT( psa_crypto_init( ) );
6777
6778 psa_set_key_usage_flags( &attributes, usage );
6779 psa_set_key_algorithm( &attributes, alg );
6780 PSA_ASSERT( psa_set_key_domain_parameters( &attributes, type,
6781 e_arg->x, e_arg->len ) );
6782 psa_set_key_bits( &attributes, bits );
6783
6784 /* Generate a key */
Ronald Cron5425a212020-08-04 14:58:35 +02006785 TEST_EQUAL( psa_generate_key( &attributes, &key ), expected_status );
Gilles Peskinee56e8782019-04-26 17:34:02 +02006786 if( expected_status != PSA_SUCCESS )
6787 goto exit;
6788
6789 /* Test the key information */
Ronald Cron5425a212020-08-04 14:58:35 +02006790 PSA_ASSERT( psa_get_key_attributes( key, &attributes ) );
Gilles Peskinee56e8782019-04-26 17:34:02 +02006791 TEST_EQUAL( psa_get_key_type( &attributes ), type );
6792 TEST_EQUAL( psa_get_key_bits( &attributes ), bits );
6793 PSA_ASSERT( psa_get_key_domain_parameters( &attributes,
6794 e_read_buffer, e_read_size,
6795 &e_read_length ) );
6796 if( is_default_public_exponent )
6797 TEST_EQUAL( e_read_length, 0 );
6798 else
6799 ASSERT_COMPARE( e_read_buffer, e_read_length, e_arg->x, e_arg->len );
6800
6801 /* Do something with the key according to its type and permitted usage. */
Gilles Peskinec18e25f2021-02-12 23:48:20 +01006802 if( ! mbedtls_test_psa_exercise_key( key, usage, alg ) )
Gilles Peskinee56e8782019-04-26 17:34:02 +02006803 goto exit;
6804
6805 /* Export the key and check the public exponent. */
Ronald Cron5425a212020-08-04 14:58:35 +02006806 PSA_ASSERT( psa_export_public_key( key,
Gilles Peskinee56e8782019-04-26 17:34:02 +02006807 exported, exported_size,
6808 &exported_length ) );
6809 {
6810 uint8_t *p = exported;
6811 uint8_t *end = exported + exported_length;
6812 size_t len;
6813 /* RSAPublicKey ::= SEQUENCE {
6814 * modulus INTEGER, -- n
6815 * publicExponent INTEGER } -- e
6816 */
6817 TEST_EQUAL( 0, mbedtls_asn1_get_tag( &p, end, &len,
Gilles Peskinecf7292e2019-05-16 17:53:40 +02006818 MBEDTLS_ASN1_SEQUENCE |
6819 MBEDTLS_ASN1_CONSTRUCTED ) );
Gilles Peskine8e94efe2021-02-13 00:25:53 +01006820 TEST_ASSERT( mbedtls_test_asn1_skip_integer( &p, end, bits, bits, 1 ) );
Gilles Peskinee56e8782019-04-26 17:34:02 +02006821 TEST_EQUAL( 0, mbedtls_asn1_get_tag( &p, end, &len,
6822 MBEDTLS_ASN1_INTEGER ) );
6823 if( len >= 1 && p[0] == 0 )
6824 {
6825 ++p;
6826 --len;
6827 }
6828 if( e_arg->len == 0 )
6829 {
6830 TEST_EQUAL( len, 3 );
6831 TEST_EQUAL( p[0], 1 );
6832 TEST_EQUAL( p[1], 0 );
6833 TEST_EQUAL( p[2], 1 );
6834 }
6835 else
6836 ASSERT_COMPARE( p, len, e_arg->x, e_arg->len );
6837 }
6838
6839exit:
Ronald Cron3a4f0e32020-11-19 17:55:23 +01006840 /*
6841 * Key attributes may have been returned by psa_get_key_attributes() or
6842 * set by psa_set_key_domain_parameters() thus reset them as required.
6843 */
Gilles Peskinee56e8782019-04-26 17:34:02 +02006844 psa_reset_key_attributes( &attributes );
Ronald Cron3a4f0e32020-11-19 17:55:23 +01006845
Ronald Cron5425a212020-08-04 14:58:35 +02006846 psa_destroy_key( key );
Gilles Peskine1153e7b2019-05-28 15:10:21 +02006847 PSA_DONE( );
Gilles Peskinee56e8782019-04-26 17:34:02 +02006848 mbedtls_free( e_read_buffer );
6849 mbedtls_free( exported );
6850}
6851/* END_CASE */
6852
Darryl Greend49a4992018-06-18 17:27:26 +01006853/* BEGIN_CASE depends_on:MBEDTLS_PSA_CRYPTO_STORAGE_C */
Gilles Peskine5c648ab2019-04-19 14:06:53 +02006854void persistent_key_load_key_from_storage( data_t *data,
6855 int type_arg, int bits_arg,
6856 int usage_flags_arg, int alg_arg,
6857 int generation_method )
Darryl Greend49a4992018-06-18 17:27:26 +01006858{
Ronald Cron71016a92020-08-28 19:01:50 +02006859 mbedtls_svc_key_id_t key_id = mbedtls_svc_key_id_make( 1, 1 );
Gilles Peskine5c648ab2019-04-19 14:06:53 +02006860 psa_key_attributes_t attributes = PSA_KEY_ATTRIBUTES_INIT;
Ronald Cron5425a212020-08-04 14:58:35 +02006861 mbedtls_svc_key_id_t key = MBEDTLS_SVC_KEY_ID_INIT;
6862 mbedtls_svc_key_id_t base_key = MBEDTLS_SVC_KEY_ID_INIT;
Gilles Peskine5c648ab2019-04-19 14:06:53 +02006863 psa_key_type_t type = type_arg;
6864 size_t bits = bits_arg;
6865 psa_key_usage_t usage_flags = usage_flags_arg;
6866 psa_algorithm_t alg = alg_arg;
Gilles Peskine51ae0e42019-05-16 17:31:03 +02006867 psa_key_derivation_operation_t operation = PSA_KEY_DERIVATION_OPERATION_INIT;
Darryl Greend49a4992018-06-18 17:27:26 +01006868 unsigned char *first_export = NULL;
6869 unsigned char *second_export = NULL;
gabor-mezei-armcbcec212020-12-18 14:23:51 +01006870 size_t export_size = PSA_EXPORT_KEY_OUTPUT_SIZE( type, bits );
Darryl Greend49a4992018-06-18 17:27:26 +01006871 size_t first_exported_length;
6872 size_t second_exported_length;
6873
Gilles Peskine5c648ab2019-04-19 14:06:53 +02006874 if( usage_flags & PSA_KEY_USAGE_EXPORT )
6875 {
6876 ASSERT_ALLOC( first_export, export_size );
6877 ASSERT_ALLOC( second_export, export_size );
6878 }
Darryl Greend49a4992018-06-18 17:27:26 +01006879
Gilles Peskine8817f612018-12-18 00:18:46 +01006880 PSA_ASSERT( psa_crypto_init() );
Darryl Greend49a4992018-06-18 17:27:26 +01006881
Gilles Peskinec87af662019-05-15 16:12:22 +02006882 psa_set_key_id( &attributes, key_id );
Gilles Peskine5c648ab2019-04-19 14:06:53 +02006883 psa_set_key_usage_flags( &attributes, usage_flags );
6884 psa_set_key_algorithm( &attributes, alg );
6885 psa_set_key_type( &attributes, type );
Gilles Peskine3a4f1f82019-04-26 13:49:28 +02006886 psa_set_key_bits( &attributes, bits );
Darryl Greend49a4992018-06-18 17:27:26 +01006887
Darryl Green0c6575a2018-11-07 16:05:30 +00006888 switch( generation_method )
6889 {
6890 case IMPORT_KEY:
6891 /* Import the key */
Gilles Peskine049c7532019-05-15 20:22:09 +02006892 PSA_ASSERT( psa_import_key( &attributes, data->x, data->len,
Ronald Cron5425a212020-08-04 14:58:35 +02006893 &key ) );
Darryl Green0c6575a2018-11-07 16:05:30 +00006894 break;
Darryl Greend49a4992018-06-18 17:27:26 +01006895
Darryl Green0c6575a2018-11-07 16:05:30 +00006896 case GENERATE_KEY:
6897 /* Generate a key */
Ronald Cron5425a212020-08-04 14:58:35 +02006898 PSA_ASSERT( psa_generate_key( &attributes, &key ) );
Darryl Green0c6575a2018-11-07 16:05:30 +00006899 break;
6900
6901 case DERIVE_KEY:
Steven Cooreman70f654a2021-02-15 10:51:43 +01006902#if defined(PSA_WANT_ALG_HKDF) && defined(PSA_WANT_ALG_SHA_256)
Gilles Peskine5c648ab2019-04-19 14:06:53 +02006903 {
6904 /* Create base key */
6905 psa_algorithm_t derive_alg = PSA_ALG_HKDF( PSA_ALG_SHA_256 );
6906 psa_key_attributes_t base_attributes = PSA_KEY_ATTRIBUTES_INIT;
6907 psa_set_key_usage_flags( &base_attributes,
6908 PSA_KEY_USAGE_DERIVE );
6909 psa_set_key_algorithm( &base_attributes, derive_alg );
6910 psa_set_key_type( &base_attributes, PSA_KEY_TYPE_DERIVE );
Gilles Peskine049c7532019-05-15 20:22:09 +02006911 PSA_ASSERT( psa_import_key( &base_attributes,
6912 data->x, data->len,
6913 &base_key ) );
Gilles Peskine5c648ab2019-04-19 14:06:53 +02006914 /* Derive a key. */
Gilles Peskine51ae0e42019-05-16 17:31:03 +02006915 PSA_ASSERT( psa_key_derivation_setup( &operation, derive_alg ) );
Gilles Peskinecf7292e2019-05-16 17:53:40 +02006916 PSA_ASSERT( psa_key_derivation_input_key(
6917 &operation,
6918 PSA_KEY_DERIVATION_INPUT_SECRET, base_key ) );
Gilles Peskine5c648ab2019-04-19 14:06:53 +02006919 PSA_ASSERT( psa_key_derivation_input_bytes(
Gilles Peskine51ae0e42019-05-16 17:31:03 +02006920 &operation, PSA_KEY_DERIVATION_INPUT_INFO,
Gilles Peskine5c648ab2019-04-19 14:06:53 +02006921 NULL, 0 ) );
Gilles Peskinecf7292e2019-05-16 17:53:40 +02006922 PSA_ASSERT( psa_key_derivation_output_key( &attributes,
6923 &operation,
Ronald Cron5425a212020-08-04 14:58:35 +02006924 &key ) );
Gilles Peskine51ae0e42019-05-16 17:31:03 +02006925 PSA_ASSERT( psa_key_derivation_abort( &operation ) );
Gilles Peskine5c648ab2019-04-19 14:06:53 +02006926 PSA_ASSERT( psa_destroy_key( base_key ) );
Ronald Cron5425a212020-08-04 14:58:35 +02006927 base_key = MBEDTLS_SVC_KEY_ID_INIT;
Gilles Peskine5c648ab2019-04-19 14:06:53 +02006928 }
Gilles Peskine6fea21d2021-01-12 00:02:15 +01006929#else
6930 TEST_ASSUME( ! "KDF not supported in this configuration" );
6931#endif
6932 break;
6933
6934 default:
6935 TEST_ASSERT( ! "generation_method not implemented in test" );
6936 break;
Darryl Green0c6575a2018-11-07 16:05:30 +00006937 }
Gilles Peskine5c648ab2019-04-19 14:06:53 +02006938 psa_reset_key_attributes( &attributes );
Darryl Greend49a4992018-06-18 17:27:26 +01006939
Gilles Peskine5c648ab2019-04-19 14:06:53 +02006940 /* Export the key if permitted by the key policy. */
6941 if( usage_flags & PSA_KEY_USAGE_EXPORT )
6942 {
Ronald Cron5425a212020-08-04 14:58:35 +02006943 PSA_ASSERT( psa_export_key( key,
Gilles Peskine5c648ab2019-04-19 14:06:53 +02006944 first_export, export_size,
6945 &first_exported_length ) );
6946 if( generation_method == IMPORT_KEY )
6947 ASSERT_COMPARE( data->x, data->len,
6948 first_export, first_exported_length );
6949 }
Darryl Greend49a4992018-06-18 17:27:26 +01006950
6951 /* Shutdown and restart */
Ronald Cron5425a212020-08-04 14:58:35 +02006952 PSA_ASSERT( psa_purge_key( key ) );
Gilles Peskine1153e7b2019-05-28 15:10:21 +02006953 PSA_DONE();
Gilles Peskine8817f612018-12-18 00:18:46 +01006954 PSA_ASSERT( psa_crypto_init() );
Darryl Greend49a4992018-06-18 17:27:26 +01006955
Darryl Greend49a4992018-06-18 17:27:26 +01006956 /* Check key slot still contains key data */
Ronald Cron5425a212020-08-04 14:58:35 +02006957 PSA_ASSERT( psa_get_key_attributes( key, &attributes ) );
Ronald Cronecfb2372020-07-23 17:13:42 +02006958 TEST_ASSERT( mbedtls_svc_key_id_equal(
6959 psa_get_key_id( &attributes ), key_id ) );
Gilles Peskine5c648ab2019-04-19 14:06:53 +02006960 TEST_EQUAL( psa_get_key_lifetime( &attributes ),
6961 PSA_KEY_LIFETIME_PERSISTENT );
6962 TEST_EQUAL( psa_get_key_type( &attributes ), type );
6963 TEST_EQUAL( psa_get_key_bits( &attributes ), bits );
gabor-mezei-arm4ff73032021-05-13 12:05:01 +02006964 TEST_EQUAL( psa_get_key_usage_flags( &attributes ),
gabor-mezei-arm98a34352021-06-28 14:05:00 +02006965 mbedtls_test_update_key_usage_flags( usage_flags ) );
Gilles Peskine5c648ab2019-04-19 14:06:53 +02006966 TEST_EQUAL( psa_get_key_algorithm( &attributes ), alg );
Darryl Greend49a4992018-06-18 17:27:26 +01006967
Gilles Peskine5c648ab2019-04-19 14:06:53 +02006968 /* Export the key again if permitted by the key policy. */
6969 if( usage_flags & PSA_KEY_USAGE_EXPORT )
Darryl Green0c6575a2018-11-07 16:05:30 +00006970 {
Ronald Cron5425a212020-08-04 14:58:35 +02006971 PSA_ASSERT( psa_export_key( key,
Gilles Peskine5c648ab2019-04-19 14:06:53 +02006972 second_export, export_size,
6973 &second_exported_length ) );
Darryl Green0c6575a2018-11-07 16:05:30 +00006974 ASSERT_COMPARE( first_export, first_exported_length,
6975 second_export, second_exported_length );
Darryl Green0c6575a2018-11-07 16:05:30 +00006976 }
6977
6978 /* Do something with the key according to its type and permitted usage. */
Gilles Peskinec18e25f2021-02-12 23:48:20 +01006979 if( ! mbedtls_test_psa_exercise_key( key, usage_flags, alg ) )
Darryl Green0c6575a2018-11-07 16:05:30 +00006980 goto exit;
Darryl Greend49a4992018-06-18 17:27:26 +01006981
6982exit:
Ronald Cron3a4f0e32020-11-19 17:55:23 +01006983 /*
6984 * Key attributes may have been returned by psa_get_key_attributes()
6985 * thus reset them as required.
6986 */
Gilles Peskinea1ace9c2019-04-26 16:03:33 +02006987 psa_reset_key_attributes( &attributes );
Ronald Cron3a4f0e32020-11-19 17:55:23 +01006988
Darryl Greend49a4992018-06-18 17:27:26 +01006989 mbedtls_free( first_export );
6990 mbedtls_free( second_export );
Gilles Peskine51ae0e42019-05-16 17:31:03 +02006991 psa_key_derivation_abort( &operation );
Gilles Peskine5c648ab2019-04-19 14:06:53 +02006992 psa_destroy_key( base_key );
Ronald Cron5425a212020-08-04 14:58:35 +02006993 psa_destroy_key( key );
Gilles Peskine1153e7b2019-05-28 15:10:21 +02006994 PSA_DONE();
Darryl Greend49a4992018-06-18 17:27:26 +01006995}
6996/* END_CASE */