1/*
2 * Test driver for AEAD entry points.
3 */
4/*  Copyright The Mbed TLS Contributors
5 *  SPDX-License-Identifier: Apache-2.0 OR GPL-2.0-or-later
6 */
7
8#include <test/helpers.h>
9
10#if defined(PSA_CRYPTO_DRIVER_TEST)
11#include "psa_crypto_aead.h"
12#include "psa_crypto_core.h"
13
14#include "test/drivers/aead.h"
15
16#include "mbedtls/constant_time.h"
17
18#if defined(MBEDTLS_TEST_LIBTESTDRIVER1)
19#include "libtestdriver1/library/psa_crypto_aead.h"
20#endif
21
22mbedtls_test_driver_aead_hooks_t
23    mbedtls_test_driver_aead_hooks = MBEDTLS_TEST_DRIVER_AEAD_INIT;
24
25psa_status_t mbedtls_test_transparent_aead_encrypt(
26    const psa_key_attributes_t *attributes,
27    const uint8_t *key_buffer, size_t key_buffer_size,
28    psa_algorithm_t alg,
29    const uint8_t *nonce, size_t nonce_length,
30    const uint8_t *additional_data, size_t additional_data_length,
31    const uint8_t *plaintext, size_t plaintext_length,
32    uint8_t *ciphertext, size_t ciphertext_size, size_t *ciphertext_length)
33{
34    mbedtls_test_driver_aead_hooks.hits_encrypt++;
35
36    if (mbedtls_test_driver_aead_hooks.forced_status != PSA_SUCCESS) {
37        mbedtls_test_driver_aead_hooks.driver_status =
38            mbedtls_test_driver_aead_hooks.forced_status;
39    } else {
40#if defined(MBEDTLS_TEST_LIBTESTDRIVER1) && \
41        defined(LIBTESTDRIVER1_MBEDTLS_PSA_BUILTIN_AEAD)
42        mbedtls_test_driver_aead_hooks.driver_status =
43            libtestdriver1_mbedtls_psa_aead_encrypt(
44                (const libtestdriver1_psa_key_attributes_t *) attributes,
45                key_buffer, key_buffer_size,
46                alg,
47                nonce, nonce_length,
48                additional_data, additional_data_length,
49                plaintext, plaintext_length,
50                ciphertext, ciphertext_size, ciphertext_length);
51#elif defined(MBEDTLS_PSA_BUILTIN_AEAD)
52        mbedtls_test_driver_aead_hooks.driver_status =
53            mbedtls_psa_aead_encrypt(
54                attributes, key_buffer, key_buffer_size,
55                alg,
56                nonce, nonce_length,
57                additional_data, additional_data_length,
58                plaintext, plaintext_length,
59                ciphertext, ciphertext_size, ciphertext_length);
60#else
61        (void) attributes;
62        (void) key_buffer;
63        (void) key_buffer_size;
64        (void) alg;
65        (void) nonce;
66        (void) nonce_length;
67        (void) additional_data;
68        (void) additional_data_length;
69        (void) plaintext;
70        (void) plaintext_length;
71        (void) ciphertext;
72        (void) ciphertext_size;
73        (void) ciphertext_length;
74        mbedtls_test_driver_aead_hooks.driver_status = PSA_ERROR_NOT_SUPPORTED;
75#endif
76    }
77
78    return mbedtls_test_driver_aead_hooks.driver_status;
79}
80
81psa_status_t mbedtls_test_transparent_aead_decrypt(
82    const psa_key_attributes_t *attributes,
83    const uint8_t *key_buffer, size_t key_buffer_size,
84    psa_algorithm_t alg,
85    const uint8_t *nonce, size_t nonce_length,
86    const uint8_t *additional_data, size_t additional_data_length,
87    const uint8_t *ciphertext, size_t ciphertext_length,
88    uint8_t *plaintext, size_t plaintext_size, size_t *plaintext_length)
89{
90    mbedtls_test_driver_aead_hooks.hits_decrypt++;
91
92    if (mbedtls_test_driver_aead_hooks.forced_status != PSA_SUCCESS) {
93        mbedtls_test_driver_aead_hooks.driver_status =
94            mbedtls_test_driver_aead_hooks.forced_status;
95    } else {
96#if defined(MBEDTLS_TEST_LIBTESTDRIVER1) && \
97        defined(LIBTESTDRIVER1_MBEDTLS_PSA_BUILTIN_AEAD)
98        mbedtls_test_driver_aead_hooks.driver_status =
99            libtestdriver1_mbedtls_psa_aead_decrypt(
100                (const libtestdriver1_psa_key_attributes_t *) attributes,
101                key_buffer, key_buffer_size,
102                alg,
103                nonce, nonce_length,
104                additional_data, additional_data_length,
105                ciphertext, ciphertext_length,
106                plaintext, plaintext_size, plaintext_length);
107#elif defined(MBEDTLS_PSA_BUILTIN_AEAD)
108        mbedtls_test_driver_aead_hooks.driver_status =
109            mbedtls_psa_aead_decrypt(
110                attributes, key_buffer, key_buffer_size,
111                alg,
112                nonce, nonce_length,
113                additional_data, additional_data_length,
114                ciphertext, ciphertext_length,
115                plaintext, plaintext_size, plaintext_length);
116#else
117        (void) attributes;
118        (void) key_buffer;
119        (void) key_buffer_size;
120        (void) alg;
121        (void) nonce;
122        (void) nonce_length;
123        (void) additional_data;
124        (void) additional_data_length;
125        (void) ciphertext;
126        (void) ciphertext_length;
127        (void) plaintext;
128        (void) plaintext_size;
129        (void) plaintext_length;
130        mbedtls_test_driver_aead_hooks.driver_status = PSA_ERROR_NOT_SUPPORTED;
131#endif
132    }
133
134    return mbedtls_test_driver_aead_hooks.driver_status;
135}
136
137psa_status_t mbedtls_test_transparent_aead_encrypt_setup(
138    mbedtls_transparent_test_driver_aead_operation_t *operation,
139    const psa_key_attributes_t *attributes,
140    const uint8_t *key_buffer, size_t key_buffer_size,
141    psa_algorithm_t alg)
142{
143    mbedtls_test_driver_aead_hooks.hits_encrypt_setup++;
144
145    if (mbedtls_test_driver_aead_hooks.forced_status != PSA_SUCCESS) {
146        mbedtls_test_driver_aead_hooks.driver_status =
147            mbedtls_test_driver_aead_hooks.forced_status;
148    } else {
149#if defined(MBEDTLS_TEST_LIBTESTDRIVER1) && \
150        defined(LIBTESTDRIVER1_MBEDTLS_PSA_BUILTIN_AEAD)
151        mbedtls_test_driver_aead_hooks.driver_status =
152            libtestdriver1_mbedtls_psa_aead_encrypt_setup(operation,
153                                                          (const libtestdriver1_psa_key_attributes_t
154                                                           *) attributes,
155                                                          key_buffer,
156                                                          key_buffer_size, alg);
157#elif defined(MBEDTLS_PSA_BUILTIN_AEAD)
158        mbedtls_test_driver_aead_hooks.driver_status =
159            mbedtls_psa_aead_encrypt_setup(operation, attributes, key_buffer,
160                                           key_buffer_size, alg);
161#else
162        (void) operation;
163        (void) attributes;
164        (void) key_buffer;
165        (void) key_buffer_size;
166        (void) alg;
167        mbedtls_test_driver_aead_hooks.driver_status = PSA_ERROR_NOT_SUPPORTED;
168#endif
169    }
170
171    return mbedtls_test_driver_aead_hooks.driver_status;
172}
173
174psa_status_t mbedtls_test_transparent_aead_decrypt_setup(
175    mbedtls_transparent_test_driver_aead_operation_t *operation,
176    const psa_key_attributes_t *attributes,
177    const uint8_t *key_buffer, size_t key_buffer_size,
178    psa_algorithm_t alg)
179{
180    mbedtls_test_driver_aead_hooks.hits_decrypt_setup++;
181
182    if (mbedtls_test_driver_aead_hooks.forced_status != PSA_SUCCESS) {
183        mbedtls_test_driver_aead_hooks.driver_status =
184            mbedtls_test_driver_aead_hooks.forced_status;
185    } else {
186#if defined(MBEDTLS_TEST_LIBTESTDRIVER1) && \
187        defined(LIBTESTDRIVER1_MBEDTLS_PSA_BUILTIN_AEAD)
188        mbedtls_test_driver_aead_hooks.driver_status =
189            libtestdriver1_mbedtls_psa_aead_decrypt_setup(operation,
190                                                          (const libtestdriver1_psa_key_attributes_t
191                                                           *) attributes,
192                                                          key_buffer, key_buffer_size, alg);
193#elif defined(MBEDTLS_PSA_BUILTIN_AEAD)
194        mbedtls_test_driver_aead_hooks.driver_status =
195            mbedtls_psa_aead_decrypt_setup(operation, attributes, key_buffer,
196                                           key_buffer_size, alg);
197#else
198        (void) operation;
199        (void) attributes;
200        (void) key_buffer;
201        (void) key_buffer_size;
202        (void) alg;
203        mbedtls_test_driver_aead_hooks.driver_status = PSA_ERROR_NOT_SUPPORTED;
204#endif
205    }
206
207    return mbedtls_test_driver_aead_hooks.driver_status;
208}
209
210psa_status_t mbedtls_test_transparent_aead_set_nonce(
211    mbedtls_transparent_test_driver_aead_operation_t *operation,
212    const uint8_t *nonce,
213    size_t nonce_length)
214{
215    mbedtls_test_driver_aead_hooks.hits_set_nonce++;
216
217    if (mbedtls_test_driver_aead_hooks.forced_status != PSA_SUCCESS) {
218        mbedtls_test_driver_aead_hooks.driver_status =
219            mbedtls_test_driver_aead_hooks.forced_status;
220    } else {
221#if defined(MBEDTLS_TEST_LIBTESTDRIVER1) && \
222        defined(LIBTESTDRIVER1_MBEDTLS_PSA_BUILTIN_AEAD)
223        mbedtls_test_driver_aead_hooks.driver_status =
224            libtestdriver1_mbedtls_psa_aead_set_nonce(operation, nonce, nonce_length);
225#elif defined(MBEDTLS_PSA_BUILTIN_AEAD)
226        mbedtls_test_driver_aead_hooks.driver_status =
227            mbedtls_psa_aead_set_nonce(operation, nonce, nonce_length);
228#else
229        (void) operation;
230        (void) nonce;
231        (void) nonce_length;
232        mbedtls_test_driver_aead_hooks.driver_status = PSA_ERROR_NOT_SUPPORTED;
233#endif
234    }
235
236    return mbedtls_test_driver_aead_hooks.driver_status;
237}
238
239psa_status_t mbedtls_test_transparent_aead_set_lengths(
240    mbedtls_transparent_test_driver_aead_operation_t *operation,
241    size_t ad_length,
242    size_t plaintext_length)
243{
244    mbedtls_test_driver_aead_hooks.hits_set_lengths++;
245
246    if (mbedtls_test_driver_aead_hooks.forced_status != PSA_SUCCESS) {
247        mbedtls_test_driver_aead_hooks.driver_status =
248            mbedtls_test_driver_aead_hooks.forced_status;
249    } else {
250#if defined(MBEDTLS_TEST_LIBTESTDRIVER1) && \
251        defined(LIBTESTDRIVER1_MBEDTLS_PSA_BUILTIN_AEAD)
252        mbedtls_test_driver_aead_hooks.driver_status =
253            libtestdriver1_mbedtls_psa_aead_set_lengths(operation, ad_length,
254                                                        plaintext_length);
255#elif defined(MBEDTLS_PSA_BUILTIN_AEAD)
256        mbedtls_test_driver_aead_hooks.driver_status =
257            mbedtls_psa_aead_set_lengths(operation, ad_length,
258                                         plaintext_length);
259#else
260        (void) operation;
261        (void) ad_length;
262        (void) plaintext_length;
263        mbedtls_test_driver_aead_hooks.driver_status = PSA_ERROR_NOT_SUPPORTED;
264#endif
265    }
266
267    return mbedtls_test_driver_aead_hooks.driver_status;
268}
269
270psa_status_t mbedtls_test_transparent_aead_update_ad(
271    mbedtls_transparent_test_driver_aead_operation_t *operation,
272    const uint8_t *input,
273    size_t input_length)
274{
275    mbedtls_test_driver_aead_hooks.hits_update_ad++;
276
277    if (mbedtls_test_driver_aead_hooks.forced_status != PSA_SUCCESS) {
278        mbedtls_test_driver_aead_hooks.driver_status =
279            mbedtls_test_driver_aead_hooks.forced_status;
280    } else {
281#if defined(MBEDTLS_TEST_LIBTESTDRIVER1) && \
282        defined(LIBTESTDRIVER1_MBEDTLS_PSA_BUILTIN_AEAD)
283        mbedtls_test_driver_aead_hooks.driver_status =
284            libtestdriver1_mbedtls_psa_aead_update_ad(operation, input, input_length);
285#elif defined(MBEDTLS_PSA_BUILTIN_AEAD)
286        mbedtls_test_driver_aead_hooks.driver_status =
287            mbedtls_psa_aead_update_ad(operation, input, input_length);
288#else
289        (void) operation;
290        (void) input;
291        (void) input_length;
292        mbedtls_test_driver_aead_hooks.driver_status = PSA_ERROR_NOT_SUPPORTED;
293#endif
294    }
295
296    return mbedtls_test_driver_aead_hooks.driver_status;
297}
298
299psa_status_t mbedtls_test_transparent_aead_update(
300    mbedtls_transparent_test_driver_aead_operation_t *operation,
301    const uint8_t *input,
302    size_t input_length,
303    uint8_t *output,
304    size_t output_size,
305    size_t *output_length)
306{
307    mbedtls_test_driver_aead_hooks.hits_update++;
308
309    if (mbedtls_test_driver_aead_hooks.forced_status != PSA_SUCCESS) {
310        mbedtls_test_driver_aead_hooks.driver_status =
311            mbedtls_test_driver_aead_hooks.forced_status;
312    } else {
313#if defined(MBEDTLS_TEST_LIBTESTDRIVER1) && \
314        defined(LIBTESTDRIVER1_MBEDTLS_PSA_BUILTIN_AEAD)
315        mbedtls_test_driver_aead_hooks.driver_status =
316            libtestdriver1_mbedtls_psa_aead_update(operation, input,
317                                                   input_length, output,
318                                                   output_size, output_length);
319#elif defined(MBEDTLS_PSA_BUILTIN_AEAD)
320        mbedtls_test_driver_aead_hooks.driver_status =
321            mbedtls_psa_aead_update(operation, input, input_length, output,
322                                    output_size, output_length);
323#else
324        (void) operation;
325        (void) input;
326        (void) input_length;
327        (void) output;
328        (void) output_size;
329        (void) output_length;
330        mbedtls_test_driver_aead_hooks.driver_status = PSA_ERROR_NOT_SUPPORTED;
331#endif
332    }
333
334    return mbedtls_test_driver_aead_hooks.driver_status;
335}
336
337psa_status_t mbedtls_test_transparent_aead_finish(
338    mbedtls_transparent_test_driver_aead_operation_t *operation,
339    uint8_t *ciphertext,
340    size_t ciphertext_size,
341    size_t *ciphertext_length,
342    uint8_t *tag,
343    size_t tag_size,
344    size_t *tag_length)
345{
346    mbedtls_test_driver_aead_hooks.hits_finish++;
347
348    if (mbedtls_test_driver_aead_hooks.forced_status != PSA_SUCCESS) {
349        mbedtls_test_driver_aead_hooks.driver_status =
350            mbedtls_test_driver_aead_hooks.forced_status;
351    } else {
352#if defined(MBEDTLS_TEST_LIBTESTDRIVER1) && \
353        defined(LIBTESTDRIVER1_MBEDTLS_PSA_BUILTIN_AEAD)
354        mbedtls_test_driver_aead_hooks.driver_status =
355            libtestdriver1_mbedtls_psa_aead_finish(operation, ciphertext,
356                                                   ciphertext_size, ciphertext_length,
357                                                   tag, tag_size, tag_length);
358#elif defined(MBEDTLS_PSA_BUILTIN_AEAD)
359        mbedtls_test_driver_aead_hooks.driver_status =
360            mbedtls_psa_aead_finish(operation, ciphertext, ciphertext_size,
361                                    ciphertext_length, tag, tag_size,
362                                    tag_length);
363#else
364        (void) operation;
365        (void) ciphertext;
366        (void) ciphertext_size;
367        (void) ciphertext_length;
368        (void) tag;
369        (void) tag_size;
370        (void) tag_length;
371        mbedtls_test_driver_aead_hooks.driver_status = PSA_ERROR_NOT_SUPPORTED;
372#endif
373    }
374
375    return mbedtls_test_driver_aead_hooks.driver_status;
376}
377
378psa_status_t mbedtls_test_transparent_aead_verify(
379    mbedtls_transparent_test_driver_aead_operation_t *operation,
380    uint8_t *plaintext,
381    size_t plaintext_size,
382    size_t *plaintext_length,
383    const uint8_t *tag,
384    size_t tag_length)
385{
386    mbedtls_test_driver_aead_hooks.hits_verify++;
387
388    if (mbedtls_test_driver_aead_hooks.forced_status != PSA_SUCCESS) {
389        mbedtls_test_driver_aead_hooks.driver_status =
390            mbedtls_test_driver_aead_hooks.forced_status;
391    } else {
392        uint8_t check_tag[PSA_AEAD_TAG_MAX_SIZE];
393        size_t check_tag_length = 0;
394
395#if defined(MBEDTLS_TEST_LIBTESTDRIVER1) && \
396        defined(LIBTESTDRIVER1_MBEDTLS_PSA_BUILTIN_AEAD)
397        mbedtls_test_driver_aead_hooks.driver_status =
398            libtestdriver1_mbedtls_psa_aead_finish(operation,
399                                                   plaintext,
400                                                   plaintext_size,
401                                                   plaintext_length,
402                                                   check_tag,
403                                                   sizeof(check_tag),
404                                                   &check_tag_length);
405#elif defined(MBEDTLS_PSA_BUILTIN_AEAD)
406        mbedtls_test_driver_aead_hooks.driver_status =
407            mbedtls_psa_aead_finish(operation,
408                                    plaintext,
409                                    plaintext_size,
410                                    plaintext_length,
411                                    check_tag,
412                                    sizeof(check_tag),
413                                    &check_tag_length);
414#else
415        (void) operation;
416        (void) plaintext;
417        (void) plaintext_size;
418        (void) plaintext_length;
419        mbedtls_test_driver_aead_hooks.driver_status = PSA_ERROR_NOT_SUPPORTED;
420#endif
421
422        if (mbedtls_test_driver_aead_hooks.driver_status == PSA_SUCCESS) {
423            if (tag_length != check_tag_length ||
424                mbedtls_ct_memcmp(tag, check_tag, tag_length)
425                != 0) {
426                mbedtls_test_driver_aead_hooks.driver_status =
427                    PSA_ERROR_INVALID_SIGNATURE;
428            }
429        }
430
431        mbedtls_platform_zeroize(check_tag, sizeof(check_tag));
432    }
433
434    return mbedtls_test_driver_aead_hooks.driver_status;
435}
436
437psa_status_t mbedtls_test_transparent_aead_abort(
438    mbedtls_transparent_test_driver_aead_operation_t *operation)
439{
440    mbedtls_test_driver_aead_hooks.hits_abort++;
441
442    if (mbedtls_test_driver_aead_hooks.forced_status != PSA_SUCCESS) {
443        mbedtls_test_driver_aead_hooks.driver_status =
444            mbedtls_test_driver_aead_hooks.forced_status;
445    } else {
446#if defined(MBEDTLS_TEST_LIBTESTDRIVER1) && \
447        defined(LIBTESTDRIVER1_MBEDTLS_PSA_BUILTIN_AEAD)
448        mbedtls_test_driver_aead_hooks.driver_status =
449            libtestdriver1_mbedtls_psa_aead_abort(operation);
450#elif defined(MBEDTLS_PSA_BUILTIN_AEAD)
451        mbedtls_test_driver_aead_hooks.driver_status =
452            mbedtls_psa_aead_abort(operation);
453#else
454        (void) operation;
455        mbedtls_test_driver_aead_hooks.driver_status = PSA_ERROR_NOT_SUPPORTED;
456#endif
457    }
458
459    return mbedtls_test_driver_aead_hooks.driver_status;
460}
461
462#endif /* PSA_CRYPTO_DRIVER_TEST */
463