1/*
2 * Test driver for cipher functions.
3 * Currently only supports multi-part operations using AES-CTR.
4 */
5/*  Copyright The Mbed TLS Contributors
6 *  SPDX-License-Identifier: Apache-2.0 OR GPL-2.0-or-later
7 */
8
9#include <test/helpers.h>
10
11#if defined(PSA_CRYPTO_DRIVER_TEST)
12#include "psa/crypto.h"
13#include "psa_crypto_cipher.h"
14#include "psa_crypto_core.h"
15#include "mbedtls/cipher.h"
16
17#include "test/drivers/cipher.h"
18
19#include "test/random.h"
20
21#if defined(MBEDTLS_TEST_LIBTESTDRIVER1)
22#include "libtestdriver1/library/psa_crypto_cipher.h"
23#endif
24
25#include <string.h>
26
27mbedtls_test_driver_cipher_hooks_t mbedtls_test_driver_cipher_hooks =
28    MBEDTLS_TEST_DRIVER_CIPHER_INIT;
29
30psa_status_t mbedtls_test_transparent_cipher_encrypt(
31    const psa_key_attributes_t *attributes,
32    const uint8_t *key_buffer,
33    size_t key_buffer_size,
34    psa_algorithm_t alg,
35    const uint8_t *iv,
36    size_t iv_length,
37    const uint8_t *input,
38    size_t input_length,
39    uint8_t *output,
40    size_t output_size,
41    size_t *output_length)
42{
43    mbedtls_test_driver_cipher_hooks.hits++;
44    mbedtls_test_driver_cipher_hooks.hits_encrypt++;
45
46    if (mbedtls_test_driver_cipher_hooks.forced_output != NULL) {
47        if (output_size < mbedtls_test_driver_cipher_hooks.forced_output_length) {
48            return PSA_ERROR_BUFFER_TOO_SMALL;
49        }
50
51        memcpy(output,
52               mbedtls_test_driver_cipher_hooks.forced_output,
53               mbedtls_test_driver_cipher_hooks.forced_output_length);
54        *output_length = mbedtls_test_driver_cipher_hooks.forced_output_length;
55
56        return mbedtls_test_driver_cipher_hooks.forced_status;
57    }
58
59    if (mbedtls_test_driver_cipher_hooks.forced_status != PSA_SUCCESS) {
60        return mbedtls_test_driver_cipher_hooks.forced_status;
61    }
62    if (mbedtls_test_driver_cipher_hooks.forced_status_encrypt != PSA_SUCCESS) {
63        return mbedtls_test_driver_cipher_hooks.forced_status_encrypt;
64    }
65
66#if defined(MBEDTLS_TEST_LIBTESTDRIVER1) && \
67    defined(LIBTESTDRIVER1_MBEDTLS_PSA_BUILTIN_CIPHER)
68    return libtestdriver1_mbedtls_psa_cipher_encrypt(
69        (const libtestdriver1_psa_key_attributes_t *) attributes,
70        key_buffer, key_buffer_size,
71        alg, iv, iv_length, input, input_length,
72        output, output_size, output_length);
73#elif defined(MBEDTLS_PSA_BUILTIN_CIPHER)
74    return mbedtls_psa_cipher_encrypt(
75        attributes, key_buffer, key_buffer_size,
76        alg, iv, iv_length, input, input_length,
77        output, output_size, output_length);
78#endif
79
80    return PSA_ERROR_NOT_SUPPORTED;
81}
82
83psa_status_t mbedtls_test_transparent_cipher_decrypt(
84    const psa_key_attributes_t *attributes,
85    const uint8_t *key_buffer,
86    size_t key_buffer_size,
87    psa_algorithm_t alg,
88    const uint8_t *input,
89    size_t input_length,
90    uint8_t *output,
91    size_t output_size,
92    size_t *output_length)
93{
94    mbedtls_test_driver_cipher_hooks.hits++;
95
96    if (mbedtls_test_driver_cipher_hooks.forced_output != NULL) {
97        if (output_size < mbedtls_test_driver_cipher_hooks.forced_output_length) {
98            return PSA_ERROR_BUFFER_TOO_SMALL;
99        }
100
101        memcpy(output,
102               mbedtls_test_driver_cipher_hooks.forced_output,
103               mbedtls_test_driver_cipher_hooks.forced_output_length);
104        *output_length = mbedtls_test_driver_cipher_hooks.forced_output_length;
105
106        return mbedtls_test_driver_cipher_hooks.forced_status;
107    }
108
109    if (mbedtls_test_driver_cipher_hooks.forced_status != PSA_SUCCESS) {
110        return mbedtls_test_driver_cipher_hooks.forced_status;
111    }
112
113#if defined(MBEDTLS_TEST_LIBTESTDRIVER1) && \
114    defined(LIBTESTDRIVER1_MBEDTLS_PSA_BUILTIN_CIPHER)
115    return libtestdriver1_mbedtls_psa_cipher_decrypt(
116        (const libtestdriver1_psa_key_attributes_t *) attributes,
117        key_buffer, key_buffer_size,
118        alg, input, input_length,
119        output, output_size, output_length);
120#elif defined(MBEDTLS_PSA_BUILTIN_CIPHER)
121    return mbedtls_psa_cipher_decrypt(
122        attributes, key_buffer, key_buffer_size,
123        alg, input, input_length,
124        output, output_size, output_length);
125#endif
126
127    return PSA_ERROR_NOT_SUPPORTED;
128}
129
130psa_status_t mbedtls_test_transparent_cipher_encrypt_setup(
131    mbedtls_transparent_test_driver_cipher_operation_t *operation,
132    const psa_key_attributes_t *attributes,
133    const uint8_t *key, size_t key_length,
134    psa_algorithm_t alg)
135{
136    mbedtls_test_driver_cipher_hooks.hits++;
137
138    /* Wiping the entire struct here, instead of member-by-member. This is
139     * useful for the test suite, since it gives a chance of catching memory
140     * corruption errors should the core not have allocated (enough) memory for
141     * our context struct. */
142    memset(operation, 0, sizeof(*operation));
143
144    if (mbedtls_test_driver_cipher_hooks.forced_status != PSA_SUCCESS) {
145        return mbedtls_test_driver_cipher_hooks.forced_status;
146    }
147
148#if defined(MBEDTLS_TEST_LIBTESTDRIVER1) && \
149    defined(LIBTESTDRIVER1_MBEDTLS_PSA_BUILTIN_CIPHER)
150    return libtestdriver1_mbedtls_psa_cipher_encrypt_setup(
151        operation,
152        (const libtestdriver1_psa_key_attributes_t *) attributes,
153        key, key_length, alg);
154#elif defined(MBEDTLS_PSA_BUILTIN_CIPHER)
155    return mbedtls_psa_cipher_encrypt_setup(
156        operation, attributes, key, key_length, alg);
157#endif
158
159    return PSA_ERROR_NOT_SUPPORTED;
160}
161
162psa_status_t mbedtls_test_transparent_cipher_decrypt_setup(
163    mbedtls_transparent_test_driver_cipher_operation_t *operation,
164    const psa_key_attributes_t *attributes,
165    const uint8_t *key, size_t key_length,
166    psa_algorithm_t alg)
167{
168    mbedtls_test_driver_cipher_hooks.hits++;
169
170    if (mbedtls_test_driver_cipher_hooks.forced_status != PSA_SUCCESS) {
171        return mbedtls_test_driver_cipher_hooks.forced_status;
172    }
173
174#if defined(MBEDTLS_TEST_LIBTESTDRIVER1) && \
175    defined(LIBTESTDRIVER1_MBEDTLS_PSA_BUILTIN_CIPHER)
176    return libtestdriver1_mbedtls_psa_cipher_decrypt_setup(
177        operation,
178        (const libtestdriver1_psa_key_attributes_t *) attributes,
179        key, key_length, alg);
180#elif defined(MBEDTLS_PSA_BUILTIN_CIPHER)
181    return mbedtls_psa_cipher_decrypt_setup(
182        operation, attributes, key, key_length, alg);
183#endif
184
185    return PSA_ERROR_NOT_SUPPORTED;
186}
187
188psa_status_t mbedtls_test_transparent_cipher_abort(
189    mbedtls_transparent_test_driver_cipher_operation_t *operation)
190{
191    mbedtls_test_driver_cipher_hooks.hits++;
192
193#if defined(MBEDTLS_TEST_LIBTESTDRIVER1) && \
194    defined(LIBTESTDRIVER1_MBEDTLS_PSA_BUILTIN_CIPHER)
195    libtestdriver1_mbedtls_psa_cipher_abort(operation);
196#elif defined(MBEDTLS_PSA_BUILTIN_CIPHER)
197    mbedtls_psa_cipher_abort(operation);
198#endif
199
200    /* Wiping the entire struct here, instead of member-by-member. This is
201     * useful for the test suite, since it gives a chance of catching memory
202     * corruption errors should the core not have allocated (enough) memory for
203     * our context struct. */
204    memset(operation, 0, sizeof(*operation));
205
206    return mbedtls_test_driver_cipher_hooks.forced_status;
207}
208
209psa_status_t mbedtls_test_transparent_cipher_set_iv(
210    mbedtls_transparent_test_driver_cipher_operation_t *operation,
211    const uint8_t *iv,
212    size_t iv_length)
213{
214    mbedtls_test_driver_cipher_hooks.hits++;
215    mbedtls_test_driver_cipher_hooks.hits_set_iv++;
216
217    if (mbedtls_test_driver_cipher_hooks.forced_status != PSA_SUCCESS) {
218        return mbedtls_test_driver_cipher_hooks.forced_status;
219    }
220    if (mbedtls_test_driver_cipher_hooks.forced_status_set_iv != PSA_SUCCESS) {
221        return mbedtls_test_driver_cipher_hooks.forced_status_set_iv;
222    }
223
224#if defined(MBEDTLS_TEST_LIBTESTDRIVER1) && \
225    defined(LIBTESTDRIVER1_MBEDTLS_PSA_BUILTIN_CIPHER)
226    return libtestdriver1_mbedtls_psa_cipher_set_iv(
227        operation, iv, iv_length);
228#elif defined(MBEDTLS_PSA_BUILTIN_CIPHER)
229    return mbedtls_psa_cipher_set_iv(operation, iv, iv_length);
230#endif
231
232    return PSA_ERROR_NOT_SUPPORTED;
233}
234
235psa_status_t mbedtls_test_transparent_cipher_update(
236    mbedtls_transparent_test_driver_cipher_operation_t *operation,
237    const uint8_t *input,
238    size_t input_length,
239    uint8_t *output,
240    size_t output_size,
241    size_t *output_length)
242{
243    mbedtls_test_driver_cipher_hooks.hits++;
244
245    if (mbedtls_test_driver_cipher_hooks.forced_output != NULL) {
246        if (output_size < mbedtls_test_driver_cipher_hooks.forced_output_length) {
247            return PSA_ERROR_BUFFER_TOO_SMALL;
248        }
249
250        memcpy(output,
251               mbedtls_test_driver_cipher_hooks.forced_output,
252               mbedtls_test_driver_cipher_hooks.forced_output_length);
253        *output_length = mbedtls_test_driver_cipher_hooks.forced_output_length;
254
255        return mbedtls_test_driver_cipher_hooks.forced_status;
256    }
257
258    if (mbedtls_test_driver_cipher_hooks.forced_status != PSA_SUCCESS) {
259        return mbedtls_test_driver_cipher_hooks.forced_status;
260    }
261
262#if defined(MBEDTLS_TEST_LIBTESTDRIVER1) && \
263    defined(LIBTESTDRIVER1_MBEDTLS_PSA_BUILTIN_CIPHER)
264    return libtestdriver1_mbedtls_psa_cipher_update(
265        operation, input, input_length,
266        output, output_size, output_length);
267#elif defined(MBEDTLS_PSA_BUILTIN_CIPHER)
268    return mbedtls_psa_cipher_update(
269        operation, input, input_length,
270        output, output_size, output_length);
271#endif
272
273    return PSA_ERROR_NOT_SUPPORTED;
274}
275
276psa_status_t mbedtls_test_transparent_cipher_finish(
277    mbedtls_transparent_test_driver_cipher_operation_t *operation,
278    uint8_t *output,
279    size_t output_size,
280    size_t *output_length)
281{
282    mbedtls_test_driver_cipher_hooks.hits++;
283
284    if (mbedtls_test_driver_cipher_hooks.forced_output != NULL) {
285        if (output_size < mbedtls_test_driver_cipher_hooks.forced_output_length) {
286            return PSA_ERROR_BUFFER_TOO_SMALL;
287        }
288
289        memcpy(output,
290               mbedtls_test_driver_cipher_hooks.forced_output,
291               mbedtls_test_driver_cipher_hooks.forced_output_length);
292        *output_length = mbedtls_test_driver_cipher_hooks.forced_output_length;
293
294        return mbedtls_test_driver_cipher_hooks.forced_status;
295    }
296
297    if (mbedtls_test_driver_cipher_hooks.forced_status != PSA_SUCCESS) {
298        return mbedtls_test_driver_cipher_hooks.forced_status;
299    }
300
301#if defined(MBEDTLS_TEST_LIBTESTDRIVER1) && \
302    defined(LIBTESTDRIVER1_MBEDTLS_PSA_BUILTIN_CIPHER)
303    return libtestdriver1_mbedtls_psa_cipher_finish(
304        operation, output, output_size, output_length);
305#elif defined(MBEDTLS_PSA_BUILTIN_CIPHER)
306    return mbedtls_psa_cipher_finish(
307        operation, output, output_size, output_length);
308#endif
309
310    return PSA_ERROR_NOT_SUPPORTED;
311}
312
313/*
314 * opaque versions, to do
315 */
316psa_status_t mbedtls_test_opaque_cipher_encrypt(
317    const psa_key_attributes_t *attributes,
318    const uint8_t *key, size_t key_length,
319    psa_algorithm_t alg,
320    const uint8_t *iv, size_t iv_length,
321    const uint8_t *input, size_t input_length,
322    uint8_t *output, size_t output_size, size_t *output_length)
323{
324    (void) attributes;
325    (void) key;
326    (void) key_length;
327    (void) alg;
328    (void) iv;
329    (void) iv_length;
330    (void) input;
331    (void) input_length;
332    (void) output;
333    (void) output_size;
334    (void) output_length;
335    return PSA_ERROR_NOT_SUPPORTED;
336}
337
338psa_status_t mbedtls_test_opaque_cipher_decrypt(
339    const psa_key_attributes_t *attributes,
340    const uint8_t *key, size_t key_length,
341    psa_algorithm_t alg,
342    const uint8_t *input, size_t input_length,
343    uint8_t *output, size_t output_size, size_t *output_length)
344{
345    (void) attributes;
346    (void) key;
347    (void) key_length;
348    (void) alg;
349    (void) input;
350    (void) input_length;
351    (void) output;
352    (void) output_size;
353    (void) output_length;
354    return PSA_ERROR_NOT_SUPPORTED;
355}
356
357psa_status_t mbedtls_test_opaque_cipher_encrypt_setup(
358    mbedtls_opaque_test_driver_cipher_operation_t *operation,
359    const psa_key_attributes_t *attributes,
360    const uint8_t *key, size_t key_length,
361    psa_algorithm_t alg)
362{
363    (void) operation;
364    (void) attributes;
365    (void) key;
366    (void) key_length;
367    (void) alg;
368    return PSA_ERROR_NOT_SUPPORTED;
369}
370
371psa_status_t mbedtls_test_opaque_cipher_decrypt_setup(
372    mbedtls_opaque_test_driver_cipher_operation_t *operation,
373    const psa_key_attributes_t *attributes,
374    const uint8_t *key, size_t key_length,
375    psa_algorithm_t alg)
376{
377    (void) operation;
378    (void) attributes;
379    (void) key;
380    (void) key_length;
381    (void) alg;
382    return PSA_ERROR_NOT_SUPPORTED;
383}
384
385psa_status_t mbedtls_test_opaque_cipher_abort(
386    mbedtls_opaque_test_driver_cipher_operation_t *operation)
387{
388    (void) operation;
389    return PSA_ERROR_NOT_SUPPORTED;
390}
391
392psa_status_t mbedtls_test_opaque_cipher_set_iv(
393    mbedtls_opaque_test_driver_cipher_operation_t *operation,
394    const uint8_t *iv,
395    size_t iv_length)
396{
397    (void) operation;
398    (void) iv;
399    (void) iv_length;
400    return PSA_ERROR_NOT_SUPPORTED;
401}
402
403psa_status_t mbedtls_test_opaque_cipher_update(
404    mbedtls_opaque_test_driver_cipher_operation_t *operation,
405    const uint8_t *input,
406    size_t input_length,
407    uint8_t *output,
408    size_t output_size,
409    size_t *output_length)
410{
411    (void) operation;
412    (void) input;
413    (void) input_length;
414    (void) output;
415    (void) output_size;
416    (void) output_length;
417    return PSA_ERROR_NOT_SUPPORTED;
418}
419
420psa_status_t mbedtls_test_opaque_cipher_finish(
421    mbedtls_opaque_test_driver_cipher_operation_t *operation,
422    uint8_t *output,
423    size_t output_size,
424    size_t *output_length)
425{
426    (void) operation;
427    (void) output;
428    (void) output_size;
429    (void) output_length;
430    return PSA_ERROR_NOT_SUPPORTED;
431}
432#endif /* PSA_CRYPTO_DRIVER_TEST */
433