Line data Source code
1 : /**
2 : * \file cipher_wrap.c
3 : *
4 : * \brief Generic cipher wrapper for Mbed TLS
5 : *
6 : * \author Adriaan de Jong <dejong@fox-it.com>
7 : *
8 : * Copyright The Mbed TLS Contributors
9 : * SPDX-License-Identifier: Apache-2.0 OR GPL-2.0-or-later
10 : */
11 :
12 : #include "common.h"
13 :
14 : #if defined(MBEDTLS_CIPHER_C)
15 :
16 : #include "cipher_wrap.h"
17 : #include "mbedtls/error.h"
18 :
19 : #if defined(MBEDTLS_CHACHAPOLY_C)
20 : #include "mbedtls/chachapoly.h"
21 : #endif
22 :
23 : #if defined(MBEDTLS_AES_C)
24 : #include "mbedtls/aes.h"
25 : #endif
26 :
27 : #if defined(MBEDTLS_CAMELLIA_C)
28 : #include "mbedtls/camellia.h"
29 : #endif
30 :
31 : #if defined(MBEDTLS_ARIA_C)
32 : #include "mbedtls/aria.h"
33 : #endif
34 :
35 : #if defined(MBEDTLS_DES_C)
36 : #include "mbedtls/des.h"
37 : #endif
38 :
39 : #if defined(MBEDTLS_CHACHA20_C)
40 : #include "mbedtls/chacha20.h"
41 : #endif
42 :
43 : #if defined(MBEDTLS_GCM_C)
44 : #include "mbedtls/gcm.h"
45 : #endif
46 :
47 : #if defined(MBEDTLS_CCM_C)
48 : #include "mbedtls/ccm.h"
49 : #endif
50 :
51 : #if defined(MBEDTLS_NIST_KW_C)
52 : #include "mbedtls/nist_kw.h"
53 : #endif
54 :
55 : #if defined(MBEDTLS_CIPHER_NULL_CIPHER)
56 : #include <string.h>
57 : #endif
58 :
59 : #include "mbedtls/platform.h"
60 :
61 : enum mbedtls_cipher_base_index {
62 : #if defined(MBEDTLS_AES_C)
63 : MBEDTLS_CIPHER_BASE_INDEX_AES,
64 : #endif
65 : #if defined(MBEDTLS_ARIA_C)
66 : MBEDTLS_CIPHER_BASE_INDEX_ARIA,
67 : #endif
68 : #if defined(MBEDTLS_CAMELLIA_C)
69 : MBEDTLS_CIPHER_BASE_INDEX_CAMELLIA,
70 : #endif
71 : #if defined(MBEDTLS_CIPHER_HAVE_CCM_AES_VIA_LEGACY_OR_USE_PSA)
72 : MBEDTLS_CIPHER_BASE_INDEX_CCM_AES,
73 : #endif
74 : #if defined(MBEDTLS_CCM_C) && defined(MBEDTLS_ARIA_C)
75 : MBEDTLS_CIPHER_BASE_INDEX_CCM_ARIA,
76 : #endif
77 : #if defined(MBEDTLS_CCM_C) && defined(MBEDTLS_CAMELLIA_C)
78 : MBEDTLS_CIPHER_BASE_INDEX_CCM_CAMELLIA,
79 : #endif
80 : #if defined(MBEDTLS_CHACHA20_C)
81 : MBEDTLS_CIPHER_BASE_INDEX_CHACHA20_BASE,
82 : #endif
83 : #if defined(MBEDTLS_CHACHAPOLY_C)
84 : MBEDTLS_CIPHER_BASE_INDEX_CHACHAPOLY_BASE,
85 : #endif
86 : #if defined(MBEDTLS_DES_C)
87 : MBEDTLS_CIPHER_BASE_INDEX_DES_EDE3,
88 : #endif
89 : #if defined(MBEDTLS_DES_C)
90 : MBEDTLS_CIPHER_BASE_INDEX_DES_EDE,
91 : #endif
92 : #if defined(MBEDTLS_DES_C)
93 : MBEDTLS_CIPHER_BASE_INDEX_DES,
94 : #endif
95 : #if defined(MBEDTLS_CIPHER_HAVE_GCM_AES_VIA_LEGACY_OR_USE_PSA)
96 : MBEDTLS_CIPHER_BASE_INDEX_GCM_AES,
97 : #endif
98 : #if defined(MBEDTLS_GCM_C) && defined(MBEDTLS_ARIA_C)
99 : MBEDTLS_CIPHER_BASE_INDEX_GCM_ARIA,
100 : #endif
101 : #if defined(MBEDTLS_GCM_C) && defined(MBEDTLS_CAMELLIA_C)
102 : MBEDTLS_CIPHER_BASE_INDEX_GCM_CAMELLIA,
103 : #endif
104 : #if defined(MBEDTLS_NIST_KW_C)
105 : MBEDTLS_CIPHER_BASE_INDEX_KW_AES,
106 : #endif
107 : #if defined(MBEDTLS_CIPHER_NULL_CIPHER)
108 : MBEDTLS_CIPHER_BASE_INDEX_NULL_BASE,
109 : #endif
110 : #if defined(MBEDTLS_CIPHER_MODE_XTS) && defined(MBEDTLS_AES_C)
111 : MBEDTLS_CIPHER_BASE_INDEX_XTS_AES,
112 : #endif
113 : /* Prevent compile failure due to empty enum */
114 : MBEDTLS_CIPHER_BASE_PREVENT_EMPTY_ENUM
115 : };
116 :
117 : #if defined(MBEDTLS_GCM_C) && \
118 : (defined(MBEDTLS_CIPHER_HAVE_GCM_AES_VIA_LEGACY_OR_USE_PSA) || \
119 : defined(MBEDTLS_ARIA_C) || defined(MBEDTLS_CAMELLIA_C))
120 : /* shared by all GCM ciphers */
121 0 : static void *gcm_ctx_alloc(void)
122 : {
123 0 : void *ctx = mbedtls_calloc(1, sizeof(mbedtls_gcm_context));
124 :
125 0 : if (ctx != NULL) {
126 0 : mbedtls_gcm_init((mbedtls_gcm_context *) ctx);
127 : }
128 :
129 0 : return ctx;
130 : }
131 :
132 0 : static void gcm_ctx_free(void *ctx)
133 : {
134 0 : mbedtls_gcm_free(ctx);
135 0 : mbedtls_free(ctx);
136 0 : }
137 : #endif /* MBEDTLS_GCM_C */
138 :
139 : #if defined(MBEDTLS_CCM_C) && \
140 : (defined(MBEDTLS_CIPHER_HAVE_CCM_AES_VIA_LEGACY_OR_USE_PSA) || \
141 : defined(MBEDTLS_ARIA_C) || defined(MBEDTLS_CAMELLIA_C))
142 : /* shared by all CCM ciphers */
143 : static void *ccm_ctx_alloc(void)
144 : {
145 : void *ctx = mbedtls_calloc(1, sizeof(mbedtls_ccm_context));
146 :
147 : if (ctx != NULL) {
148 : mbedtls_ccm_init((mbedtls_ccm_context *) ctx);
149 : }
150 :
151 : return ctx;
152 : }
153 :
154 : static void ccm_ctx_free(void *ctx)
155 : {
156 : mbedtls_ccm_free(ctx);
157 : mbedtls_free(ctx);
158 : }
159 : #endif /* MBEDTLS_CCM_C */
160 :
161 : #if defined(MBEDTLS_AES_C)
162 :
163 3620 : static int aes_crypt_ecb_wrap(void *ctx, mbedtls_operation_t operation,
164 : const unsigned char *input, unsigned char *output)
165 : {
166 3620 : return mbedtls_aes_crypt_ecb((mbedtls_aes_context *) ctx, operation, input, output);
167 : }
168 :
169 : #if defined(MBEDTLS_CIPHER_MODE_CBC)
170 : static int aes_crypt_cbc_wrap(void *ctx, mbedtls_operation_t operation, size_t length,
171 : unsigned char *iv, const unsigned char *input, unsigned char *output)
172 : {
173 : return mbedtls_aes_crypt_cbc((mbedtls_aes_context *) ctx, operation, length, iv, input,
174 : output);
175 : }
176 : #endif /* MBEDTLS_CIPHER_MODE_CBC */
177 :
178 : #if defined(MBEDTLS_CIPHER_MODE_CFB)
179 : static int aes_crypt_cfb128_wrap(void *ctx, mbedtls_operation_t operation,
180 : size_t length, size_t *iv_off, unsigned char *iv,
181 : const unsigned char *input, unsigned char *output)
182 : {
183 : return mbedtls_aes_crypt_cfb128((mbedtls_aes_context *) ctx, operation, length, iv_off, iv,
184 : input, output);
185 : }
186 : #endif /* MBEDTLS_CIPHER_MODE_CFB */
187 :
188 : #if defined(MBEDTLS_CIPHER_MODE_OFB)
189 : static int aes_crypt_ofb_wrap(void *ctx, size_t length, size_t *iv_off,
190 : unsigned char *iv, const unsigned char *input, unsigned char *output)
191 : {
192 : return mbedtls_aes_crypt_ofb((mbedtls_aes_context *) ctx, length, iv_off,
193 : iv, input, output);
194 : }
195 : #endif /* MBEDTLS_CIPHER_MODE_OFB */
196 :
197 : #if defined(MBEDTLS_CIPHER_MODE_CTR)
198 : static int aes_crypt_ctr_wrap(void *ctx, size_t length, size_t *nc_off,
199 : unsigned char *nonce_counter, unsigned char *stream_block,
200 : const unsigned char *input, unsigned char *output)
201 : {
202 : return mbedtls_aes_crypt_ctr((mbedtls_aes_context *) ctx, length, nc_off, nonce_counter,
203 : stream_block, input, output);
204 : }
205 : #endif /* MBEDTLS_CIPHER_MODE_CTR */
206 :
207 : #if defined(MBEDTLS_CIPHER_MODE_XTS)
208 : static int aes_crypt_xts_wrap(void *ctx, mbedtls_operation_t operation,
209 : size_t length,
210 : const unsigned char data_unit[16],
211 : const unsigned char *input,
212 : unsigned char *output)
213 : {
214 : mbedtls_aes_xts_context *xts_ctx = ctx;
215 : int mode;
216 :
217 : switch (operation) {
218 : case MBEDTLS_ENCRYPT:
219 : mode = MBEDTLS_AES_ENCRYPT;
220 : break;
221 : case MBEDTLS_DECRYPT:
222 : mode = MBEDTLS_AES_DECRYPT;
223 : break;
224 : default:
225 : return MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA;
226 : }
227 :
228 : return mbedtls_aes_crypt_xts(xts_ctx, mode, length,
229 : data_unit, input, output);
230 : }
231 : #endif /* MBEDTLS_CIPHER_MODE_XTS */
232 :
233 : #if !defined(MBEDTLS_BLOCK_CIPHER_NO_DECRYPT)
234 0 : static int aes_setkey_dec_wrap(void *ctx, const unsigned char *key,
235 : unsigned int key_bitlen)
236 : {
237 0 : return mbedtls_aes_setkey_dec((mbedtls_aes_context *) ctx, key, key_bitlen);
238 : }
239 : #endif
240 :
241 795 : static int aes_setkey_enc_wrap(void *ctx, const unsigned char *key,
242 : unsigned int key_bitlen)
243 : {
244 795 : return mbedtls_aes_setkey_enc((mbedtls_aes_context *) ctx, key, key_bitlen);
245 : }
246 :
247 795 : static void *aes_ctx_alloc(void)
248 : {
249 795 : mbedtls_aes_context *aes = mbedtls_calloc(1, sizeof(mbedtls_aes_context));
250 :
251 795 : if (aes == NULL) {
252 0 : return NULL;
253 : }
254 :
255 795 : mbedtls_aes_init(aes);
256 :
257 795 : return aes;
258 : }
259 :
260 795 : static void aes_ctx_free(void *ctx)
261 : {
262 795 : mbedtls_aes_free((mbedtls_aes_context *) ctx);
263 795 : mbedtls_free(ctx);
264 795 : }
265 :
266 : static const mbedtls_cipher_base_t aes_info = {
267 : MBEDTLS_CIPHER_ID_AES,
268 : aes_crypt_ecb_wrap,
269 : #if defined(MBEDTLS_CIPHER_MODE_CBC)
270 : aes_crypt_cbc_wrap,
271 : #endif
272 : #if defined(MBEDTLS_CIPHER_MODE_CFB)
273 : aes_crypt_cfb128_wrap,
274 : #endif
275 : #if defined(MBEDTLS_CIPHER_MODE_OFB)
276 : aes_crypt_ofb_wrap,
277 : #endif
278 : #if defined(MBEDTLS_CIPHER_MODE_CTR)
279 : aes_crypt_ctr_wrap,
280 : #endif
281 : #if defined(MBEDTLS_CIPHER_MODE_XTS)
282 : NULL,
283 : #endif
284 : #if defined(MBEDTLS_CIPHER_MODE_STREAM)
285 : NULL,
286 : #endif
287 : aes_setkey_enc_wrap,
288 : #if !defined(MBEDTLS_BLOCK_CIPHER_NO_DECRYPT)
289 : aes_setkey_dec_wrap,
290 : #endif
291 : aes_ctx_alloc,
292 : aes_ctx_free
293 : };
294 :
295 : static const mbedtls_cipher_info_t aes_128_ecb_info = {
296 : "AES-128-ECB",
297 : 16,
298 : 0 >> MBEDTLS_IV_SIZE_SHIFT,
299 : 128 >> MBEDTLS_KEY_BITLEN_SHIFT,
300 : MBEDTLS_MODE_ECB,
301 : MBEDTLS_CIPHER_AES_128_ECB,
302 : 0,
303 : MBEDTLS_CIPHER_BASE_INDEX_AES
304 : };
305 :
306 : #if !defined(MBEDTLS_AES_ONLY_128_BIT_KEY_LENGTH)
307 : static const mbedtls_cipher_info_t aes_192_ecb_info = {
308 : "AES-192-ECB",
309 : 16,
310 : 0 >> MBEDTLS_IV_SIZE_SHIFT,
311 : 192 >> MBEDTLS_KEY_BITLEN_SHIFT,
312 : MBEDTLS_MODE_ECB,
313 : MBEDTLS_CIPHER_AES_192_ECB,
314 : 0,
315 : MBEDTLS_CIPHER_BASE_INDEX_AES
316 : };
317 :
318 : static const mbedtls_cipher_info_t aes_256_ecb_info = {
319 : "AES-256-ECB",
320 : 16,
321 : 0 >> MBEDTLS_IV_SIZE_SHIFT,
322 : 256 >> MBEDTLS_KEY_BITLEN_SHIFT,
323 : MBEDTLS_MODE_ECB,
324 : MBEDTLS_CIPHER_AES_256_ECB,
325 : 0,
326 : MBEDTLS_CIPHER_BASE_INDEX_AES
327 : };
328 : #endif
329 :
330 : #if defined(MBEDTLS_CIPHER_MODE_CBC)
331 : static const mbedtls_cipher_info_t aes_128_cbc_info = {
332 : "AES-128-CBC",
333 : 16,
334 : 16 >> MBEDTLS_IV_SIZE_SHIFT,
335 : 128 >> MBEDTLS_KEY_BITLEN_SHIFT,
336 : MBEDTLS_MODE_CBC,
337 : MBEDTLS_CIPHER_AES_128_CBC,
338 : 0,
339 : MBEDTLS_CIPHER_BASE_INDEX_AES
340 : };
341 :
342 : #if !defined(MBEDTLS_AES_ONLY_128_BIT_KEY_LENGTH)
343 : static const mbedtls_cipher_info_t aes_192_cbc_info = {
344 : "AES-192-CBC",
345 : 16,
346 : 16 >> MBEDTLS_IV_SIZE_SHIFT,
347 : 192 >> MBEDTLS_KEY_BITLEN_SHIFT,
348 : MBEDTLS_MODE_CBC,
349 : MBEDTLS_CIPHER_AES_192_CBC,
350 : 0,
351 : MBEDTLS_CIPHER_BASE_INDEX_AES
352 : };
353 :
354 : static const mbedtls_cipher_info_t aes_256_cbc_info = {
355 : "AES-256-CBC",
356 : 16,
357 : 16 >> MBEDTLS_IV_SIZE_SHIFT,
358 : 256 >> MBEDTLS_KEY_BITLEN_SHIFT,
359 : MBEDTLS_MODE_CBC,
360 : MBEDTLS_CIPHER_AES_256_CBC,
361 : 0,
362 : MBEDTLS_CIPHER_BASE_INDEX_AES
363 : };
364 : #endif
365 : #endif /* MBEDTLS_CIPHER_MODE_CBC */
366 :
367 : #if defined(MBEDTLS_CIPHER_MODE_CFB)
368 : static const mbedtls_cipher_info_t aes_128_cfb128_info = {
369 : "AES-128-CFB128",
370 : 16,
371 : 16 >> MBEDTLS_IV_SIZE_SHIFT,
372 : 128 >> MBEDTLS_KEY_BITLEN_SHIFT,
373 : MBEDTLS_MODE_CFB,
374 : MBEDTLS_CIPHER_AES_128_CFB128,
375 : 0,
376 : MBEDTLS_CIPHER_BASE_INDEX_AES
377 : };
378 :
379 : #if !defined(MBEDTLS_AES_ONLY_128_BIT_KEY_LENGTH)
380 : static const mbedtls_cipher_info_t aes_192_cfb128_info = {
381 : "AES-192-CFB128",
382 : 16,
383 : 16 >> MBEDTLS_IV_SIZE_SHIFT,
384 : 192 >> MBEDTLS_KEY_BITLEN_SHIFT,
385 : MBEDTLS_MODE_CFB,
386 : MBEDTLS_CIPHER_AES_192_CFB128,
387 : 0,
388 : MBEDTLS_CIPHER_BASE_INDEX_AES
389 : };
390 :
391 : static const mbedtls_cipher_info_t aes_256_cfb128_info = {
392 : "AES-256-CFB128",
393 : 16,
394 : 16 >> MBEDTLS_IV_SIZE_SHIFT,
395 : 256 >> MBEDTLS_KEY_BITLEN_SHIFT,
396 : MBEDTLS_MODE_CFB,
397 : MBEDTLS_CIPHER_AES_256_CFB128,
398 : 0,
399 : MBEDTLS_CIPHER_BASE_INDEX_AES
400 : };
401 : #endif
402 : #endif /* MBEDTLS_CIPHER_MODE_CFB */
403 :
404 : #if defined(MBEDTLS_CIPHER_MODE_OFB)
405 : static const mbedtls_cipher_info_t aes_128_ofb_info = {
406 : "AES-128-OFB",
407 : 16,
408 : 16 >> MBEDTLS_IV_SIZE_SHIFT,
409 : 128 >> MBEDTLS_KEY_BITLEN_SHIFT,
410 : MBEDTLS_MODE_OFB,
411 : MBEDTLS_CIPHER_AES_128_OFB,
412 : 0,
413 : MBEDTLS_CIPHER_BASE_INDEX_AES
414 : };
415 :
416 : #if !defined(MBEDTLS_AES_ONLY_128_BIT_KEY_LENGTH)
417 : static const mbedtls_cipher_info_t aes_192_ofb_info = {
418 : "AES-192-OFB",
419 : 16,
420 : 16 >> MBEDTLS_IV_SIZE_SHIFT,
421 : 192 >> MBEDTLS_KEY_BITLEN_SHIFT,
422 : MBEDTLS_MODE_OFB,
423 : MBEDTLS_CIPHER_AES_192_OFB,
424 : 0,
425 : MBEDTLS_CIPHER_BASE_INDEX_AES
426 : };
427 :
428 : static const mbedtls_cipher_info_t aes_256_ofb_info = {
429 : "AES-256-OFB",
430 : 16,
431 : 16 >> MBEDTLS_IV_SIZE_SHIFT,
432 : 256 >> MBEDTLS_KEY_BITLEN_SHIFT,
433 : MBEDTLS_MODE_OFB,
434 : MBEDTLS_CIPHER_AES_256_OFB,
435 : 0,
436 : MBEDTLS_CIPHER_BASE_INDEX_AES
437 : };
438 : #endif
439 : #endif /* MBEDTLS_CIPHER_MODE_OFB */
440 :
441 : #if defined(MBEDTLS_CIPHER_MODE_CTR)
442 : static const mbedtls_cipher_info_t aes_128_ctr_info = {
443 : "AES-128-CTR",
444 : 16,
445 : 16 >> MBEDTLS_IV_SIZE_SHIFT,
446 : 128 >> MBEDTLS_KEY_BITLEN_SHIFT,
447 : MBEDTLS_MODE_CTR,
448 : MBEDTLS_CIPHER_AES_128_CTR,
449 : 0,
450 : MBEDTLS_CIPHER_BASE_INDEX_AES
451 : };
452 :
453 : #if !defined(MBEDTLS_AES_ONLY_128_BIT_KEY_LENGTH)
454 : static const mbedtls_cipher_info_t aes_192_ctr_info = {
455 : "AES-192-CTR",
456 : 16,
457 : 16 >> MBEDTLS_IV_SIZE_SHIFT,
458 : 192 >> MBEDTLS_KEY_BITLEN_SHIFT,
459 : MBEDTLS_MODE_CTR,
460 : MBEDTLS_CIPHER_AES_192_CTR,
461 : 0,
462 : MBEDTLS_CIPHER_BASE_INDEX_AES
463 : };
464 :
465 : static const mbedtls_cipher_info_t aes_256_ctr_info = {
466 : "AES-256-CTR",
467 : 16,
468 : 16 >> MBEDTLS_IV_SIZE_SHIFT,
469 : 256 >> MBEDTLS_KEY_BITLEN_SHIFT,
470 : MBEDTLS_MODE_CTR,
471 : MBEDTLS_CIPHER_AES_256_CTR,
472 : 0,
473 : MBEDTLS_CIPHER_BASE_INDEX_AES
474 : };
475 : #endif
476 : #endif /* MBEDTLS_CIPHER_MODE_CTR */
477 :
478 : #if defined(MBEDTLS_CIPHER_MODE_XTS)
479 : static int xts_aes_setkey_enc_wrap(void *ctx, const unsigned char *key,
480 : unsigned int key_bitlen)
481 : {
482 : mbedtls_aes_xts_context *xts_ctx = ctx;
483 : return mbedtls_aes_xts_setkey_enc(xts_ctx, key, key_bitlen);
484 : }
485 :
486 : static int xts_aes_setkey_dec_wrap(void *ctx, const unsigned char *key,
487 : unsigned int key_bitlen)
488 : {
489 : mbedtls_aes_xts_context *xts_ctx = ctx;
490 : return mbedtls_aes_xts_setkey_dec(xts_ctx, key, key_bitlen);
491 : }
492 :
493 : static void *xts_aes_ctx_alloc(void)
494 : {
495 : mbedtls_aes_xts_context *xts_ctx = mbedtls_calloc(1, sizeof(*xts_ctx));
496 :
497 : if (xts_ctx != NULL) {
498 : mbedtls_aes_xts_init(xts_ctx);
499 : }
500 :
501 : return xts_ctx;
502 : }
503 :
504 : static void xts_aes_ctx_free(void *ctx)
505 : {
506 : mbedtls_aes_xts_context *xts_ctx = ctx;
507 :
508 : if (xts_ctx == NULL) {
509 : return;
510 : }
511 :
512 : mbedtls_aes_xts_free(xts_ctx);
513 : mbedtls_free(xts_ctx);
514 : }
515 :
516 : static const mbedtls_cipher_base_t xts_aes_info = {
517 : MBEDTLS_CIPHER_ID_AES,
518 : NULL,
519 : #if defined(MBEDTLS_CIPHER_MODE_CBC)
520 : NULL,
521 : #endif
522 : #if defined(MBEDTLS_CIPHER_MODE_CFB)
523 : NULL,
524 : #endif
525 : #if defined(MBEDTLS_CIPHER_MODE_OFB)
526 : NULL,
527 : #endif
528 : #if defined(MBEDTLS_CIPHER_MODE_CTR)
529 : NULL,
530 : #endif
531 : #if defined(MBEDTLS_CIPHER_MODE_XTS)
532 : aes_crypt_xts_wrap,
533 : #endif
534 : #if defined(MBEDTLS_CIPHER_MODE_STREAM)
535 : NULL,
536 : #endif
537 : xts_aes_setkey_enc_wrap,
538 : xts_aes_setkey_dec_wrap,
539 : xts_aes_ctx_alloc,
540 : xts_aes_ctx_free
541 : };
542 :
543 : static const mbedtls_cipher_info_t aes_128_xts_info = {
544 : "AES-128-XTS",
545 : 16,
546 : 16 >> MBEDTLS_IV_SIZE_SHIFT,
547 : 256 >> MBEDTLS_KEY_BITLEN_SHIFT,
548 : MBEDTLS_MODE_XTS,
549 : MBEDTLS_CIPHER_AES_128_XTS,
550 : 0,
551 : MBEDTLS_CIPHER_BASE_INDEX_XTS_AES
552 : };
553 :
554 : #if !defined(MBEDTLS_AES_ONLY_128_BIT_KEY_LENGTH)
555 : static const mbedtls_cipher_info_t aes_256_xts_info = {
556 : "AES-256-XTS",
557 : 16,
558 : 16 >> MBEDTLS_IV_SIZE_SHIFT,
559 : 512 >> MBEDTLS_KEY_BITLEN_SHIFT,
560 : MBEDTLS_MODE_XTS,
561 : MBEDTLS_CIPHER_AES_256_XTS,
562 : 0,
563 : MBEDTLS_CIPHER_BASE_INDEX_XTS_AES
564 : };
565 : #endif
566 : #endif /* MBEDTLS_CIPHER_MODE_XTS */
567 : #endif /* MBEDTLS_AES_C */
568 :
569 : #if defined(MBEDTLS_GCM_C) && defined(MBEDTLS_CCM_GCM_CAN_AES)
570 0 : static int gcm_aes_setkey_wrap(void *ctx, const unsigned char *key,
571 : unsigned int key_bitlen)
572 : {
573 0 : return mbedtls_gcm_setkey((mbedtls_gcm_context *) ctx, MBEDTLS_CIPHER_ID_AES,
574 : key, key_bitlen);
575 : }
576 : #endif /* MBEDTLS_GCM_C && MBEDTLS_CCM_GCM_CAN_AES */
577 :
578 : #if defined(MBEDTLS_CIPHER_HAVE_GCM_AES_VIA_LEGACY_OR_USE_PSA)
579 : static const mbedtls_cipher_base_t gcm_aes_info = {
580 : MBEDTLS_CIPHER_ID_AES,
581 : NULL,
582 : #if defined(MBEDTLS_CIPHER_MODE_CBC)
583 : NULL,
584 : #endif
585 : #if defined(MBEDTLS_CIPHER_MODE_CFB)
586 : NULL,
587 : #endif
588 : #if defined(MBEDTLS_CIPHER_MODE_OFB)
589 : NULL,
590 : #endif
591 : #if defined(MBEDTLS_CIPHER_MODE_CTR)
592 : NULL,
593 : #endif
594 : #if defined(MBEDTLS_CIPHER_MODE_XTS)
595 : NULL,
596 : #endif
597 : #if defined(MBEDTLS_CIPHER_MODE_STREAM)
598 : NULL,
599 : #endif
600 : #if defined(MBEDTLS_GCM_C)
601 : gcm_aes_setkey_wrap,
602 : #if !defined(MBEDTLS_BLOCK_CIPHER_NO_DECRYPT)
603 : gcm_aes_setkey_wrap,
604 : #endif
605 : gcm_ctx_alloc,
606 : gcm_ctx_free,
607 : #else
608 : NULL,
609 : NULL,
610 : NULL,
611 : NULL,
612 : #endif /* MBEDTLS_GCM_C */
613 : };
614 : #endif /* MBEDTLS_CIPHER_HAVE_GCM_AES_VIA_LEGACY_OR_USE_PSA */
615 :
616 : #if defined(MBEDTLS_CIPHER_HAVE_GCM_AES_VIA_LEGACY_OR_USE_PSA)
617 : static const mbedtls_cipher_info_t aes_128_gcm_info = {
618 : "AES-128-GCM",
619 : 16,
620 : 12 >> MBEDTLS_IV_SIZE_SHIFT,
621 : 128 >> MBEDTLS_KEY_BITLEN_SHIFT,
622 : MBEDTLS_MODE_GCM,
623 : MBEDTLS_CIPHER_AES_128_GCM,
624 : MBEDTLS_CIPHER_VARIABLE_IV_LEN,
625 : MBEDTLS_CIPHER_BASE_INDEX_GCM_AES
626 : };
627 :
628 : #if !defined(MBEDTLS_AES_ONLY_128_BIT_KEY_LENGTH)
629 : static const mbedtls_cipher_info_t aes_192_gcm_info = {
630 : "AES-192-GCM",
631 : 16,
632 : 12 >> MBEDTLS_IV_SIZE_SHIFT,
633 : 192 >> MBEDTLS_KEY_BITLEN_SHIFT,
634 : MBEDTLS_MODE_GCM,
635 : MBEDTLS_CIPHER_AES_192_GCM,
636 : MBEDTLS_CIPHER_VARIABLE_IV_LEN,
637 : MBEDTLS_CIPHER_BASE_INDEX_GCM_AES
638 : };
639 :
640 : static const mbedtls_cipher_info_t aes_256_gcm_info = {
641 : "AES-256-GCM",
642 : 16,
643 : 12 >> MBEDTLS_IV_SIZE_SHIFT,
644 : 256 >> MBEDTLS_KEY_BITLEN_SHIFT,
645 : MBEDTLS_MODE_GCM,
646 : MBEDTLS_CIPHER_AES_256_GCM,
647 : MBEDTLS_CIPHER_VARIABLE_IV_LEN,
648 : MBEDTLS_CIPHER_BASE_INDEX_GCM_AES
649 : };
650 : #endif
651 : #endif /* MBEDTLS_CIPHER_HAVE_GCM_AES_VIA_LEGACY_OR_USE_PSA */
652 :
653 : #if defined(MBEDTLS_CCM_C) && defined(MBEDTLS_CCM_GCM_CAN_AES)
654 : static int ccm_aes_setkey_wrap(void *ctx, const unsigned char *key,
655 : unsigned int key_bitlen)
656 : {
657 : return mbedtls_ccm_setkey((mbedtls_ccm_context *) ctx, MBEDTLS_CIPHER_ID_AES,
658 : key, key_bitlen);
659 : }
660 : #endif /* MBEDTLS_CCM_C && MBEDTLS_CCM_GCM_CAN_AES */
661 :
662 : #if defined(MBEDTLS_CIPHER_HAVE_CCM_AES_VIA_LEGACY_OR_USE_PSA)
663 : static const mbedtls_cipher_base_t ccm_aes_info = {
664 : MBEDTLS_CIPHER_ID_AES,
665 : NULL,
666 : #if defined(MBEDTLS_CIPHER_MODE_CBC)
667 : NULL,
668 : #endif
669 : #if defined(MBEDTLS_CIPHER_MODE_CFB)
670 : NULL,
671 : #endif
672 : #if defined(MBEDTLS_CIPHER_MODE_OFB)
673 : NULL,
674 : #endif
675 : #if defined(MBEDTLS_CIPHER_MODE_CTR)
676 : NULL,
677 : #endif
678 : #if defined(MBEDTLS_CIPHER_MODE_XTS)
679 : NULL,
680 : #endif
681 : #if defined(MBEDTLS_CIPHER_MODE_STREAM)
682 : NULL,
683 : #endif
684 : #if defined(MBEDTLS_CCM_C)
685 : ccm_aes_setkey_wrap,
686 : #if !defined(MBEDTLS_BLOCK_CIPHER_NO_DECRYPT)
687 : ccm_aes_setkey_wrap,
688 : #endif
689 : ccm_ctx_alloc,
690 : ccm_ctx_free,
691 : #else
692 : NULL,
693 : NULL,
694 : NULL,
695 : NULL,
696 : #endif
697 : };
698 : #endif /* MBEDTLS_CIPHER_HAVE_CCM_AES_VIA_LEGACY_OR_USE_PSA */
699 :
700 : #if defined(MBEDTLS_CIPHER_HAVE_CCM_AES_VIA_LEGACY_OR_USE_PSA)
701 : static const mbedtls_cipher_info_t aes_128_ccm_info = {
702 : "AES-128-CCM",
703 : 16,
704 : 12 >> MBEDTLS_IV_SIZE_SHIFT,
705 : 128 >> MBEDTLS_KEY_BITLEN_SHIFT,
706 : MBEDTLS_MODE_CCM,
707 : MBEDTLS_CIPHER_AES_128_CCM,
708 : MBEDTLS_CIPHER_VARIABLE_IV_LEN,
709 : MBEDTLS_CIPHER_BASE_INDEX_CCM_AES
710 : };
711 :
712 : #if !defined(MBEDTLS_AES_ONLY_128_BIT_KEY_LENGTH)
713 : static const mbedtls_cipher_info_t aes_192_ccm_info = {
714 : "AES-192-CCM",
715 : 16,
716 : 12 >> MBEDTLS_IV_SIZE_SHIFT,
717 : 192 >> MBEDTLS_KEY_BITLEN_SHIFT,
718 : MBEDTLS_MODE_CCM,
719 : MBEDTLS_CIPHER_AES_192_CCM,
720 : MBEDTLS_CIPHER_VARIABLE_IV_LEN,
721 : MBEDTLS_CIPHER_BASE_INDEX_CCM_AES
722 : };
723 :
724 : static const mbedtls_cipher_info_t aes_256_ccm_info = {
725 : "AES-256-CCM",
726 : 16,
727 : 12 >> MBEDTLS_IV_SIZE_SHIFT,
728 : 256 >> MBEDTLS_KEY_BITLEN_SHIFT,
729 : MBEDTLS_MODE_CCM,
730 : MBEDTLS_CIPHER_AES_256_CCM,
731 : MBEDTLS_CIPHER_VARIABLE_IV_LEN,
732 : MBEDTLS_CIPHER_BASE_INDEX_CCM_AES
733 : };
734 : #endif
735 : #endif /* MBEDTLS_CIPHER_HAVE_CCM_AES_VIA_LEGACY_OR_USE_PSA */
736 :
737 : #if defined(MBEDTLS_CIPHER_HAVE_CCM_STAR_NO_TAG_AES_VIA_LEGACY_OR_USE_PSA)
738 : static const mbedtls_cipher_info_t aes_128_ccm_star_no_tag_info = {
739 : "AES-128-CCM*-NO-TAG",
740 : 16,
741 : 12 >> MBEDTLS_IV_SIZE_SHIFT,
742 : 128 >> MBEDTLS_KEY_BITLEN_SHIFT,
743 : MBEDTLS_MODE_CCM_STAR_NO_TAG,
744 : MBEDTLS_CIPHER_AES_128_CCM_STAR_NO_TAG,
745 : MBEDTLS_CIPHER_VARIABLE_IV_LEN,
746 : MBEDTLS_CIPHER_BASE_INDEX_CCM_AES
747 : };
748 :
749 : #if !defined(MBEDTLS_AES_ONLY_128_BIT_KEY_LENGTH)
750 : static const mbedtls_cipher_info_t aes_192_ccm_star_no_tag_info = {
751 : "AES-192-CCM*-NO-TAG",
752 : 16,
753 : 12 >> MBEDTLS_IV_SIZE_SHIFT,
754 : 192 >> MBEDTLS_KEY_BITLEN_SHIFT,
755 : MBEDTLS_MODE_CCM_STAR_NO_TAG,
756 : MBEDTLS_CIPHER_AES_192_CCM_STAR_NO_TAG,
757 : MBEDTLS_CIPHER_VARIABLE_IV_LEN,
758 : MBEDTLS_CIPHER_BASE_INDEX_CCM_AES
759 : };
760 :
761 : static const mbedtls_cipher_info_t aes_256_ccm_star_no_tag_info = {
762 : "AES-256-CCM*-NO-TAG",
763 : 16,
764 : 12 >> MBEDTLS_IV_SIZE_SHIFT,
765 : 256 >> MBEDTLS_KEY_BITLEN_SHIFT,
766 : MBEDTLS_MODE_CCM_STAR_NO_TAG,
767 : MBEDTLS_CIPHER_AES_256_CCM_STAR_NO_TAG,
768 : MBEDTLS_CIPHER_VARIABLE_IV_LEN,
769 : MBEDTLS_CIPHER_BASE_INDEX_CCM_AES
770 : };
771 : #endif
772 : #endif /* MBEDTLS_CIPHER_HAVE_CCM_STAR_NO_TAG_AES_VIA_LEGACY_OR_USE_PSA */
773 :
774 :
775 : #if defined(MBEDTLS_CAMELLIA_C)
776 :
777 : static int camellia_crypt_ecb_wrap(void *ctx, mbedtls_operation_t operation,
778 : const unsigned char *input, unsigned char *output)
779 : {
780 : return mbedtls_camellia_crypt_ecb((mbedtls_camellia_context *) ctx, operation, input,
781 : output);
782 : }
783 :
784 : #if defined(MBEDTLS_CIPHER_MODE_CBC)
785 : static int camellia_crypt_cbc_wrap(void *ctx, mbedtls_operation_t operation,
786 : size_t length, unsigned char *iv,
787 : const unsigned char *input, unsigned char *output)
788 : {
789 : return mbedtls_camellia_crypt_cbc((mbedtls_camellia_context *) ctx, operation, length, iv,
790 : input, output);
791 : }
792 : #endif /* MBEDTLS_CIPHER_MODE_CBC */
793 :
794 : #if defined(MBEDTLS_CIPHER_MODE_CFB)
795 : static int camellia_crypt_cfb128_wrap(void *ctx, mbedtls_operation_t operation,
796 : size_t length, size_t *iv_off, unsigned char *iv,
797 : const unsigned char *input, unsigned char *output)
798 : {
799 : return mbedtls_camellia_crypt_cfb128((mbedtls_camellia_context *) ctx, operation, length,
800 : iv_off, iv, input, output);
801 : }
802 : #endif /* MBEDTLS_CIPHER_MODE_CFB */
803 :
804 : #if defined(MBEDTLS_CIPHER_MODE_CTR)
805 : static int camellia_crypt_ctr_wrap(void *ctx, size_t length, size_t *nc_off,
806 : unsigned char *nonce_counter, unsigned char *stream_block,
807 : const unsigned char *input, unsigned char *output)
808 : {
809 : return mbedtls_camellia_crypt_ctr((mbedtls_camellia_context *) ctx, length, nc_off,
810 : nonce_counter, stream_block, input, output);
811 : }
812 : #endif /* MBEDTLS_CIPHER_MODE_CTR */
813 :
814 : #if !defined(MBEDTLS_BLOCK_CIPHER_NO_DECRYPT)
815 : static int camellia_setkey_dec_wrap(void *ctx, const unsigned char *key,
816 : unsigned int key_bitlen)
817 : {
818 : return mbedtls_camellia_setkey_dec((mbedtls_camellia_context *) ctx, key, key_bitlen);
819 : }
820 : #endif
821 :
822 : static int camellia_setkey_enc_wrap(void *ctx, const unsigned char *key,
823 : unsigned int key_bitlen)
824 : {
825 : return mbedtls_camellia_setkey_enc((mbedtls_camellia_context *) ctx, key, key_bitlen);
826 : }
827 :
828 : static void *camellia_ctx_alloc(void)
829 : {
830 : mbedtls_camellia_context *ctx;
831 : ctx = mbedtls_calloc(1, sizeof(mbedtls_camellia_context));
832 :
833 : if (ctx == NULL) {
834 : return NULL;
835 : }
836 :
837 : mbedtls_camellia_init(ctx);
838 :
839 : return ctx;
840 : }
841 :
842 : static void camellia_ctx_free(void *ctx)
843 : {
844 : mbedtls_camellia_free((mbedtls_camellia_context *) ctx);
845 : mbedtls_free(ctx);
846 : }
847 :
848 : static const mbedtls_cipher_base_t camellia_info = {
849 : MBEDTLS_CIPHER_ID_CAMELLIA,
850 : camellia_crypt_ecb_wrap,
851 : #if defined(MBEDTLS_CIPHER_MODE_CBC)
852 : camellia_crypt_cbc_wrap,
853 : #endif
854 : #if defined(MBEDTLS_CIPHER_MODE_CFB)
855 : camellia_crypt_cfb128_wrap,
856 : #endif
857 : #if defined(MBEDTLS_CIPHER_MODE_OFB)
858 : NULL,
859 : #endif
860 : #if defined(MBEDTLS_CIPHER_MODE_CTR)
861 : camellia_crypt_ctr_wrap,
862 : #endif
863 : #if defined(MBEDTLS_CIPHER_MODE_XTS)
864 : NULL,
865 : #endif
866 : #if defined(MBEDTLS_CIPHER_MODE_STREAM)
867 : NULL,
868 : #endif
869 : camellia_setkey_enc_wrap,
870 : #if !defined(MBEDTLS_BLOCK_CIPHER_NO_DECRYPT)
871 : camellia_setkey_dec_wrap,
872 : #endif
873 : camellia_ctx_alloc,
874 : camellia_ctx_free
875 : };
876 :
877 : static const mbedtls_cipher_info_t camellia_128_ecb_info = {
878 : "CAMELLIA-128-ECB",
879 : 16,
880 : 0 >> MBEDTLS_IV_SIZE_SHIFT,
881 : 128 >> MBEDTLS_KEY_BITLEN_SHIFT,
882 : MBEDTLS_MODE_ECB,
883 : MBEDTLS_CIPHER_CAMELLIA_128_ECB,
884 : 0,
885 : MBEDTLS_CIPHER_BASE_INDEX_CAMELLIA
886 : };
887 :
888 : static const mbedtls_cipher_info_t camellia_192_ecb_info = {
889 : "CAMELLIA-192-ECB",
890 : 16,
891 : 0 >> MBEDTLS_IV_SIZE_SHIFT,
892 : 192 >> MBEDTLS_KEY_BITLEN_SHIFT,
893 : MBEDTLS_MODE_ECB,
894 : MBEDTLS_CIPHER_CAMELLIA_192_ECB,
895 : 0,
896 : MBEDTLS_CIPHER_BASE_INDEX_CAMELLIA
897 : };
898 :
899 : static const mbedtls_cipher_info_t camellia_256_ecb_info = {
900 : "CAMELLIA-256-ECB",
901 : 16,
902 : 0 >> MBEDTLS_IV_SIZE_SHIFT,
903 : 256 >> MBEDTLS_KEY_BITLEN_SHIFT,
904 : MBEDTLS_MODE_ECB,
905 : MBEDTLS_CIPHER_CAMELLIA_256_ECB,
906 : 0,
907 : MBEDTLS_CIPHER_BASE_INDEX_CAMELLIA
908 : };
909 :
910 : #if defined(MBEDTLS_CIPHER_MODE_CBC)
911 : static const mbedtls_cipher_info_t camellia_128_cbc_info = {
912 : "CAMELLIA-128-CBC",
913 : 16,
914 : 16 >> MBEDTLS_IV_SIZE_SHIFT,
915 : 128 >> MBEDTLS_KEY_BITLEN_SHIFT,
916 : MBEDTLS_MODE_CBC,
917 : MBEDTLS_CIPHER_CAMELLIA_128_CBC,
918 : 0,
919 : MBEDTLS_CIPHER_BASE_INDEX_CAMELLIA
920 : };
921 :
922 : static const mbedtls_cipher_info_t camellia_192_cbc_info = {
923 : "CAMELLIA-192-CBC",
924 : 16,
925 : 16 >> MBEDTLS_IV_SIZE_SHIFT,
926 : 192 >> MBEDTLS_KEY_BITLEN_SHIFT,
927 : MBEDTLS_MODE_CBC,
928 : MBEDTLS_CIPHER_CAMELLIA_192_CBC,
929 : 0,
930 : MBEDTLS_CIPHER_BASE_INDEX_CAMELLIA
931 : };
932 :
933 : static const mbedtls_cipher_info_t camellia_256_cbc_info = {
934 : "CAMELLIA-256-CBC",
935 : 16,
936 : 16 >> MBEDTLS_IV_SIZE_SHIFT,
937 : 256 >> MBEDTLS_KEY_BITLEN_SHIFT,
938 : MBEDTLS_MODE_CBC,
939 : MBEDTLS_CIPHER_CAMELLIA_256_CBC,
940 : 0,
941 : MBEDTLS_CIPHER_BASE_INDEX_CAMELLIA
942 : };
943 : #endif /* MBEDTLS_CIPHER_MODE_CBC */
944 :
945 : #if defined(MBEDTLS_CIPHER_MODE_CFB)
946 : static const mbedtls_cipher_info_t camellia_128_cfb128_info = {
947 : "CAMELLIA-128-CFB128",
948 : 16,
949 : 16 >> MBEDTLS_IV_SIZE_SHIFT,
950 : 128 >> MBEDTLS_KEY_BITLEN_SHIFT,
951 : MBEDTLS_MODE_CFB,
952 : MBEDTLS_CIPHER_CAMELLIA_128_CFB128,
953 : 0,
954 : MBEDTLS_CIPHER_BASE_INDEX_CAMELLIA
955 : };
956 :
957 : static const mbedtls_cipher_info_t camellia_192_cfb128_info = {
958 : "CAMELLIA-192-CFB128",
959 : 16,
960 : 16 >> MBEDTLS_IV_SIZE_SHIFT,
961 : 192 >> MBEDTLS_KEY_BITLEN_SHIFT,
962 : MBEDTLS_MODE_CFB,
963 : MBEDTLS_CIPHER_CAMELLIA_192_CFB128,
964 : 0,
965 : MBEDTLS_CIPHER_BASE_INDEX_CAMELLIA
966 : };
967 :
968 : static const mbedtls_cipher_info_t camellia_256_cfb128_info = {
969 : "CAMELLIA-256-CFB128",
970 : 16,
971 : 16 >> MBEDTLS_IV_SIZE_SHIFT,
972 : 256 >> MBEDTLS_KEY_BITLEN_SHIFT,
973 : MBEDTLS_MODE_CFB,
974 : MBEDTLS_CIPHER_CAMELLIA_256_CFB128,
975 : 0,
976 : MBEDTLS_CIPHER_BASE_INDEX_CAMELLIA
977 : };
978 : #endif /* MBEDTLS_CIPHER_MODE_CFB */
979 :
980 : #if defined(MBEDTLS_CIPHER_MODE_CTR)
981 : static const mbedtls_cipher_info_t camellia_128_ctr_info = {
982 : "CAMELLIA-128-CTR",
983 : 16,
984 : 16 >> MBEDTLS_IV_SIZE_SHIFT,
985 : 128 >> MBEDTLS_KEY_BITLEN_SHIFT,
986 : MBEDTLS_MODE_CTR,
987 : MBEDTLS_CIPHER_CAMELLIA_128_CTR,
988 : 0,
989 : MBEDTLS_CIPHER_BASE_INDEX_CAMELLIA
990 : };
991 :
992 : static const mbedtls_cipher_info_t camellia_192_ctr_info = {
993 : "CAMELLIA-192-CTR",
994 : 16,
995 : 16 >> MBEDTLS_IV_SIZE_SHIFT,
996 : 192 >> MBEDTLS_KEY_BITLEN_SHIFT,
997 : MBEDTLS_MODE_CTR,
998 : MBEDTLS_CIPHER_CAMELLIA_192_CTR,
999 : 0,
1000 : MBEDTLS_CIPHER_BASE_INDEX_CAMELLIA
1001 : };
1002 :
1003 : static const mbedtls_cipher_info_t camellia_256_ctr_info = {
1004 : "CAMELLIA-256-CTR",
1005 : 16,
1006 : 16 >> MBEDTLS_IV_SIZE_SHIFT,
1007 : 256 >> MBEDTLS_KEY_BITLEN_SHIFT,
1008 : MBEDTLS_MODE_CTR,
1009 : MBEDTLS_CIPHER_CAMELLIA_256_CTR,
1010 : 0,
1011 : MBEDTLS_CIPHER_BASE_INDEX_CAMELLIA
1012 : };
1013 : #endif /* MBEDTLS_CIPHER_MODE_CTR */
1014 :
1015 : #if defined(MBEDTLS_GCM_C)
1016 : static int gcm_camellia_setkey_wrap(void *ctx, const unsigned char *key,
1017 : unsigned int key_bitlen)
1018 : {
1019 : return mbedtls_gcm_setkey((mbedtls_gcm_context *) ctx, MBEDTLS_CIPHER_ID_CAMELLIA,
1020 : key, key_bitlen);
1021 : }
1022 :
1023 : static const mbedtls_cipher_base_t gcm_camellia_info = {
1024 : MBEDTLS_CIPHER_ID_CAMELLIA,
1025 : NULL,
1026 : #if defined(MBEDTLS_CIPHER_MODE_CBC)
1027 : NULL,
1028 : #endif
1029 : #if defined(MBEDTLS_CIPHER_MODE_CFB)
1030 : NULL,
1031 : #endif
1032 : #if defined(MBEDTLS_CIPHER_MODE_OFB)
1033 : NULL,
1034 : #endif
1035 : #if defined(MBEDTLS_CIPHER_MODE_CTR)
1036 : NULL,
1037 : #endif
1038 : #if defined(MBEDTLS_CIPHER_MODE_XTS)
1039 : NULL,
1040 : #endif
1041 : #if defined(MBEDTLS_CIPHER_MODE_STREAM)
1042 : NULL,
1043 : #endif
1044 : gcm_camellia_setkey_wrap,
1045 : #if !defined(MBEDTLS_BLOCK_CIPHER_NO_DECRYPT)
1046 : gcm_camellia_setkey_wrap,
1047 : #endif
1048 : gcm_ctx_alloc,
1049 : gcm_ctx_free,
1050 : };
1051 :
1052 : static const mbedtls_cipher_info_t camellia_128_gcm_info = {
1053 : "CAMELLIA-128-GCM",
1054 : 16,
1055 : 12 >> MBEDTLS_IV_SIZE_SHIFT,
1056 : 128 >> MBEDTLS_KEY_BITLEN_SHIFT,
1057 : MBEDTLS_MODE_GCM,
1058 : MBEDTLS_CIPHER_CAMELLIA_128_GCM,
1059 : MBEDTLS_CIPHER_VARIABLE_IV_LEN,
1060 : MBEDTLS_CIPHER_BASE_INDEX_GCM_CAMELLIA
1061 : };
1062 :
1063 : static const mbedtls_cipher_info_t camellia_192_gcm_info = {
1064 : "CAMELLIA-192-GCM",
1065 : 16,
1066 : 12 >> MBEDTLS_IV_SIZE_SHIFT,
1067 : 192 >> MBEDTLS_KEY_BITLEN_SHIFT,
1068 : MBEDTLS_MODE_GCM,
1069 : MBEDTLS_CIPHER_CAMELLIA_192_GCM,
1070 : MBEDTLS_CIPHER_VARIABLE_IV_LEN,
1071 : MBEDTLS_CIPHER_BASE_INDEX_GCM_CAMELLIA
1072 : };
1073 :
1074 : static const mbedtls_cipher_info_t camellia_256_gcm_info = {
1075 : "CAMELLIA-256-GCM",
1076 : 16,
1077 : 12 >> MBEDTLS_IV_SIZE_SHIFT,
1078 : 256 >> MBEDTLS_KEY_BITLEN_SHIFT,
1079 : MBEDTLS_MODE_GCM,
1080 : MBEDTLS_CIPHER_CAMELLIA_256_GCM,
1081 : MBEDTLS_CIPHER_VARIABLE_IV_LEN,
1082 : MBEDTLS_CIPHER_BASE_INDEX_GCM_CAMELLIA
1083 : };
1084 : #endif /* MBEDTLS_GCM_C */
1085 :
1086 : #if defined(MBEDTLS_CCM_C)
1087 : static int ccm_camellia_setkey_wrap(void *ctx, const unsigned char *key,
1088 : unsigned int key_bitlen)
1089 : {
1090 : return mbedtls_ccm_setkey((mbedtls_ccm_context *) ctx, MBEDTLS_CIPHER_ID_CAMELLIA,
1091 : key, key_bitlen);
1092 : }
1093 :
1094 : static const mbedtls_cipher_base_t ccm_camellia_info = {
1095 : MBEDTLS_CIPHER_ID_CAMELLIA,
1096 : NULL,
1097 : #if defined(MBEDTLS_CIPHER_MODE_CBC)
1098 : NULL,
1099 : #endif
1100 : #if defined(MBEDTLS_CIPHER_MODE_CFB)
1101 : NULL,
1102 : #endif
1103 : #if defined(MBEDTLS_CIPHER_MODE_OFB)
1104 : NULL,
1105 : #endif
1106 : #if defined(MBEDTLS_CIPHER_MODE_CTR)
1107 : NULL,
1108 : #endif
1109 : #if defined(MBEDTLS_CIPHER_MODE_XTS)
1110 : NULL,
1111 : #endif
1112 : #if defined(MBEDTLS_CIPHER_MODE_STREAM)
1113 : NULL,
1114 : #endif
1115 : ccm_camellia_setkey_wrap,
1116 : #if !defined(MBEDTLS_BLOCK_CIPHER_NO_DECRYPT)
1117 : ccm_camellia_setkey_wrap,
1118 : #endif
1119 : ccm_ctx_alloc,
1120 : ccm_ctx_free,
1121 : };
1122 :
1123 : static const mbedtls_cipher_info_t camellia_128_ccm_info = {
1124 : "CAMELLIA-128-CCM",
1125 : 16,
1126 : 12 >> MBEDTLS_IV_SIZE_SHIFT,
1127 : 128 >> MBEDTLS_KEY_BITLEN_SHIFT,
1128 : MBEDTLS_MODE_CCM,
1129 : MBEDTLS_CIPHER_CAMELLIA_128_CCM,
1130 : MBEDTLS_CIPHER_VARIABLE_IV_LEN,
1131 : MBEDTLS_CIPHER_BASE_INDEX_CCM_CAMELLIA
1132 : };
1133 :
1134 : static const mbedtls_cipher_info_t camellia_192_ccm_info = {
1135 : "CAMELLIA-192-CCM",
1136 : 16,
1137 : 12 >> MBEDTLS_IV_SIZE_SHIFT,
1138 : 192 >> MBEDTLS_KEY_BITLEN_SHIFT,
1139 : MBEDTLS_MODE_CCM,
1140 : MBEDTLS_CIPHER_CAMELLIA_192_CCM,
1141 : MBEDTLS_CIPHER_VARIABLE_IV_LEN,
1142 : MBEDTLS_CIPHER_BASE_INDEX_CCM_CAMELLIA
1143 : };
1144 :
1145 : static const mbedtls_cipher_info_t camellia_256_ccm_info = {
1146 : "CAMELLIA-256-CCM",
1147 : 16,
1148 : 12 >> MBEDTLS_IV_SIZE_SHIFT,
1149 : 256 >> MBEDTLS_KEY_BITLEN_SHIFT,
1150 : MBEDTLS_MODE_CCM,
1151 : MBEDTLS_CIPHER_CAMELLIA_256_CCM,
1152 : MBEDTLS_CIPHER_VARIABLE_IV_LEN,
1153 : MBEDTLS_CIPHER_BASE_INDEX_CCM_CAMELLIA
1154 : };
1155 :
1156 : static const mbedtls_cipher_info_t camellia_128_ccm_star_no_tag_info = {
1157 : "CAMELLIA-128-CCM*-NO-TAG",
1158 : 16,
1159 : 12 >> MBEDTLS_IV_SIZE_SHIFT,
1160 : 128 >> MBEDTLS_KEY_BITLEN_SHIFT,
1161 : MBEDTLS_MODE_CCM_STAR_NO_TAG,
1162 : MBEDTLS_CIPHER_CAMELLIA_128_CCM_STAR_NO_TAG,
1163 : MBEDTLS_CIPHER_VARIABLE_IV_LEN,
1164 : MBEDTLS_CIPHER_BASE_INDEX_CCM_CAMELLIA
1165 : };
1166 :
1167 : static const mbedtls_cipher_info_t camellia_192_ccm_star_no_tag_info = {
1168 : "CAMELLIA-192-CCM*-NO-TAG",
1169 : 16,
1170 : 12 >> MBEDTLS_IV_SIZE_SHIFT,
1171 : 192 >> MBEDTLS_KEY_BITLEN_SHIFT,
1172 : MBEDTLS_MODE_CCM_STAR_NO_TAG,
1173 : MBEDTLS_CIPHER_CAMELLIA_192_CCM_STAR_NO_TAG,
1174 : MBEDTLS_CIPHER_VARIABLE_IV_LEN,
1175 : MBEDTLS_CIPHER_BASE_INDEX_CCM_CAMELLIA
1176 : };
1177 :
1178 : static const mbedtls_cipher_info_t camellia_256_ccm_star_no_tag_info = {
1179 : "CAMELLIA-256-CCM*-NO-TAG",
1180 : 16,
1181 : 12 >> MBEDTLS_IV_SIZE_SHIFT,
1182 : 256 >> MBEDTLS_KEY_BITLEN_SHIFT,
1183 : MBEDTLS_MODE_CCM_STAR_NO_TAG,
1184 : MBEDTLS_CIPHER_CAMELLIA_256_CCM_STAR_NO_TAG,
1185 : MBEDTLS_CIPHER_VARIABLE_IV_LEN,
1186 : MBEDTLS_CIPHER_BASE_INDEX_CCM_CAMELLIA
1187 : };
1188 : #endif /* MBEDTLS_CCM_C */
1189 :
1190 : #endif /* MBEDTLS_CAMELLIA_C */
1191 :
1192 : #if defined(MBEDTLS_ARIA_C)
1193 :
1194 : static int aria_crypt_ecb_wrap(void *ctx, mbedtls_operation_t operation,
1195 : const unsigned char *input, unsigned char *output)
1196 : {
1197 : (void) operation;
1198 : return mbedtls_aria_crypt_ecb((mbedtls_aria_context *) ctx, input,
1199 : output);
1200 : }
1201 :
1202 : #if defined(MBEDTLS_CIPHER_MODE_CBC)
1203 : static int aria_crypt_cbc_wrap(void *ctx, mbedtls_operation_t operation,
1204 : size_t length, unsigned char *iv,
1205 : const unsigned char *input, unsigned char *output)
1206 : {
1207 : return mbedtls_aria_crypt_cbc((mbedtls_aria_context *) ctx, operation, length, iv,
1208 : input, output);
1209 : }
1210 : #endif /* MBEDTLS_CIPHER_MODE_CBC */
1211 :
1212 : #if defined(MBEDTLS_CIPHER_MODE_CFB)
1213 : static int aria_crypt_cfb128_wrap(void *ctx, mbedtls_operation_t operation,
1214 : size_t length, size_t *iv_off, unsigned char *iv,
1215 : const unsigned char *input, unsigned char *output)
1216 : {
1217 : return mbedtls_aria_crypt_cfb128((mbedtls_aria_context *) ctx, operation, length,
1218 : iv_off, iv, input, output);
1219 : }
1220 : #endif /* MBEDTLS_CIPHER_MODE_CFB */
1221 :
1222 : #if defined(MBEDTLS_CIPHER_MODE_CTR)
1223 : static int aria_crypt_ctr_wrap(void *ctx, size_t length, size_t *nc_off,
1224 : unsigned char *nonce_counter, unsigned char *stream_block,
1225 : const unsigned char *input, unsigned char *output)
1226 : {
1227 : return mbedtls_aria_crypt_ctr((mbedtls_aria_context *) ctx, length, nc_off,
1228 : nonce_counter, stream_block, input, output);
1229 : }
1230 : #endif /* MBEDTLS_CIPHER_MODE_CTR */
1231 :
1232 : #if !defined(MBEDTLS_BLOCK_CIPHER_NO_DECRYPT)
1233 : static int aria_setkey_dec_wrap(void *ctx, const unsigned char *key,
1234 : unsigned int key_bitlen)
1235 : {
1236 : return mbedtls_aria_setkey_dec((mbedtls_aria_context *) ctx, key, key_bitlen);
1237 : }
1238 : #endif
1239 :
1240 : static int aria_setkey_enc_wrap(void *ctx, const unsigned char *key,
1241 : unsigned int key_bitlen)
1242 : {
1243 : return mbedtls_aria_setkey_enc((mbedtls_aria_context *) ctx, key, key_bitlen);
1244 : }
1245 :
1246 : static void *aria_ctx_alloc(void)
1247 : {
1248 : mbedtls_aria_context *ctx;
1249 : ctx = mbedtls_calloc(1, sizeof(mbedtls_aria_context));
1250 :
1251 : if (ctx == NULL) {
1252 : return NULL;
1253 : }
1254 :
1255 : mbedtls_aria_init(ctx);
1256 :
1257 : return ctx;
1258 : }
1259 :
1260 : static void aria_ctx_free(void *ctx)
1261 : {
1262 : mbedtls_aria_free((mbedtls_aria_context *) ctx);
1263 : mbedtls_free(ctx);
1264 : }
1265 :
1266 : static const mbedtls_cipher_base_t aria_info = {
1267 : MBEDTLS_CIPHER_ID_ARIA,
1268 : aria_crypt_ecb_wrap,
1269 : #if defined(MBEDTLS_CIPHER_MODE_CBC)
1270 : aria_crypt_cbc_wrap,
1271 : #endif
1272 : #if defined(MBEDTLS_CIPHER_MODE_CFB)
1273 : aria_crypt_cfb128_wrap,
1274 : #endif
1275 : #if defined(MBEDTLS_CIPHER_MODE_OFB)
1276 : NULL,
1277 : #endif
1278 : #if defined(MBEDTLS_CIPHER_MODE_CTR)
1279 : aria_crypt_ctr_wrap,
1280 : #endif
1281 : #if defined(MBEDTLS_CIPHER_MODE_XTS)
1282 : NULL,
1283 : #endif
1284 : #if defined(MBEDTLS_CIPHER_MODE_STREAM)
1285 : NULL,
1286 : #endif
1287 : aria_setkey_enc_wrap,
1288 : #if !defined(MBEDTLS_BLOCK_CIPHER_NO_DECRYPT)
1289 : aria_setkey_dec_wrap,
1290 : #endif
1291 : aria_ctx_alloc,
1292 : aria_ctx_free
1293 : };
1294 :
1295 : static const mbedtls_cipher_info_t aria_128_ecb_info = {
1296 : "ARIA-128-ECB",
1297 : 16,
1298 : 0 >> MBEDTLS_IV_SIZE_SHIFT,
1299 : 128 >> MBEDTLS_KEY_BITLEN_SHIFT,
1300 : MBEDTLS_MODE_ECB,
1301 : MBEDTLS_CIPHER_ARIA_128_ECB,
1302 : 0,
1303 : MBEDTLS_CIPHER_BASE_INDEX_ARIA
1304 : };
1305 :
1306 : static const mbedtls_cipher_info_t aria_192_ecb_info = {
1307 : "ARIA-192-ECB",
1308 : 16,
1309 : 0 >> MBEDTLS_IV_SIZE_SHIFT,
1310 : 192 >> MBEDTLS_KEY_BITLEN_SHIFT,
1311 : MBEDTLS_MODE_ECB,
1312 : MBEDTLS_CIPHER_ARIA_192_ECB,
1313 : 0,
1314 : MBEDTLS_CIPHER_BASE_INDEX_ARIA
1315 : };
1316 :
1317 : static const mbedtls_cipher_info_t aria_256_ecb_info = {
1318 : "ARIA-256-ECB",
1319 : 16,
1320 : 0 >> MBEDTLS_IV_SIZE_SHIFT,
1321 : 256 >> MBEDTLS_KEY_BITLEN_SHIFT,
1322 : MBEDTLS_MODE_ECB,
1323 : MBEDTLS_CIPHER_ARIA_256_ECB,
1324 : 0,
1325 : MBEDTLS_CIPHER_BASE_INDEX_ARIA
1326 : };
1327 :
1328 : #if defined(MBEDTLS_CIPHER_MODE_CBC)
1329 : static const mbedtls_cipher_info_t aria_128_cbc_info = {
1330 : "ARIA-128-CBC",
1331 : 16,
1332 : 16 >> MBEDTLS_IV_SIZE_SHIFT,
1333 : 128 >> MBEDTLS_KEY_BITLEN_SHIFT,
1334 : MBEDTLS_MODE_CBC,
1335 : MBEDTLS_CIPHER_ARIA_128_CBC,
1336 : 0,
1337 : MBEDTLS_CIPHER_BASE_INDEX_ARIA
1338 : };
1339 :
1340 : static const mbedtls_cipher_info_t aria_192_cbc_info = {
1341 : "ARIA-192-CBC",
1342 : 16,
1343 : 16 >> MBEDTLS_IV_SIZE_SHIFT,
1344 : 192 >> MBEDTLS_KEY_BITLEN_SHIFT,
1345 : MBEDTLS_MODE_CBC,
1346 : MBEDTLS_CIPHER_ARIA_192_CBC,
1347 : 0,
1348 : MBEDTLS_CIPHER_BASE_INDEX_ARIA
1349 : };
1350 :
1351 : static const mbedtls_cipher_info_t aria_256_cbc_info = {
1352 : "ARIA-256-CBC",
1353 : 16,
1354 : 16 >> MBEDTLS_IV_SIZE_SHIFT,
1355 : 256 >> MBEDTLS_KEY_BITLEN_SHIFT,
1356 : MBEDTLS_MODE_CBC,
1357 : MBEDTLS_CIPHER_ARIA_256_CBC,
1358 : 0,
1359 : MBEDTLS_CIPHER_BASE_INDEX_ARIA
1360 : };
1361 : #endif /* MBEDTLS_CIPHER_MODE_CBC */
1362 :
1363 : #if defined(MBEDTLS_CIPHER_MODE_CFB)
1364 : static const mbedtls_cipher_info_t aria_128_cfb128_info = {
1365 : "ARIA-128-CFB128",
1366 : 16,
1367 : 16 >> MBEDTLS_IV_SIZE_SHIFT,
1368 : 128 >> MBEDTLS_KEY_BITLEN_SHIFT,
1369 : MBEDTLS_MODE_CFB,
1370 : MBEDTLS_CIPHER_ARIA_128_CFB128,
1371 : 0,
1372 : MBEDTLS_CIPHER_BASE_INDEX_ARIA
1373 : };
1374 :
1375 : static const mbedtls_cipher_info_t aria_192_cfb128_info = {
1376 : "ARIA-192-CFB128",
1377 : 16,
1378 : 16 >> MBEDTLS_IV_SIZE_SHIFT,
1379 : 192 >> MBEDTLS_KEY_BITLEN_SHIFT,
1380 : MBEDTLS_MODE_CFB,
1381 : MBEDTLS_CIPHER_ARIA_192_CFB128,
1382 : 0,
1383 : MBEDTLS_CIPHER_BASE_INDEX_ARIA
1384 : };
1385 :
1386 : static const mbedtls_cipher_info_t aria_256_cfb128_info = {
1387 : "ARIA-256-CFB128",
1388 : 16,
1389 : 16 >> MBEDTLS_IV_SIZE_SHIFT,
1390 : 256 >> MBEDTLS_KEY_BITLEN_SHIFT,
1391 : MBEDTLS_MODE_CFB,
1392 : MBEDTLS_CIPHER_ARIA_256_CFB128,
1393 : 0,
1394 : MBEDTLS_CIPHER_BASE_INDEX_ARIA
1395 : };
1396 : #endif /* MBEDTLS_CIPHER_MODE_CFB */
1397 :
1398 : #if defined(MBEDTLS_CIPHER_MODE_CTR)
1399 : static const mbedtls_cipher_info_t aria_128_ctr_info = {
1400 : "ARIA-128-CTR",
1401 : 16,
1402 : 16 >> MBEDTLS_IV_SIZE_SHIFT,
1403 : 128 >> MBEDTLS_KEY_BITLEN_SHIFT,
1404 : MBEDTLS_MODE_CTR,
1405 : MBEDTLS_CIPHER_ARIA_128_CTR,
1406 : 0,
1407 : MBEDTLS_CIPHER_BASE_INDEX_ARIA
1408 : };
1409 :
1410 : static const mbedtls_cipher_info_t aria_192_ctr_info = {
1411 : "ARIA-192-CTR",
1412 : 16,
1413 : 16 >> MBEDTLS_IV_SIZE_SHIFT,
1414 : 192 >> MBEDTLS_KEY_BITLEN_SHIFT,
1415 : MBEDTLS_MODE_CTR,
1416 : MBEDTLS_CIPHER_ARIA_192_CTR,
1417 : 0,
1418 : MBEDTLS_CIPHER_BASE_INDEX_ARIA
1419 : };
1420 :
1421 : static const mbedtls_cipher_info_t aria_256_ctr_info = {
1422 : "ARIA-256-CTR",
1423 : 16,
1424 : 16 >> MBEDTLS_IV_SIZE_SHIFT,
1425 : 256 >> MBEDTLS_KEY_BITLEN_SHIFT,
1426 : MBEDTLS_MODE_CTR,
1427 : MBEDTLS_CIPHER_ARIA_256_CTR,
1428 : 0,
1429 : MBEDTLS_CIPHER_BASE_INDEX_ARIA
1430 : };
1431 : #endif /* MBEDTLS_CIPHER_MODE_CTR */
1432 :
1433 : #if defined(MBEDTLS_GCM_C)
1434 : static int gcm_aria_setkey_wrap(void *ctx, const unsigned char *key,
1435 : unsigned int key_bitlen)
1436 : {
1437 : return mbedtls_gcm_setkey((mbedtls_gcm_context *) ctx, MBEDTLS_CIPHER_ID_ARIA,
1438 : key, key_bitlen);
1439 : }
1440 :
1441 : static const mbedtls_cipher_base_t gcm_aria_info = {
1442 : MBEDTLS_CIPHER_ID_ARIA,
1443 : NULL,
1444 : #if defined(MBEDTLS_CIPHER_MODE_CBC)
1445 : NULL,
1446 : #endif
1447 : #if defined(MBEDTLS_CIPHER_MODE_CFB)
1448 : NULL,
1449 : #endif
1450 : #if defined(MBEDTLS_CIPHER_MODE_OFB)
1451 : NULL,
1452 : #endif
1453 : #if defined(MBEDTLS_CIPHER_MODE_CTR)
1454 : NULL,
1455 : #endif
1456 : #if defined(MBEDTLS_CIPHER_MODE_XTS)
1457 : NULL,
1458 : #endif
1459 : #if defined(MBEDTLS_CIPHER_MODE_STREAM)
1460 : NULL,
1461 : #endif
1462 : gcm_aria_setkey_wrap,
1463 : #if !defined(MBEDTLS_BLOCK_CIPHER_NO_DECRYPT)
1464 : gcm_aria_setkey_wrap,
1465 : #endif
1466 : gcm_ctx_alloc,
1467 : gcm_ctx_free,
1468 : };
1469 :
1470 : static const mbedtls_cipher_info_t aria_128_gcm_info = {
1471 : "ARIA-128-GCM",
1472 : 16,
1473 : 12 >> MBEDTLS_IV_SIZE_SHIFT,
1474 : 128 >> MBEDTLS_KEY_BITLEN_SHIFT,
1475 : MBEDTLS_MODE_GCM,
1476 : MBEDTLS_CIPHER_ARIA_128_GCM,
1477 : MBEDTLS_CIPHER_VARIABLE_IV_LEN,
1478 : MBEDTLS_CIPHER_BASE_INDEX_GCM_ARIA
1479 : };
1480 :
1481 : static const mbedtls_cipher_info_t aria_192_gcm_info = {
1482 : "ARIA-192-GCM",
1483 : 16,
1484 : 12 >> MBEDTLS_IV_SIZE_SHIFT,
1485 : 192 >> MBEDTLS_KEY_BITLEN_SHIFT,
1486 : MBEDTLS_MODE_GCM,
1487 : MBEDTLS_CIPHER_ARIA_192_GCM,
1488 : MBEDTLS_CIPHER_VARIABLE_IV_LEN,
1489 : MBEDTLS_CIPHER_BASE_INDEX_GCM_ARIA
1490 : };
1491 :
1492 : static const mbedtls_cipher_info_t aria_256_gcm_info = {
1493 : "ARIA-256-GCM",
1494 : 16,
1495 : 12 >> MBEDTLS_IV_SIZE_SHIFT,
1496 : 256 >> MBEDTLS_KEY_BITLEN_SHIFT,
1497 : MBEDTLS_MODE_GCM,
1498 : MBEDTLS_CIPHER_ARIA_256_GCM,
1499 : MBEDTLS_CIPHER_VARIABLE_IV_LEN,
1500 : MBEDTLS_CIPHER_BASE_INDEX_GCM_ARIA
1501 : };
1502 : #endif /* MBEDTLS_GCM_C */
1503 :
1504 : #if defined(MBEDTLS_CCM_C)
1505 : static int ccm_aria_setkey_wrap(void *ctx, const unsigned char *key,
1506 : unsigned int key_bitlen)
1507 : {
1508 : return mbedtls_ccm_setkey((mbedtls_ccm_context *) ctx, MBEDTLS_CIPHER_ID_ARIA,
1509 : key, key_bitlen);
1510 : }
1511 :
1512 : static const mbedtls_cipher_base_t ccm_aria_info = {
1513 : MBEDTLS_CIPHER_ID_ARIA,
1514 : NULL,
1515 : #if defined(MBEDTLS_CIPHER_MODE_CBC)
1516 : NULL,
1517 : #endif
1518 : #if defined(MBEDTLS_CIPHER_MODE_CFB)
1519 : NULL,
1520 : #endif
1521 : #if defined(MBEDTLS_CIPHER_MODE_OFB)
1522 : NULL,
1523 : #endif
1524 : #if defined(MBEDTLS_CIPHER_MODE_CTR)
1525 : NULL,
1526 : #endif
1527 : #if defined(MBEDTLS_CIPHER_MODE_XTS)
1528 : NULL,
1529 : #endif
1530 : #if defined(MBEDTLS_CIPHER_MODE_STREAM)
1531 : NULL,
1532 : #endif
1533 : ccm_aria_setkey_wrap,
1534 : #if !defined(MBEDTLS_BLOCK_CIPHER_NO_DECRYPT)
1535 : ccm_aria_setkey_wrap,
1536 : #endif
1537 : ccm_ctx_alloc,
1538 : ccm_ctx_free,
1539 : };
1540 :
1541 : static const mbedtls_cipher_info_t aria_128_ccm_info = {
1542 : "ARIA-128-CCM",
1543 : 16,
1544 : 12 >> MBEDTLS_IV_SIZE_SHIFT,
1545 : 128 >> MBEDTLS_KEY_BITLEN_SHIFT,
1546 : MBEDTLS_MODE_CCM,
1547 : MBEDTLS_CIPHER_ARIA_128_CCM,
1548 : MBEDTLS_CIPHER_VARIABLE_IV_LEN,
1549 : MBEDTLS_CIPHER_BASE_INDEX_CCM_ARIA
1550 : };
1551 :
1552 : static const mbedtls_cipher_info_t aria_192_ccm_info = {
1553 : "ARIA-192-CCM",
1554 : 16,
1555 : 12 >> MBEDTLS_IV_SIZE_SHIFT,
1556 : 192 >> MBEDTLS_KEY_BITLEN_SHIFT,
1557 : MBEDTLS_MODE_CCM,
1558 : MBEDTLS_CIPHER_ARIA_192_CCM,
1559 : MBEDTLS_CIPHER_VARIABLE_IV_LEN,
1560 : MBEDTLS_CIPHER_BASE_INDEX_CCM_ARIA
1561 : };
1562 :
1563 : static const mbedtls_cipher_info_t aria_256_ccm_info = {
1564 : "ARIA-256-CCM",
1565 : 16,
1566 : 12 >> MBEDTLS_IV_SIZE_SHIFT,
1567 : 256 >> MBEDTLS_KEY_BITLEN_SHIFT,
1568 : MBEDTLS_MODE_CCM,
1569 : MBEDTLS_CIPHER_ARIA_256_CCM,
1570 : MBEDTLS_CIPHER_VARIABLE_IV_LEN,
1571 : MBEDTLS_CIPHER_BASE_INDEX_CCM_ARIA
1572 : };
1573 :
1574 : static const mbedtls_cipher_info_t aria_128_ccm_star_no_tag_info = {
1575 : "ARIA-128-CCM*-NO-TAG",
1576 : 16,
1577 : 12 >> MBEDTLS_IV_SIZE_SHIFT,
1578 : 128 >> MBEDTLS_KEY_BITLEN_SHIFT,
1579 : MBEDTLS_MODE_CCM_STAR_NO_TAG,
1580 : MBEDTLS_CIPHER_ARIA_128_CCM_STAR_NO_TAG,
1581 : MBEDTLS_CIPHER_VARIABLE_IV_LEN,
1582 : MBEDTLS_CIPHER_BASE_INDEX_CCM_ARIA
1583 : };
1584 :
1585 : static const mbedtls_cipher_info_t aria_192_ccm_star_no_tag_info = {
1586 : "ARIA-192-CCM*-NO-TAG",
1587 : 16,
1588 : 12 >> MBEDTLS_IV_SIZE_SHIFT,
1589 : 192 >> MBEDTLS_KEY_BITLEN_SHIFT,
1590 : MBEDTLS_MODE_CCM_STAR_NO_TAG,
1591 : MBEDTLS_CIPHER_ARIA_192_CCM_STAR_NO_TAG,
1592 : MBEDTLS_CIPHER_VARIABLE_IV_LEN,
1593 : MBEDTLS_CIPHER_BASE_INDEX_CCM_ARIA
1594 : };
1595 :
1596 : static const mbedtls_cipher_info_t aria_256_ccm_star_no_tag_info = {
1597 : "ARIA-256-CCM*-NO-TAG",
1598 : 16,
1599 : 12 >> MBEDTLS_IV_SIZE_SHIFT,
1600 : 256 >> MBEDTLS_KEY_BITLEN_SHIFT,
1601 : MBEDTLS_MODE_CCM_STAR_NO_TAG,
1602 : MBEDTLS_CIPHER_ARIA_256_CCM_STAR_NO_TAG,
1603 : MBEDTLS_CIPHER_VARIABLE_IV_LEN,
1604 : MBEDTLS_CIPHER_BASE_INDEX_CCM_ARIA
1605 : };
1606 : #endif /* MBEDTLS_CCM_C */
1607 :
1608 : #endif /* MBEDTLS_ARIA_C */
1609 :
1610 : #if defined(MBEDTLS_DES_C)
1611 :
1612 : static int des_crypt_ecb_wrap(void *ctx, mbedtls_operation_t operation,
1613 : const unsigned char *input, unsigned char *output)
1614 : {
1615 : ((void) operation);
1616 : return mbedtls_des_crypt_ecb((mbedtls_des_context *) ctx, input, output);
1617 : }
1618 :
1619 : static int des3_crypt_ecb_wrap(void *ctx, mbedtls_operation_t operation,
1620 : const unsigned char *input, unsigned char *output)
1621 : {
1622 : ((void) operation);
1623 : return mbedtls_des3_crypt_ecb((mbedtls_des3_context *) ctx, input, output);
1624 : }
1625 :
1626 : #if defined(MBEDTLS_CIPHER_MODE_CBC)
1627 : static int des_crypt_cbc_wrap(void *ctx, mbedtls_operation_t operation, size_t length,
1628 : unsigned char *iv, const unsigned char *input, unsigned char *output)
1629 : {
1630 : return mbedtls_des_crypt_cbc((mbedtls_des_context *) ctx, operation, length, iv, input,
1631 : output);
1632 : }
1633 : #endif /* MBEDTLS_CIPHER_MODE_CBC */
1634 :
1635 : #if defined(MBEDTLS_CIPHER_MODE_CBC)
1636 : static int des3_crypt_cbc_wrap(void *ctx, mbedtls_operation_t operation, size_t length,
1637 : unsigned char *iv, const unsigned char *input, unsigned char *output)
1638 : {
1639 : return mbedtls_des3_crypt_cbc((mbedtls_des3_context *) ctx, operation, length, iv, input,
1640 : output);
1641 : }
1642 : #endif /* MBEDTLS_CIPHER_MODE_CBC */
1643 :
1644 : static int des_setkey_dec_wrap(void *ctx, const unsigned char *key,
1645 : unsigned int key_bitlen)
1646 : {
1647 : ((void) key_bitlen);
1648 :
1649 : return mbedtls_des_setkey_dec((mbedtls_des_context *) ctx, key);
1650 : }
1651 :
1652 : static int des_setkey_enc_wrap(void *ctx, const unsigned char *key,
1653 : unsigned int key_bitlen)
1654 : {
1655 : ((void) key_bitlen);
1656 :
1657 : return mbedtls_des_setkey_enc((mbedtls_des_context *) ctx, key);
1658 : }
1659 :
1660 : static int des3_set2key_dec_wrap(void *ctx, const unsigned char *key,
1661 : unsigned int key_bitlen)
1662 : {
1663 : ((void) key_bitlen);
1664 :
1665 : return mbedtls_des3_set2key_dec((mbedtls_des3_context *) ctx, key);
1666 : }
1667 :
1668 : static int des3_set2key_enc_wrap(void *ctx, const unsigned char *key,
1669 : unsigned int key_bitlen)
1670 : {
1671 : ((void) key_bitlen);
1672 :
1673 : return mbedtls_des3_set2key_enc((mbedtls_des3_context *) ctx, key);
1674 : }
1675 :
1676 : static int des3_set3key_dec_wrap(void *ctx, const unsigned char *key,
1677 : unsigned int key_bitlen)
1678 : {
1679 : ((void) key_bitlen);
1680 :
1681 : return mbedtls_des3_set3key_dec((mbedtls_des3_context *) ctx, key);
1682 : }
1683 :
1684 : static int des3_set3key_enc_wrap(void *ctx, const unsigned char *key,
1685 : unsigned int key_bitlen)
1686 : {
1687 : ((void) key_bitlen);
1688 :
1689 : return mbedtls_des3_set3key_enc((mbedtls_des3_context *) ctx, key);
1690 : }
1691 :
1692 : static void *des_ctx_alloc(void)
1693 : {
1694 : mbedtls_des_context *des = mbedtls_calloc(1, sizeof(mbedtls_des_context));
1695 :
1696 : if (des == NULL) {
1697 : return NULL;
1698 : }
1699 :
1700 : mbedtls_des_init(des);
1701 :
1702 : return des;
1703 : }
1704 :
1705 : static void des_ctx_free(void *ctx)
1706 : {
1707 : mbedtls_des_free((mbedtls_des_context *) ctx);
1708 : mbedtls_free(ctx);
1709 : }
1710 :
1711 : static void *des3_ctx_alloc(void)
1712 : {
1713 : mbedtls_des3_context *des3;
1714 : des3 = mbedtls_calloc(1, sizeof(mbedtls_des3_context));
1715 :
1716 : if (des3 == NULL) {
1717 : return NULL;
1718 : }
1719 :
1720 : mbedtls_des3_init(des3);
1721 :
1722 : return des3;
1723 : }
1724 :
1725 : static void des3_ctx_free(void *ctx)
1726 : {
1727 : mbedtls_des3_free((mbedtls_des3_context *) ctx);
1728 : mbedtls_free(ctx);
1729 : }
1730 :
1731 : static const mbedtls_cipher_base_t des_info = {
1732 : MBEDTLS_CIPHER_ID_DES,
1733 : des_crypt_ecb_wrap,
1734 : #if defined(MBEDTLS_CIPHER_MODE_CBC)
1735 : des_crypt_cbc_wrap,
1736 : #endif
1737 : #if defined(MBEDTLS_CIPHER_MODE_CFB)
1738 : NULL,
1739 : #endif
1740 : #if defined(MBEDTLS_CIPHER_MODE_OFB)
1741 : NULL,
1742 : #endif
1743 : #if defined(MBEDTLS_CIPHER_MODE_CTR)
1744 : NULL,
1745 : #endif
1746 : #if defined(MBEDTLS_CIPHER_MODE_XTS)
1747 : NULL,
1748 : #endif
1749 : #if defined(MBEDTLS_CIPHER_MODE_STREAM)
1750 : NULL,
1751 : #endif
1752 : des_setkey_enc_wrap,
1753 : des_setkey_dec_wrap,
1754 : des_ctx_alloc,
1755 : des_ctx_free
1756 : };
1757 :
1758 : static const mbedtls_cipher_info_t des_ecb_info = {
1759 : "DES-ECB",
1760 : 8,
1761 : 0 >> MBEDTLS_IV_SIZE_SHIFT,
1762 : MBEDTLS_KEY_LENGTH_DES >> MBEDTLS_KEY_BITLEN_SHIFT,
1763 : MBEDTLS_MODE_ECB,
1764 : MBEDTLS_CIPHER_DES_ECB,
1765 : 0,
1766 : MBEDTLS_CIPHER_BASE_INDEX_DES
1767 : };
1768 :
1769 : #if defined(MBEDTLS_CIPHER_MODE_CBC)
1770 : static const mbedtls_cipher_info_t des_cbc_info = {
1771 : "DES-CBC",
1772 : 8,
1773 : 8 >> MBEDTLS_IV_SIZE_SHIFT,
1774 : MBEDTLS_KEY_LENGTH_DES >> MBEDTLS_KEY_BITLEN_SHIFT,
1775 : MBEDTLS_MODE_CBC,
1776 : MBEDTLS_CIPHER_DES_CBC,
1777 : 0,
1778 : MBEDTLS_CIPHER_BASE_INDEX_DES
1779 : };
1780 : #endif /* MBEDTLS_CIPHER_MODE_CBC */
1781 :
1782 : static const mbedtls_cipher_base_t des_ede_info = {
1783 : MBEDTLS_CIPHER_ID_DES,
1784 : des3_crypt_ecb_wrap,
1785 : #if defined(MBEDTLS_CIPHER_MODE_CBC)
1786 : des3_crypt_cbc_wrap,
1787 : #endif
1788 : #if defined(MBEDTLS_CIPHER_MODE_CFB)
1789 : NULL,
1790 : #endif
1791 : #if defined(MBEDTLS_CIPHER_MODE_OFB)
1792 : NULL,
1793 : #endif
1794 : #if defined(MBEDTLS_CIPHER_MODE_CTR)
1795 : NULL,
1796 : #endif
1797 : #if defined(MBEDTLS_CIPHER_MODE_XTS)
1798 : NULL,
1799 : #endif
1800 : #if defined(MBEDTLS_CIPHER_MODE_STREAM)
1801 : NULL,
1802 : #endif
1803 : des3_set2key_enc_wrap,
1804 : des3_set2key_dec_wrap,
1805 : des3_ctx_alloc,
1806 : des3_ctx_free
1807 : };
1808 :
1809 : static const mbedtls_cipher_info_t des_ede_ecb_info = {
1810 : "DES-EDE-ECB",
1811 : 8,
1812 : 0 >> MBEDTLS_IV_SIZE_SHIFT,
1813 : MBEDTLS_KEY_LENGTH_DES_EDE >> MBEDTLS_KEY_BITLEN_SHIFT,
1814 : MBEDTLS_MODE_ECB,
1815 : MBEDTLS_CIPHER_DES_EDE_ECB,
1816 : 0,
1817 : MBEDTLS_CIPHER_BASE_INDEX_DES_EDE
1818 : };
1819 :
1820 : #if defined(MBEDTLS_CIPHER_MODE_CBC)
1821 : static const mbedtls_cipher_info_t des_ede_cbc_info = {
1822 : "DES-EDE-CBC",
1823 : 8,
1824 : 8 >> MBEDTLS_IV_SIZE_SHIFT,
1825 : MBEDTLS_KEY_LENGTH_DES_EDE >> MBEDTLS_KEY_BITLEN_SHIFT,
1826 : MBEDTLS_MODE_CBC,
1827 : MBEDTLS_CIPHER_DES_EDE_CBC,
1828 : 0,
1829 : MBEDTLS_CIPHER_BASE_INDEX_DES_EDE
1830 : };
1831 : #endif /* MBEDTLS_CIPHER_MODE_CBC */
1832 :
1833 : static const mbedtls_cipher_base_t des_ede3_info = {
1834 : MBEDTLS_CIPHER_ID_3DES,
1835 : des3_crypt_ecb_wrap,
1836 : #if defined(MBEDTLS_CIPHER_MODE_CBC)
1837 : des3_crypt_cbc_wrap,
1838 : #endif
1839 : #if defined(MBEDTLS_CIPHER_MODE_CFB)
1840 : NULL,
1841 : #endif
1842 : #if defined(MBEDTLS_CIPHER_MODE_OFB)
1843 : NULL,
1844 : #endif
1845 : #if defined(MBEDTLS_CIPHER_MODE_CTR)
1846 : NULL,
1847 : #endif
1848 : #if defined(MBEDTLS_CIPHER_MODE_XTS)
1849 : NULL,
1850 : #endif
1851 : #if defined(MBEDTLS_CIPHER_MODE_STREAM)
1852 : NULL,
1853 : #endif
1854 : des3_set3key_enc_wrap,
1855 : des3_set3key_dec_wrap,
1856 : des3_ctx_alloc,
1857 : des3_ctx_free
1858 : };
1859 :
1860 : static const mbedtls_cipher_info_t des_ede3_ecb_info = {
1861 : "DES-EDE3-ECB",
1862 : 8,
1863 : 0 >> MBEDTLS_IV_SIZE_SHIFT,
1864 : MBEDTLS_KEY_LENGTH_DES_EDE3 >> MBEDTLS_KEY_BITLEN_SHIFT,
1865 : MBEDTLS_MODE_ECB,
1866 : MBEDTLS_CIPHER_DES_EDE3_ECB,
1867 : 0,
1868 : MBEDTLS_CIPHER_BASE_INDEX_DES_EDE3
1869 : };
1870 : #if defined(MBEDTLS_CIPHER_MODE_CBC)
1871 : static const mbedtls_cipher_info_t des_ede3_cbc_info = {
1872 : "DES-EDE3-CBC",
1873 : 8,
1874 : 8 >> MBEDTLS_IV_SIZE_SHIFT,
1875 : MBEDTLS_KEY_LENGTH_DES_EDE3 >> MBEDTLS_KEY_BITLEN_SHIFT,
1876 : MBEDTLS_MODE_CBC,
1877 : MBEDTLS_CIPHER_DES_EDE3_CBC,
1878 : 0,
1879 : MBEDTLS_CIPHER_BASE_INDEX_DES_EDE3
1880 : };
1881 : #endif /* MBEDTLS_CIPHER_MODE_CBC */
1882 : #endif /* MBEDTLS_DES_C */
1883 :
1884 : #if defined(MBEDTLS_CHACHA20_C)
1885 :
1886 0 : static int chacha20_setkey_wrap(void *ctx, const unsigned char *key,
1887 : unsigned int key_bitlen)
1888 : {
1889 0 : if (key_bitlen != 256U) {
1890 0 : return MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA;
1891 : }
1892 :
1893 0 : if (0 != mbedtls_chacha20_setkey((mbedtls_chacha20_context *) ctx, key)) {
1894 0 : return MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA;
1895 : }
1896 :
1897 0 : return 0;
1898 : }
1899 :
1900 0 : static int chacha20_stream_wrap(void *ctx, size_t length,
1901 : const unsigned char *input,
1902 : unsigned char *output)
1903 : {
1904 0 : int ret = MBEDTLS_ERR_ERROR_CORRUPTION_DETECTED;
1905 :
1906 0 : ret = mbedtls_chacha20_update(ctx, length, input, output);
1907 0 : if (ret == MBEDTLS_ERR_CHACHA20_BAD_INPUT_DATA) {
1908 0 : return MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA;
1909 : }
1910 :
1911 0 : return ret;
1912 : }
1913 :
1914 0 : static void *chacha20_ctx_alloc(void)
1915 : {
1916 : mbedtls_chacha20_context *ctx;
1917 0 : ctx = mbedtls_calloc(1, sizeof(mbedtls_chacha20_context));
1918 :
1919 0 : if (ctx == NULL) {
1920 0 : return NULL;
1921 : }
1922 :
1923 0 : mbedtls_chacha20_init(ctx);
1924 :
1925 0 : return ctx;
1926 : }
1927 :
1928 0 : static void chacha20_ctx_free(void *ctx)
1929 : {
1930 0 : mbedtls_chacha20_free((mbedtls_chacha20_context *) ctx);
1931 0 : mbedtls_free(ctx);
1932 0 : }
1933 :
1934 : static const mbedtls_cipher_base_t chacha20_base_info = {
1935 : MBEDTLS_CIPHER_ID_CHACHA20,
1936 : NULL,
1937 : #if defined(MBEDTLS_CIPHER_MODE_CBC)
1938 : NULL,
1939 : #endif
1940 : #if defined(MBEDTLS_CIPHER_MODE_CFB)
1941 : NULL,
1942 : #endif
1943 : #if defined(MBEDTLS_CIPHER_MODE_OFB)
1944 : NULL,
1945 : #endif
1946 : #if defined(MBEDTLS_CIPHER_MODE_CTR)
1947 : NULL,
1948 : #endif
1949 : #if defined(MBEDTLS_CIPHER_MODE_XTS)
1950 : NULL,
1951 : #endif
1952 : #if defined(MBEDTLS_CIPHER_MODE_STREAM)
1953 : chacha20_stream_wrap,
1954 : #endif
1955 : chacha20_setkey_wrap,
1956 : #if !defined(MBEDTLS_BLOCK_CIPHER_NO_DECRYPT)
1957 : chacha20_setkey_wrap,
1958 : #endif
1959 : chacha20_ctx_alloc,
1960 : chacha20_ctx_free
1961 : };
1962 : static const mbedtls_cipher_info_t chacha20_info = {
1963 : "CHACHA20",
1964 : 1,
1965 : 12 >> MBEDTLS_IV_SIZE_SHIFT,
1966 : 256 >> MBEDTLS_KEY_BITLEN_SHIFT,
1967 : MBEDTLS_MODE_STREAM,
1968 : MBEDTLS_CIPHER_CHACHA20,
1969 : 0,
1970 : MBEDTLS_CIPHER_BASE_INDEX_CHACHA20_BASE
1971 : };
1972 : #endif /* MBEDTLS_CHACHA20_C */
1973 :
1974 : #if defined(MBEDTLS_CHACHAPOLY_C)
1975 :
1976 0 : static int chachapoly_setkey_wrap(void *ctx,
1977 : const unsigned char *key,
1978 : unsigned int key_bitlen)
1979 : {
1980 0 : if (key_bitlen != 256U) {
1981 0 : return MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA;
1982 : }
1983 :
1984 0 : if (0 != mbedtls_chachapoly_setkey((mbedtls_chachapoly_context *) ctx, key)) {
1985 0 : return MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA;
1986 : }
1987 :
1988 0 : return 0;
1989 : }
1990 :
1991 0 : static void *chachapoly_ctx_alloc(void)
1992 : {
1993 : mbedtls_chachapoly_context *ctx;
1994 0 : ctx = mbedtls_calloc(1, sizeof(mbedtls_chachapoly_context));
1995 :
1996 0 : if (ctx == NULL) {
1997 0 : return NULL;
1998 : }
1999 :
2000 0 : mbedtls_chachapoly_init(ctx);
2001 :
2002 0 : return ctx;
2003 : }
2004 :
2005 0 : static void chachapoly_ctx_free(void *ctx)
2006 : {
2007 0 : mbedtls_chachapoly_free((mbedtls_chachapoly_context *) ctx);
2008 0 : mbedtls_free(ctx);
2009 0 : }
2010 :
2011 : static const mbedtls_cipher_base_t chachapoly_base_info = {
2012 : MBEDTLS_CIPHER_ID_CHACHA20,
2013 : NULL,
2014 : #if defined(MBEDTLS_CIPHER_MODE_CBC)
2015 : NULL,
2016 : #endif
2017 : #if defined(MBEDTLS_CIPHER_MODE_CFB)
2018 : NULL,
2019 : #endif
2020 : #if defined(MBEDTLS_CIPHER_MODE_OFB)
2021 : NULL,
2022 : #endif
2023 : #if defined(MBEDTLS_CIPHER_MODE_CTR)
2024 : NULL,
2025 : #endif
2026 : #if defined(MBEDTLS_CIPHER_MODE_XTS)
2027 : NULL,
2028 : #endif
2029 : #if defined(MBEDTLS_CIPHER_MODE_STREAM)
2030 : NULL,
2031 : #endif
2032 : chachapoly_setkey_wrap,
2033 : #if !defined(MBEDTLS_BLOCK_CIPHER_NO_DECRYPT)
2034 : chachapoly_setkey_wrap,
2035 : #endif
2036 : chachapoly_ctx_alloc,
2037 : chachapoly_ctx_free
2038 : };
2039 : static const mbedtls_cipher_info_t chachapoly_info = {
2040 : "CHACHA20-POLY1305",
2041 : 1,
2042 : 12 >> MBEDTLS_IV_SIZE_SHIFT,
2043 : 256 >> MBEDTLS_KEY_BITLEN_SHIFT,
2044 : MBEDTLS_MODE_CHACHAPOLY,
2045 : MBEDTLS_CIPHER_CHACHA20_POLY1305,
2046 : 0,
2047 : MBEDTLS_CIPHER_BASE_INDEX_CHACHAPOLY_BASE
2048 : };
2049 : #endif /* MBEDTLS_CHACHAPOLY_C */
2050 :
2051 : #if defined(MBEDTLS_CIPHER_NULL_CIPHER)
2052 : static int null_crypt_stream(void *ctx, size_t length,
2053 : const unsigned char *input,
2054 : unsigned char *output)
2055 : {
2056 : ((void) ctx);
2057 : memmove(output, input, length);
2058 : return 0;
2059 : }
2060 :
2061 : static int null_setkey(void *ctx, const unsigned char *key,
2062 : unsigned int key_bitlen)
2063 : {
2064 : ((void) ctx);
2065 : ((void) key);
2066 : ((void) key_bitlen);
2067 :
2068 : return 0;
2069 : }
2070 :
2071 : static void *null_ctx_alloc(void)
2072 : {
2073 : return (void *) 1;
2074 : }
2075 :
2076 : static void null_ctx_free(void *ctx)
2077 : {
2078 : ((void) ctx);
2079 : }
2080 :
2081 : static const mbedtls_cipher_base_t null_base_info = {
2082 : MBEDTLS_CIPHER_ID_NULL,
2083 : NULL,
2084 : #if defined(MBEDTLS_CIPHER_MODE_CBC)
2085 : NULL,
2086 : #endif
2087 : #if defined(MBEDTLS_CIPHER_MODE_CFB)
2088 : NULL,
2089 : #endif
2090 : #if defined(MBEDTLS_CIPHER_MODE_OFB)
2091 : NULL,
2092 : #endif
2093 : #if defined(MBEDTLS_CIPHER_MODE_CTR)
2094 : NULL,
2095 : #endif
2096 : #if defined(MBEDTLS_CIPHER_MODE_XTS)
2097 : NULL,
2098 : #endif
2099 : #if defined(MBEDTLS_CIPHER_MODE_STREAM)
2100 : null_crypt_stream,
2101 : #endif
2102 : null_setkey,
2103 : #if !defined(MBEDTLS_BLOCK_CIPHER_NO_DECRYPT)
2104 : null_setkey,
2105 : #endif
2106 : null_ctx_alloc,
2107 : null_ctx_free
2108 : };
2109 :
2110 : static const mbedtls_cipher_info_t null_cipher_info = {
2111 : "NULL",
2112 : 1,
2113 : 0 >> MBEDTLS_IV_SIZE_SHIFT,
2114 : 0 >> MBEDTLS_KEY_BITLEN_SHIFT,
2115 : MBEDTLS_MODE_STREAM,
2116 : MBEDTLS_CIPHER_NULL,
2117 : 0,
2118 : MBEDTLS_CIPHER_BASE_INDEX_NULL_BASE
2119 : };
2120 : #endif /* defined(MBEDTLS_CIPHER_NULL_CIPHER) */
2121 :
2122 : #if defined(MBEDTLS_NIST_KW_C)
2123 : static void *kw_ctx_alloc(void)
2124 : {
2125 : void *ctx = mbedtls_calloc(1, sizeof(mbedtls_nist_kw_context));
2126 :
2127 : if (ctx != NULL) {
2128 : mbedtls_nist_kw_init((mbedtls_nist_kw_context *) ctx);
2129 : }
2130 :
2131 : return ctx;
2132 : }
2133 :
2134 : static void kw_ctx_free(void *ctx)
2135 : {
2136 : mbedtls_nist_kw_free(ctx);
2137 : mbedtls_free(ctx);
2138 : }
2139 :
2140 : static int kw_aes_setkey_wrap(void *ctx, const unsigned char *key,
2141 : unsigned int key_bitlen)
2142 : {
2143 : return mbedtls_nist_kw_setkey((mbedtls_nist_kw_context *) ctx,
2144 : MBEDTLS_CIPHER_ID_AES, key, key_bitlen, 1);
2145 : }
2146 :
2147 : static int kw_aes_setkey_unwrap(void *ctx, const unsigned char *key,
2148 : unsigned int key_bitlen)
2149 : {
2150 : return mbedtls_nist_kw_setkey((mbedtls_nist_kw_context *) ctx,
2151 : MBEDTLS_CIPHER_ID_AES, key, key_bitlen, 0);
2152 : }
2153 :
2154 : static const mbedtls_cipher_base_t kw_aes_info = {
2155 : MBEDTLS_CIPHER_ID_AES,
2156 : NULL,
2157 : #if defined(MBEDTLS_CIPHER_MODE_CBC)
2158 : NULL,
2159 : #endif
2160 : #if defined(MBEDTLS_CIPHER_MODE_CFB)
2161 : NULL,
2162 : #endif
2163 : #if defined(MBEDTLS_CIPHER_MODE_OFB)
2164 : NULL,
2165 : #endif
2166 : #if defined(MBEDTLS_CIPHER_MODE_CTR)
2167 : NULL,
2168 : #endif
2169 : #if defined(MBEDTLS_CIPHER_MODE_XTS)
2170 : NULL,
2171 : #endif
2172 : #if defined(MBEDTLS_CIPHER_MODE_STREAM)
2173 : NULL,
2174 : #endif
2175 : kw_aes_setkey_wrap,
2176 : kw_aes_setkey_unwrap,
2177 : kw_ctx_alloc,
2178 : kw_ctx_free,
2179 : };
2180 :
2181 : static const mbedtls_cipher_info_t aes_128_nist_kw_info = {
2182 : "AES-128-KW",
2183 : 16,
2184 : 0 >> MBEDTLS_IV_SIZE_SHIFT,
2185 : 128 >> MBEDTLS_KEY_BITLEN_SHIFT,
2186 : MBEDTLS_MODE_KW,
2187 : MBEDTLS_CIPHER_AES_128_KW,
2188 : 0,
2189 : MBEDTLS_CIPHER_BASE_INDEX_KW_AES
2190 : };
2191 :
2192 : #if !defined(MBEDTLS_AES_ONLY_128_BIT_KEY_LENGTH)
2193 : static const mbedtls_cipher_info_t aes_192_nist_kw_info = {
2194 : "AES-192-KW",
2195 : 16,
2196 : 0 >> MBEDTLS_IV_SIZE_SHIFT,
2197 : 192 >> MBEDTLS_KEY_BITLEN_SHIFT,
2198 : MBEDTLS_MODE_KW,
2199 : MBEDTLS_CIPHER_AES_192_KW,
2200 : 0,
2201 : MBEDTLS_CIPHER_BASE_INDEX_KW_AES
2202 : };
2203 :
2204 : static const mbedtls_cipher_info_t aes_256_nist_kw_info = {
2205 : "AES-256-KW",
2206 : 16,
2207 : 0 >> MBEDTLS_IV_SIZE_SHIFT,
2208 : 256 >> MBEDTLS_KEY_BITLEN_SHIFT,
2209 : MBEDTLS_MODE_KW,
2210 : MBEDTLS_CIPHER_AES_256_KW,
2211 : 0,
2212 : MBEDTLS_CIPHER_BASE_INDEX_KW_AES
2213 : };
2214 : #endif
2215 :
2216 : static const mbedtls_cipher_info_t aes_128_nist_kwp_info = {
2217 : "AES-128-KWP",
2218 : 16,
2219 : 0 >> MBEDTLS_IV_SIZE_SHIFT,
2220 : 128 >> MBEDTLS_KEY_BITLEN_SHIFT,
2221 : MBEDTLS_MODE_KWP,
2222 : MBEDTLS_CIPHER_AES_128_KWP,
2223 : 0,
2224 : MBEDTLS_CIPHER_BASE_INDEX_KW_AES
2225 : };
2226 :
2227 : #if !defined(MBEDTLS_AES_ONLY_128_BIT_KEY_LENGTH)
2228 : static const mbedtls_cipher_info_t aes_192_nist_kwp_info = {
2229 : "AES-192-KWP",
2230 : 16,
2231 : 0 >> MBEDTLS_IV_SIZE_SHIFT,
2232 : 192 >> MBEDTLS_KEY_BITLEN_SHIFT,
2233 : MBEDTLS_MODE_KWP,
2234 : MBEDTLS_CIPHER_AES_192_KWP,
2235 : 0,
2236 : MBEDTLS_CIPHER_BASE_INDEX_KW_AES
2237 : };
2238 :
2239 : static const mbedtls_cipher_info_t aes_256_nist_kwp_info = {
2240 : "AES-256-KWP",
2241 : 16,
2242 : 0 >> MBEDTLS_IV_SIZE_SHIFT,
2243 : 256 >> MBEDTLS_KEY_BITLEN_SHIFT,
2244 : MBEDTLS_MODE_KWP,
2245 : MBEDTLS_CIPHER_AES_256_KWP,
2246 : 0,
2247 : MBEDTLS_CIPHER_BASE_INDEX_KW_AES
2248 : };
2249 : #endif
2250 : #endif /* MBEDTLS_NIST_KW_C */
2251 :
2252 : const mbedtls_cipher_definition_t mbedtls_cipher_definitions[] =
2253 : {
2254 : #if defined(MBEDTLS_AES_C)
2255 : { MBEDTLS_CIPHER_AES_128_ECB, &aes_128_ecb_info },
2256 : #if !defined(MBEDTLS_AES_ONLY_128_BIT_KEY_LENGTH)
2257 : { MBEDTLS_CIPHER_AES_192_ECB, &aes_192_ecb_info },
2258 : { MBEDTLS_CIPHER_AES_256_ECB, &aes_256_ecb_info },
2259 : #endif
2260 : #if defined(MBEDTLS_CIPHER_MODE_CBC)
2261 : { MBEDTLS_CIPHER_AES_128_CBC, &aes_128_cbc_info },
2262 : #if !defined(MBEDTLS_AES_ONLY_128_BIT_KEY_LENGTH)
2263 : { MBEDTLS_CIPHER_AES_192_CBC, &aes_192_cbc_info },
2264 : { MBEDTLS_CIPHER_AES_256_CBC, &aes_256_cbc_info },
2265 : #endif
2266 : #endif
2267 : #if defined(MBEDTLS_CIPHER_MODE_CFB)
2268 : { MBEDTLS_CIPHER_AES_128_CFB128, &aes_128_cfb128_info },
2269 : #if !defined(MBEDTLS_AES_ONLY_128_BIT_KEY_LENGTH)
2270 : { MBEDTLS_CIPHER_AES_192_CFB128, &aes_192_cfb128_info },
2271 : { MBEDTLS_CIPHER_AES_256_CFB128, &aes_256_cfb128_info },
2272 : #endif
2273 : #endif
2274 : #if defined(MBEDTLS_CIPHER_MODE_OFB)
2275 : { MBEDTLS_CIPHER_AES_128_OFB, &aes_128_ofb_info },
2276 : #if !defined(MBEDTLS_AES_ONLY_128_BIT_KEY_LENGTH)
2277 : { MBEDTLS_CIPHER_AES_192_OFB, &aes_192_ofb_info },
2278 : { MBEDTLS_CIPHER_AES_256_OFB, &aes_256_ofb_info },
2279 : #endif
2280 : #endif
2281 : #if defined(MBEDTLS_CIPHER_MODE_CTR)
2282 : { MBEDTLS_CIPHER_AES_128_CTR, &aes_128_ctr_info },
2283 : #if !defined(MBEDTLS_AES_ONLY_128_BIT_KEY_LENGTH)
2284 : { MBEDTLS_CIPHER_AES_192_CTR, &aes_192_ctr_info },
2285 : { MBEDTLS_CIPHER_AES_256_CTR, &aes_256_ctr_info },
2286 : #endif
2287 : #endif
2288 : #if defined(MBEDTLS_CIPHER_MODE_XTS)
2289 : { MBEDTLS_CIPHER_AES_128_XTS, &aes_128_xts_info },
2290 : #if !defined(MBEDTLS_AES_ONLY_128_BIT_KEY_LENGTH)
2291 : { MBEDTLS_CIPHER_AES_256_XTS, &aes_256_xts_info },
2292 : #endif
2293 : #endif
2294 : #endif /* MBEDTLS_AES_C */
2295 : #if defined(MBEDTLS_CIPHER_HAVE_GCM_AES_VIA_LEGACY_OR_USE_PSA)
2296 : { MBEDTLS_CIPHER_AES_128_GCM, &aes_128_gcm_info },
2297 : #if !defined(MBEDTLS_AES_ONLY_128_BIT_KEY_LENGTH)
2298 : { MBEDTLS_CIPHER_AES_192_GCM, &aes_192_gcm_info },
2299 : { MBEDTLS_CIPHER_AES_256_GCM, &aes_256_gcm_info },
2300 : #endif
2301 : #endif
2302 : #if defined(MBEDTLS_CIPHER_HAVE_CCM_AES_VIA_LEGACY_OR_USE_PSA)
2303 : { MBEDTLS_CIPHER_AES_128_CCM, &aes_128_ccm_info },
2304 : #if !defined(MBEDTLS_AES_ONLY_128_BIT_KEY_LENGTH)
2305 : { MBEDTLS_CIPHER_AES_192_CCM, &aes_192_ccm_info },
2306 : { MBEDTLS_CIPHER_AES_256_CCM, &aes_256_ccm_info },
2307 : #endif
2308 : #endif
2309 : #if defined(MBEDTLS_CIPHER_HAVE_CCM_STAR_NO_TAG_AES_VIA_LEGACY_OR_USE_PSA)
2310 : { MBEDTLS_CIPHER_AES_128_CCM_STAR_NO_TAG, &aes_128_ccm_star_no_tag_info },
2311 : #if !defined(MBEDTLS_AES_ONLY_128_BIT_KEY_LENGTH)
2312 : { MBEDTLS_CIPHER_AES_192_CCM_STAR_NO_TAG, &aes_192_ccm_star_no_tag_info },
2313 : { MBEDTLS_CIPHER_AES_256_CCM_STAR_NO_TAG, &aes_256_ccm_star_no_tag_info },
2314 : #endif
2315 : #endif
2316 :
2317 : #if defined(MBEDTLS_CAMELLIA_C)
2318 : { MBEDTLS_CIPHER_CAMELLIA_128_ECB, &camellia_128_ecb_info },
2319 : { MBEDTLS_CIPHER_CAMELLIA_192_ECB, &camellia_192_ecb_info },
2320 : { MBEDTLS_CIPHER_CAMELLIA_256_ECB, &camellia_256_ecb_info },
2321 : #if defined(MBEDTLS_CIPHER_MODE_CBC)
2322 : { MBEDTLS_CIPHER_CAMELLIA_128_CBC, &camellia_128_cbc_info },
2323 : { MBEDTLS_CIPHER_CAMELLIA_192_CBC, &camellia_192_cbc_info },
2324 : { MBEDTLS_CIPHER_CAMELLIA_256_CBC, &camellia_256_cbc_info },
2325 : #endif
2326 : #if defined(MBEDTLS_CIPHER_MODE_CFB)
2327 : { MBEDTLS_CIPHER_CAMELLIA_128_CFB128, &camellia_128_cfb128_info },
2328 : { MBEDTLS_CIPHER_CAMELLIA_192_CFB128, &camellia_192_cfb128_info },
2329 : { MBEDTLS_CIPHER_CAMELLIA_256_CFB128, &camellia_256_cfb128_info },
2330 : #endif
2331 : #if defined(MBEDTLS_CIPHER_MODE_CTR)
2332 : { MBEDTLS_CIPHER_CAMELLIA_128_CTR, &camellia_128_ctr_info },
2333 : { MBEDTLS_CIPHER_CAMELLIA_192_CTR, &camellia_192_ctr_info },
2334 : { MBEDTLS_CIPHER_CAMELLIA_256_CTR, &camellia_256_ctr_info },
2335 : #endif
2336 : #if defined(MBEDTLS_GCM_C)
2337 : { MBEDTLS_CIPHER_CAMELLIA_128_GCM, &camellia_128_gcm_info },
2338 : { MBEDTLS_CIPHER_CAMELLIA_192_GCM, &camellia_192_gcm_info },
2339 : { MBEDTLS_CIPHER_CAMELLIA_256_GCM, &camellia_256_gcm_info },
2340 : #endif
2341 : #if defined(MBEDTLS_CCM_C)
2342 : { MBEDTLS_CIPHER_CAMELLIA_128_CCM, &camellia_128_ccm_info },
2343 : { MBEDTLS_CIPHER_CAMELLIA_192_CCM, &camellia_192_ccm_info },
2344 : { MBEDTLS_CIPHER_CAMELLIA_256_CCM, &camellia_256_ccm_info },
2345 : { MBEDTLS_CIPHER_CAMELLIA_128_CCM_STAR_NO_TAG, &camellia_128_ccm_star_no_tag_info },
2346 : { MBEDTLS_CIPHER_CAMELLIA_192_CCM_STAR_NO_TAG, &camellia_192_ccm_star_no_tag_info },
2347 : { MBEDTLS_CIPHER_CAMELLIA_256_CCM_STAR_NO_TAG, &camellia_256_ccm_star_no_tag_info },
2348 : #endif
2349 : #endif /* MBEDTLS_CAMELLIA_C */
2350 :
2351 : #if defined(MBEDTLS_ARIA_C)
2352 : { MBEDTLS_CIPHER_ARIA_128_ECB, &aria_128_ecb_info },
2353 : { MBEDTLS_CIPHER_ARIA_192_ECB, &aria_192_ecb_info },
2354 : { MBEDTLS_CIPHER_ARIA_256_ECB, &aria_256_ecb_info },
2355 : #if defined(MBEDTLS_CIPHER_MODE_CBC)
2356 : { MBEDTLS_CIPHER_ARIA_128_CBC, &aria_128_cbc_info },
2357 : { MBEDTLS_CIPHER_ARIA_192_CBC, &aria_192_cbc_info },
2358 : { MBEDTLS_CIPHER_ARIA_256_CBC, &aria_256_cbc_info },
2359 : #endif
2360 : #if defined(MBEDTLS_CIPHER_MODE_CFB)
2361 : { MBEDTLS_CIPHER_ARIA_128_CFB128, &aria_128_cfb128_info },
2362 : { MBEDTLS_CIPHER_ARIA_192_CFB128, &aria_192_cfb128_info },
2363 : { MBEDTLS_CIPHER_ARIA_256_CFB128, &aria_256_cfb128_info },
2364 : #endif
2365 : #if defined(MBEDTLS_CIPHER_MODE_CTR)
2366 : { MBEDTLS_CIPHER_ARIA_128_CTR, &aria_128_ctr_info },
2367 : { MBEDTLS_CIPHER_ARIA_192_CTR, &aria_192_ctr_info },
2368 : { MBEDTLS_CIPHER_ARIA_256_CTR, &aria_256_ctr_info },
2369 : #endif
2370 : #if defined(MBEDTLS_GCM_C)
2371 : { MBEDTLS_CIPHER_ARIA_128_GCM, &aria_128_gcm_info },
2372 : { MBEDTLS_CIPHER_ARIA_192_GCM, &aria_192_gcm_info },
2373 : { MBEDTLS_CIPHER_ARIA_256_GCM, &aria_256_gcm_info },
2374 : #endif
2375 : #if defined(MBEDTLS_CCM_C)
2376 : { MBEDTLS_CIPHER_ARIA_128_CCM, &aria_128_ccm_info },
2377 : { MBEDTLS_CIPHER_ARIA_192_CCM, &aria_192_ccm_info },
2378 : { MBEDTLS_CIPHER_ARIA_256_CCM, &aria_256_ccm_info },
2379 : { MBEDTLS_CIPHER_ARIA_128_CCM_STAR_NO_TAG, &aria_128_ccm_star_no_tag_info },
2380 : { MBEDTLS_CIPHER_ARIA_192_CCM_STAR_NO_TAG, &aria_192_ccm_star_no_tag_info },
2381 : { MBEDTLS_CIPHER_ARIA_256_CCM_STAR_NO_TAG, &aria_256_ccm_star_no_tag_info },
2382 : #endif
2383 : #endif /* MBEDTLS_ARIA_C */
2384 :
2385 : #if defined(MBEDTLS_DES_C)
2386 : { MBEDTLS_CIPHER_DES_ECB, &des_ecb_info },
2387 : { MBEDTLS_CIPHER_DES_EDE_ECB, &des_ede_ecb_info },
2388 : { MBEDTLS_CIPHER_DES_EDE3_ECB, &des_ede3_ecb_info },
2389 : #if defined(MBEDTLS_CIPHER_MODE_CBC)
2390 : { MBEDTLS_CIPHER_DES_CBC, &des_cbc_info },
2391 : { MBEDTLS_CIPHER_DES_EDE_CBC, &des_ede_cbc_info },
2392 : { MBEDTLS_CIPHER_DES_EDE3_CBC, &des_ede3_cbc_info },
2393 : #endif
2394 : #endif /* MBEDTLS_DES_C */
2395 :
2396 : #if defined(MBEDTLS_CHACHA20_C)
2397 : { MBEDTLS_CIPHER_CHACHA20, &chacha20_info },
2398 : #endif
2399 :
2400 : #if defined(MBEDTLS_CHACHAPOLY_C)
2401 : { MBEDTLS_CIPHER_CHACHA20_POLY1305, &chachapoly_info },
2402 : #endif
2403 :
2404 : #if defined(MBEDTLS_NIST_KW_C)
2405 : { MBEDTLS_CIPHER_AES_128_KW, &aes_128_nist_kw_info },
2406 : #if !defined(MBEDTLS_AES_ONLY_128_BIT_KEY_LENGTH)
2407 : { MBEDTLS_CIPHER_AES_192_KW, &aes_192_nist_kw_info },
2408 : { MBEDTLS_CIPHER_AES_256_KW, &aes_256_nist_kw_info },
2409 : #endif
2410 : { MBEDTLS_CIPHER_AES_128_KWP, &aes_128_nist_kwp_info },
2411 : #if !defined(MBEDTLS_AES_ONLY_128_BIT_KEY_LENGTH)
2412 : { MBEDTLS_CIPHER_AES_192_KWP, &aes_192_nist_kwp_info },
2413 : { MBEDTLS_CIPHER_AES_256_KWP, &aes_256_nist_kwp_info },
2414 : #endif
2415 : #endif
2416 :
2417 : #if defined(MBEDTLS_CIPHER_NULL_CIPHER)
2418 : { MBEDTLS_CIPHER_NULL, &null_cipher_info },
2419 : #endif /* MBEDTLS_CIPHER_NULL_CIPHER */
2420 :
2421 : { MBEDTLS_CIPHER_NONE, NULL }
2422 : };
2423 :
2424 : #define NUM_CIPHERS (sizeof(mbedtls_cipher_definitions) / \
2425 : sizeof(mbedtls_cipher_definitions[0]))
2426 : int mbedtls_cipher_supported[NUM_CIPHERS];
2427 :
2428 : const mbedtls_cipher_base_t *mbedtls_cipher_base_lookup_table[] = {
2429 : #if defined(MBEDTLS_AES_C)
2430 : [MBEDTLS_CIPHER_BASE_INDEX_AES] = &aes_info,
2431 : #endif
2432 : #if defined(MBEDTLS_ARIA_C)
2433 : [MBEDTLS_CIPHER_BASE_INDEX_ARIA] = &aria_info,
2434 : #endif
2435 : #if defined(MBEDTLS_CAMELLIA_C)
2436 : [MBEDTLS_CIPHER_BASE_INDEX_CAMELLIA] = &camellia_info,
2437 : #endif
2438 : #if defined(MBEDTLS_CIPHER_HAVE_CCM_AES_VIA_LEGACY_OR_USE_PSA)
2439 : [MBEDTLS_CIPHER_BASE_INDEX_CCM_AES] = &ccm_aes_info,
2440 : #endif
2441 : #if defined(MBEDTLS_CCM_C) && defined(MBEDTLS_ARIA_C)
2442 : [MBEDTLS_CIPHER_BASE_INDEX_CCM_ARIA] = &ccm_aria_info,
2443 : #endif
2444 : #if defined(MBEDTLS_CCM_C) && defined(MBEDTLS_CAMELLIA_C)
2445 : [MBEDTLS_CIPHER_BASE_INDEX_CCM_CAMELLIA] = &ccm_camellia_info,
2446 : #endif
2447 : #if defined(MBEDTLS_CHACHA20_C)
2448 : [MBEDTLS_CIPHER_BASE_INDEX_CHACHA20_BASE] = &chacha20_base_info,
2449 : #endif
2450 : #if defined(MBEDTLS_CHACHAPOLY_C)
2451 : [MBEDTLS_CIPHER_BASE_INDEX_CHACHAPOLY_BASE] = &chachapoly_base_info,
2452 : #endif
2453 : #if defined(MBEDTLS_DES_C)
2454 : [MBEDTLS_CIPHER_BASE_INDEX_DES_EDE3] = &des_ede3_info,
2455 : #endif
2456 : #if defined(MBEDTLS_DES_C)
2457 : [MBEDTLS_CIPHER_BASE_INDEX_DES_EDE] = &des_ede_info,
2458 : #endif
2459 : #if defined(MBEDTLS_DES_C)
2460 : [MBEDTLS_CIPHER_BASE_INDEX_DES] = &des_info,
2461 : #endif
2462 : #if defined(MBEDTLS_CIPHER_HAVE_GCM_AES_VIA_LEGACY_OR_USE_PSA)
2463 : [MBEDTLS_CIPHER_BASE_INDEX_GCM_AES] = &gcm_aes_info,
2464 : #endif
2465 : #if defined(MBEDTLS_GCM_C) && defined(MBEDTLS_ARIA_C)
2466 : [MBEDTLS_CIPHER_BASE_INDEX_GCM_ARIA] = &gcm_aria_info,
2467 : #endif
2468 : #if defined(MBEDTLS_GCM_C) && defined(MBEDTLS_CAMELLIA_C)
2469 : [MBEDTLS_CIPHER_BASE_INDEX_GCM_CAMELLIA] = &gcm_camellia_info,
2470 : #endif
2471 : #if defined(MBEDTLS_NIST_KW_C)
2472 : [MBEDTLS_CIPHER_BASE_INDEX_KW_AES] = &kw_aes_info,
2473 : #endif
2474 : #if defined(MBEDTLS_CIPHER_NULL_CIPHER)
2475 : [MBEDTLS_CIPHER_BASE_INDEX_NULL_BASE] = &null_base_info,
2476 : #endif
2477 : #if defined(MBEDTLS_CIPHER_MODE_XTS) && defined(MBEDTLS_AES_C)
2478 : [MBEDTLS_CIPHER_BASE_INDEX_XTS_AES] = &xts_aes_info
2479 : #endif
2480 : };
2481 :
2482 : #endif /* MBEDTLS_CIPHER_C */
|
