1 /*
2 * Test driver for AEAD entry points.
3 */
4 /* Copyright The Mbed TLS Contributors
5 * SPDX-License-Identifier: Apache-2.0
6 *
7 * Licensed under the Apache License, Version 2.0 (the "License"); you may
8 * not use this file except in compliance with the License.
9 * You may obtain a copy of the License at
10 *
11 * http://www.apache.org/licenses/LICENSE-2.0
12 *
13 * Unless required by applicable law or agreed to in writing, software
14 * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
15 * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
16 * See the License for the specific language governing permissions and
17 * limitations under the License.
18 */
19
20 #include <test/helpers.h>
21
22 #if defined(MBEDTLS_PSA_CRYPTO_DRIVERS) && defined(PSA_CRYPTO_DRIVER_TEST)
23 #include "psa_crypto_aead.h"
24 #include "psa_crypto_core.h"
25
26 #include "test/drivers/aead.h"
27
28 mbedtls_test_driver_aead_hooks_t
29 mbedtls_test_driver_aead_hooks = MBEDTLS_TEST_DRIVER_AEAD_INIT;
30
mbedtls_test_transparent_aead_encrypt(const psa_key_attributes_t * attributes,const uint8_t * key_buffer,size_t key_buffer_size,psa_algorithm_t alg,const uint8_t * nonce,size_t nonce_length,const uint8_t * additional_data,size_t additional_data_length,const uint8_t * plaintext,size_t plaintext_length,uint8_t * ciphertext,size_t ciphertext_size,size_t * ciphertext_length)31 psa_status_t mbedtls_test_transparent_aead_encrypt(
32 const psa_key_attributes_t *attributes,
33 const uint8_t *key_buffer, size_t key_buffer_size,
34 psa_algorithm_t alg,
35 const uint8_t *nonce, size_t nonce_length,
36 const uint8_t *additional_data, size_t additional_data_length,
37 const uint8_t *plaintext, size_t plaintext_length,
38 uint8_t *ciphertext, size_t ciphertext_size, size_t *ciphertext_length )
39 {
40 mbedtls_test_driver_aead_hooks.hits_encrypt++;
41
42 if( mbedtls_test_driver_aead_hooks.forced_status != PSA_SUCCESS )
43 {
44 mbedtls_test_driver_aead_hooks.driver_status =
45 mbedtls_test_driver_aead_hooks.forced_status;
46 }
47 else
48 {
49 mbedtls_test_driver_aead_hooks.driver_status =
50 mbedtls_psa_aead_encrypt(
51 attributes, key_buffer, key_buffer_size,
52 alg,
53 nonce, nonce_length,
54 additional_data, additional_data_length,
55 plaintext, plaintext_length,
56 ciphertext, ciphertext_size, ciphertext_length );
57 }
58
59 return( mbedtls_test_driver_aead_hooks.driver_status );
60 }
61
mbedtls_test_transparent_aead_decrypt(const psa_key_attributes_t * attributes,const uint8_t * key_buffer,size_t key_buffer_size,psa_algorithm_t alg,const uint8_t * nonce,size_t nonce_length,const uint8_t * additional_data,size_t additional_data_length,const uint8_t * ciphertext,size_t ciphertext_length,uint8_t * plaintext,size_t plaintext_size,size_t * plaintext_length)62 psa_status_t mbedtls_test_transparent_aead_decrypt(
63 const psa_key_attributes_t *attributes,
64 const uint8_t *key_buffer, size_t key_buffer_size,
65 psa_algorithm_t alg,
66 const uint8_t *nonce, size_t nonce_length,
67 const uint8_t *additional_data, size_t additional_data_length,
68 const uint8_t *ciphertext, size_t ciphertext_length,
69 uint8_t *plaintext, size_t plaintext_size, size_t *plaintext_length )
70 {
71 mbedtls_test_driver_aead_hooks.hits_decrypt++;
72
73 if( mbedtls_test_driver_aead_hooks.forced_status != PSA_SUCCESS )
74 {
75 mbedtls_test_driver_aead_hooks.driver_status =
76 mbedtls_test_driver_aead_hooks.forced_status;
77 }
78 else
79 {
80 mbedtls_test_driver_aead_hooks.driver_status =
81 mbedtls_psa_aead_decrypt(
82 attributes, key_buffer, key_buffer_size,
83 alg,
84 nonce, nonce_length,
85 additional_data, additional_data_length,
86 ciphertext, ciphertext_length,
87 plaintext, plaintext_size, plaintext_length );
88 }
89
90 return( mbedtls_test_driver_aead_hooks.driver_status );
91 }
92
mbedtls_test_transparent_aead_encrypt_setup(mbedtls_transparent_test_driver_aead_operation_t * operation,const psa_key_attributes_t * attributes,const uint8_t * key_buffer,size_t key_buffer_size,psa_algorithm_t alg)93 psa_status_t mbedtls_test_transparent_aead_encrypt_setup(
94 mbedtls_transparent_test_driver_aead_operation_t *operation,
95 const psa_key_attributes_t *attributes,
96 const uint8_t *key_buffer, size_t key_buffer_size,
97 psa_algorithm_t alg )
98 {
99 mbedtls_test_driver_aead_hooks.hits_encrypt_setup++;
100
101 if( mbedtls_test_driver_aead_hooks.forced_status != PSA_SUCCESS )
102 {
103 mbedtls_test_driver_aead_hooks.driver_status =
104 mbedtls_test_driver_aead_hooks.forced_status;
105 }
106 else
107 {
108 mbedtls_test_driver_aead_hooks.driver_status =
109 mbedtls_psa_aead_encrypt_setup( operation, attributes, key_buffer,
110 key_buffer_size, alg );
111 }
112
113 return( mbedtls_test_driver_aead_hooks.driver_status );
114 }
115
mbedtls_test_transparent_aead_decrypt_setup(mbedtls_transparent_test_driver_aead_operation_t * operation,const psa_key_attributes_t * attributes,const uint8_t * key_buffer,size_t key_buffer_size,psa_algorithm_t alg)116 psa_status_t mbedtls_test_transparent_aead_decrypt_setup(
117 mbedtls_transparent_test_driver_aead_operation_t *operation,
118 const psa_key_attributes_t *attributes,
119 const uint8_t *key_buffer, size_t key_buffer_size,
120 psa_algorithm_t alg )
121 {
122 mbedtls_test_driver_aead_hooks.hits_decrypt_setup++;
123
124 if( mbedtls_test_driver_aead_hooks.forced_status != PSA_SUCCESS )
125 {
126 mbedtls_test_driver_aead_hooks.driver_status =
127 mbedtls_test_driver_aead_hooks.forced_status;
128 }
129 else
130 {
131 mbedtls_test_driver_aead_hooks.driver_status =
132 mbedtls_psa_aead_decrypt_setup( operation, attributes, key_buffer,
133 key_buffer_size, alg );
134 }
135
136 return( mbedtls_test_driver_aead_hooks.driver_status );
137 }
138
mbedtls_test_transparent_aead_set_nonce(mbedtls_transparent_test_driver_aead_operation_t * operation,const uint8_t * nonce,size_t nonce_length)139 psa_status_t mbedtls_test_transparent_aead_set_nonce(
140 mbedtls_transparent_test_driver_aead_operation_t *operation,
141 const uint8_t *nonce,
142 size_t nonce_length )
143 {
144 mbedtls_test_driver_aead_hooks.hits_set_nonce++;
145
146 if( mbedtls_test_driver_aead_hooks.forced_status != PSA_SUCCESS )
147 {
148 mbedtls_test_driver_aead_hooks.driver_status =
149 mbedtls_test_driver_aead_hooks.forced_status;
150 }
151 else
152 {
153 mbedtls_test_driver_aead_hooks.driver_status =
154 mbedtls_psa_aead_set_nonce( operation, nonce, nonce_length );
155 }
156
157 return( mbedtls_test_driver_aead_hooks.driver_status );
158 }
159
mbedtls_test_transparent_aead_set_lengths(mbedtls_transparent_test_driver_aead_operation_t * operation,size_t ad_length,size_t plaintext_length)160 psa_status_t mbedtls_test_transparent_aead_set_lengths(
161 mbedtls_transparent_test_driver_aead_operation_t *operation,
162 size_t ad_length,
163 size_t plaintext_length )
164 {
165 mbedtls_test_driver_aead_hooks.hits_set_lengths++;
166
167 if( mbedtls_test_driver_aead_hooks.forced_status != PSA_SUCCESS )
168 {
169 mbedtls_test_driver_aead_hooks.driver_status =
170 mbedtls_test_driver_aead_hooks.forced_status;
171 }
172 else
173 {
174 mbedtls_test_driver_aead_hooks.driver_status =
175 mbedtls_psa_aead_set_lengths( operation, ad_length,
176 plaintext_length );
177 }
178
179 return( mbedtls_test_driver_aead_hooks.driver_status );
180 }
181
mbedtls_test_transparent_aead_update_ad(mbedtls_transparent_test_driver_aead_operation_t * operation,const uint8_t * input,size_t input_length)182 psa_status_t mbedtls_test_transparent_aead_update_ad(
183 mbedtls_transparent_test_driver_aead_operation_t *operation,
184 const uint8_t *input,
185 size_t input_length )
186 {
187 mbedtls_test_driver_aead_hooks.hits_update_ad++;
188
189 if( mbedtls_test_driver_aead_hooks.forced_status != PSA_SUCCESS )
190 {
191 mbedtls_test_driver_aead_hooks.driver_status =
192 mbedtls_test_driver_aead_hooks.forced_status;
193 }
194 else
195 {
196 mbedtls_test_driver_aead_hooks.driver_status =
197 mbedtls_psa_aead_update_ad( operation, input, input_length );
198 }
199
200 return( mbedtls_test_driver_aead_hooks.driver_status );
201 }
202
mbedtls_test_transparent_aead_update(mbedtls_transparent_test_driver_aead_operation_t * operation,const uint8_t * input,size_t input_length,uint8_t * output,size_t output_size,size_t * output_length)203 psa_status_t mbedtls_test_transparent_aead_update(
204 mbedtls_transparent_test_driver_aead_operation_t *operation,
205 const uint8_t *input,
206 size_t input_length,
207 uint8_t *output,
208 size_t output_size,
209 size_t *output_length )
210 {
211 mbedtls_test_driver_aead_hooks.hits_update++;
212
213 if( mbedtls_test_driver_aead_hooks.forced_status != PSA_SUCCESS )
214 {
215 mbedtls_test_driver_aead_hooks.driver_status =
216 mbedtls_test_driver_aead_hooks.forced_status;
217 }
218 else
219 {
220 mbedtls_test_driver_aead_hooks.driver_status =
221 mbedtls_psa_aead_update( operation, input, input_length, output,
222 output_size, output_length );
223 }
224
225 return( mbedtls_test_driver_aead_hooks.driver_status );
226 }
227
mbedtls_test_transparent_aead_finish(mbedtls_transparent_test_driver_aead_operation_t * operation,uint8_t * ciphertext,size_t ciphertext_size,size_t * ciphertext_length,uint8_t * tag,size_t tag_size,size_t * tag_length)228 psa_status_t mbedtls_test_transparent_aead_finish(
229 mbedtls_transparent_test_driver_aead_operation_t *operation,
230 uint8_t *ciphertext,
231 size_t ciphertext_size,
232 size_t *ciphertext_length,
233 uint8_t *tag,
234 size_t tag_size,
235 size_t *tag_length )
236 {
237 mbedtls_test_driver_aead_hooks.hits_finish++;
238
239 if( mbedtls_test_driver_aead_hooks.forced_status != PSA_SUCCESS )
240 {
241 mbedtls_test_driver_aead_hooks.driver_status =
242 mbedtls_test_driver_aead_hooks.forced_status;
243 }
244 else
245 {
246 mbedtls_test_driver_aead_hooks.driver_status =
247 mbedtls_psa_aead_finish( operation, ciphertext, ciphertext_size,
248 ciphertext_length, tag, tag_size,
249 tag_length );
250 }
251
252 return( mbedtls_test_driver_aead_hooks.driver_status );
253 }
254
mbedtls_test_transparent_aead_verify(mbedtls_transparent_test_driver_aead_operation_t * operation,uint8_t * plaintext,size_t plaintext_size,size_t * plaintext_length,const uint8_t * tag,size_t tag_length)255 psa_status_t mbedtls_test_transparent_aead_verify(
256 mbedtls_transparent_test_driver_aead_operation_t *operation,
257 uint8_t *plaintext,
258 size_t plaintext_size,
259 size_t *plaintext_length,
260 const uint8_t *tag,
261 size_t tag_length )
262 {
263 mbedtls_test_driver_aead_hooks.hits_verify++;
264
265 if( mbedtls_test_driver_aead_hooks.forced_status != PSA_SUCCESS )
266 {
267 mbedtls_test_driver_aead_hooks.driver_status =
268 mbedtls_test_driver_aead_hooks.forced_status;
269 }
270 else
271 {
272 uint8_t check_tag[PSA_AEAD_TAG_MAX_SIZE];
273 size_t check_tag_length;
274
275 mbedtls_test_driver_aead_hooks.driver_status =
276 mbedtls_psa_aead_finish( operation,
277 plaintext,
278 plaintext_size,
279 plaintext_length,
280 check_tag,
281 sizeof( check_tag ),
282 &check_tag_length );
283
284 if( mbedtls_test_driver_aead_hooks.driver_status == PSA_SUCCESS )
285 {
286 if( tag_length != check_tag_length ||
287 mbedtls_psa_safer_memcmp( tag, check_tag, tag_length )
288 != 0 )
289 mbedtls_test_driver_aead_hooks.driver_status =
290 PSA_ERROR_INVALID_SIGNATURE;
291 }
292
293 mbedtls_platform_zeroize( check_tag, sizeof( check_tag ) );
294 }
295
296 return( mbedtls_test_driver_aead_hooks.driver_status );
297 }
298
mbedtls_test_transparent_aead_abort(mbedtls_transparent_test_driver_aead_operation_t * operation)299 psa_status_t mbedtls_test_transparent_aead_abort(
300 mbedtls_transparent_test_driver_aead_operation_t *operation )
301 {
302 mbedtls_test_driver_aead_hooks.hits_abort++;
303
304 if( mbedtls_test_driver_aead_hooks.forced_status != PSA_SUCCESS )
305 {
306 mbedtls_test_driver_aead_hooks.driver_status =
307 mbedtls_test_driver_aead_hooks.forced_status;
308 }
309 else
310 {
311 mbedtls_test_driver_aead_hooks.driver_status =
312 mbedtls_psa_aead_abort( operation );
313 }
314
315 return( mbedtls_test_driver_aead_hooks.driver_status );
316 }
317
318 #endif /* MBEDTLS_PSA_CRYPTO_DRIVERS && PSA_CRYPTO_DRIVER_TEST */
319