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