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