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