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