This Trac instance is not used for development anymore!

We migrated our development workflow to git and Gitea.
To test the future redirection, replace trac by ariadne in the page URL.

source: ps/trunk/build/premake/premake5/contrib/mbedtls/library/cipher_wrap.c

Last change on this file was 20366, checked in by Itms, 7 years ago

Alpha 12 version of Premake 5, including prebuilt binary for Windows.
Directly taken from ​https://premake.github.io/.

Refs #3729.
File size: 35.2 KB
Line 
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: Apache-2.0
10 *
11 * Licensed under the Apache License, Version 2.0 (the "License"); you may
12 * not use this file except in compliance with the License.
13 * You may obtain a copy of the License at
14 *
15 * http://www.apache.org/licenses/LICENSE-2.0
16 *
17 * Unless required by applicable law or agreed to in writing, software
18 * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
19 * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
20 * See the License for the specific language governing permissions and
21 * limitations under the License.
22 *
23 * This file is part of mbed TLS (https://tls.mbed.org)
24 */
25
26#if !defined(MBEDTLS_CONFIG_FILE)
27#include "mbedtls/config.h"
28#else
29#include MBEDTLS_CONFIG_FILE
30#endif
31
32#if defined(MBEDTLS_CIPHER_C)
33
34#include "mbedtls/cipher_internal.h"
35
36#if defined(MBEDTLS_AES_C)
37#include "mbedtls/aes.h"
38#endif
39
40#if defined(MBEDTLS_ARC4_C)
41#include "mbedtls/arc4.h"
42#endif
43
44#if defined(MBEDTLS_CAMELLIA_C)
45#include "mbedtls/camellia.h"
46#endif
47
48#if defined(MBEDTLS_DES_C)
49#include "mbedtls/des.h"
50#endif
51
52#if defined(MBEDTLS_BLOWFISH_C)
53#include "mbedtls/blowfish.h"
54#endif
55
56#if defined(MBEDTLS_GCM_C)
57#include "mbedtls/gcm.h"
58#endif
59
60#if defined(MBEDTLS_CCM_C)
61#include "mbedtls/ccm.h"
62#endif
63
64#if defined(MBEDTLS_CIPHER_NULL_CIPHER)
65#include <string.h>
66#endif
67
68#if defined(MBEDTLS_PLATFORM_C)
69#include "mbedtls/platform.h"
70#else
71#include <stdlib.h>
72#define mbedtls_calloc calloc
73#define mbedtls_free free
74#endif
75
76#if defined(MBEDTLS_GCM_C)
77/* shared by all GCM ciphers */
78static void *gcm_ctx_alloc( void )
79{
80 void *ctx = mbedtls_calloc( 1, sizeof( mbedtls_gcm_context ) );
81
82 if( ctx != NULL )
83 mbedtls_gcm_init( (mbedtls_gcm_context *) ctx );
84
85 return( ctx );
86}
87
88static void gcm_ctx_free( void *ctx )
89{
90 mbedtls_gcm_free( ctx );
91 mbedtls_free( ctx );
92}
93#endif /* MBEDTLS_GCM_C */
94
95#if defined(MBEDTLS_CCM_C)
96/* shared by all CCM ciphers */
97static void *ccm_ctx_alloc( void )
98{
99 void *ctx = mbedtls_calloc( 1, sizeof( mbedtls_ccm_context ) );
100
101 if( ctx != NULL )
102 mbedtls_ccm_init( (mbedtls_ccm_context *) ctx );
103
104 return( ctx );
105}
106
107static void ccm_ctx_free( void *ctx )
108{
109 mbedtls_ccm_free( ctx );
110 mbedtls_free( ctx );
111}
112#endif /* MBEDTLS_CCM_C */
113
114#if defined(MBEDTLS_AES_C)
115
116static int aes_crypt_ecb_wrap( void *ctx, mbedtls_operation_t operation,
117 const unsigned char *input, unsigned char *output )
118{
119 return mbedtls_aes_crypt_ecb( (mbedtls_aes_context *) ctx, operation, input, output );
120}
121
122#if defined(MBEDTLS_CIPHER_MODE_CBC)
123static int aes_crypt_cbc_wrap( void *ctx, mbedtls_operation_t operation, size_t length,
124 unsigned char *iv, const unsigned char *input, unsigned char *output )
125{
126 return mbedtls_aes_crypt_cbc( (mbedtls_aes_context *) ctx, operation, length, iv, input,
127 output );
128}
129#endif /* MBEDTLS_CIPHER_MODE_CBC */
130
131#if defined(MBEDTLS_CIPHER_MODE_CFB)
132static int aes_crypt_cfb128_wrap( void *ctx, mbedtls_operation_t operation,
133 size_t length, size_t *iv_off, unsigned char *iv,
134 const unsigned char *input, unsigned char *output )
135{
136 return mbedtls_aes_crypt_cfb128( (mbedtls_aes_context *) ctx, operation, length, iv_off, iv,
137 input, output );
138}
139#endif /* MBEDTLS_CIPHER_MODE_CFB */
140
141#if defined(MBEDTLS_CIPHER_MODE_CTR)
142static int aes_crypt_ctr_wrap( void *ctx, size_t length, size_t *nc_off,
143 unsigned char *nonce_counter, unsigned char *stream_block,
144 const unsigned char *input, unsigned char *output )
145{
146 return mbedtls_aes_crypt_ctr( (mbedtls_aes_context *) ctx, length, nc_off, nonce_counter,
147 stream_block, input, output );
148}
149#endif /* MBEDTLS_CIPHER_MODE_CTR */
150
151static int aes_setkey_dec_wrap( void *ctx, const unsigned char *key,
152 unsigned int key_bitlen )
153{
154 return mbedtls_aes_setkey_dec( (mbedtls_aes_context *) ctx, key, key_bitlen );
155}
156
157static int aes_setkey_enc_wrap( void *ctx, const unsigned char *key,
158 unsigned int key_bitlen )
159{
160 return mbedtls_aes_setkey_enc( (mbedtls_aes_context *) ctx, key, key_bitlen );
161}
162
163static void * aes_ctx_alloc( void )
164{
165 mbedtls_aes_context *aes = mbedtls_calloc( 1, sizeof( mbedtls_aes_context ) );
166
167 if( aes == NULL )
168 return( NULL );
169
170 mbedtls_aes_init( aes );
171
172 return( aes );
173}
174
175static void aes_ctx_free( void *ctx )
176{
177 mbedtls_aes_free( (mbedtls_aes_context *) ctx );
178 mbedtls_free( ctx );
179}
180
181static const mbedtls_cipher_base_t aes_info = {
182 MBEDTLS_CIPHER_ID_AES,
183 aes_crypt_ecb_wrap,
184#if defined(MBEDTLS_CIPHER_MODE_CBC)
185 aes_crypt_cbc_wrap,
186#endif
187#if defined(MBEDTLS_CIPHER_MODE_CFB)
188 aes_crypt_cfb128_wrap,
189#endif
190#if defined(MBEDTLS_CIPHER_MODE_CTR)
191 aes_crypt_ctr_wrap,
192#endif
193#if defined(MBEDTLS_CIPHER_MODE_STREAM)
194 NULL,
195#endif
196 aes_setkey_enc_wrap,
197 aes_setkey_dec_wrap,
198 aes_ctx_alloc,
199 aes_ctx_free
200};
201
202static const mbedtls_cipher_info_t aes_128_ecb_info = {
203 MBEDTLS_CIPHER_AES_128_ECB,
204 MBEDTLS_MODE_ECB,
205 128,
206 "AES-128-ECB",
207 16,
208 0,
209 16,
210 &aes_info
211};
212
213static const mbedtls_cipher_info_t aes_192_ecb_info = {
214 MBEDTLS_CIPHER_AES_192_ECB,
215 MBEDTLS_MODE_ECB,
216 192,
217 "AES-192-ECB",
218 16,
219 0,
220 16,
221 &aes_info
222};
223
224static const mbedtls_cipher_info_t aes_256_ecb_info = {
225 MBEDTLS_CIPHER_AES_256_ECB,
226 MBEDTLS_MODE_ECB,
227 256,
228 "AES-256-ECB",
229 16,
230 0,
231 16,
232 &aes_info
233};
234
235#if defined(MBEDTLS_CIPHER_MODE_CBC)
236static const mbedtls_cipher_info_t aes_128_cbc_info = {
237 MBEDTLS_CIPHER_AES_128_CBC,
238 MBEDTLS_MODE_CBC,
239 128,
240 "AES-128-CBC",
241 16,
242 0,
243 16,
244 &aes_info
245};
246
247static const mbedtls_cipher_info_t aes_192_cbc_info = {
248 MBEDTLS_CIPHER_AES_192_CBC,
249 MBEDTLS_MODE_CBC,
250 192,
251 "AES-192-CBC",
252 16,
253 0,
254 16,
255 &aes_info
256};
257
258static const mbedtls_cipher_info_t aes_256_cbc_info = {
259 MBEDTLS_CIPHER_AES_256_CBC,
260 MBEDTLS_MODE_CBC,
261 256,
262 "AES-256-CBC",
263 16,
264 0,
265 16,
266 &aes_info
267};
268#endif /* MBEDTLS_CIPHER_MODE_CBC */
269
270#if defined(MBEDTLS_CIPHER_MODE_CFB)
271static const mbedtls_cipher_info_t aes_128_cfb128_info = {
272 MBEDTLS_CIPHER_AES_128_CFB128,
273 MBEDTLS_MODE_CFB,
274 128,
275 "AES-128-CFB128",
276 16,
277 0,
278 16,
279 &aes_info
280};
281
282static const mbedtls_cipher_info_t aes_192_cfb128_info = {
283 MBEDTLS_CIPHER_AES_192_CFB128,
284 MBEDTLS_MODE_CFB,
285 192,
286 "AES-192-CFB128",
287 16,
288 0,
289 16,
290 &aes_info
291};
292
293static const mbedtls_cipher_info_t aes_256_cfb128_info = {
294 MBEDTLS_CIPHER_AES_256_CFB128,
295 MBEDTLS_MODE_CFB,
296 256,
297 "AES-256-CFB128",
298 16,
299 0,
300 16,
301 &aes_info
302};
303#endif /* MBEDTLS_CIPHER_MODE_CFB */
304
305#if defined(MBEDTLS_CIPHER_MODE_CTR)
306static const mbedtls_cipher_info_t aes_128_ctr_info = {
307 MBEDTLS_CIPHER_AES_128_CTR,
308 MBEDTLS_MODE_CTR,
309 128,
310 "AES-128-CTR",
311 16,
312 0,
313 16,
314 &aes_info
315};
316
317static const mbedtls_cipher_info_t aes_192_ctr_info = {
318 MBEDTLS_CIPHER_AES_192_CTR,
319 MBEDTLS_MODE_CTR,
320 192,
321 "AES-192-CTR",
322 16,
323 0,
324 16,
325 &aes_info
326};
327
328static const mbedtls_cipher_info_t aes_256_ctr_info = {
329 MBEDTLS_CIPHER_AES_256_CTR,
330 MBEDTLS_MODE_CTR,
331 256,
332 "AES-256-CTR",
333 16,
334 0,
335 16,
336 &aes_info
337};
338#endif /* MBEDTLS_CIPHER_MODE_CTR */
339
340#if defined(MBEDTLS_GCM_C)
341static int gcm_aes_setkey_wrap( void *ctx, const unsigned char *key,
342 unsigned int key_bitlen )
343{
344 return mbedtls_gcm_setkey( (mbedtls_gcm_context *) ctx, MBEDTLS_CIPHER_ID_AES,
345 key, key_bitlen );
346}
347
348static const mbedtls_cipher_base_t gcm_aes_info = {
349 MBEDTLS_CIPHER_ID_AES,
350 NULL,
351#if defined(MBEDTLS_CIPHER_MODE_CBC)
352 NULL,
353#endif
354#if defined(MBEDTLS_CIPHER_MODE_CFB)
355 NULL,
356#endif
357#if defined(MBEDTLS_CIPHER_MODE_CTR)
358 NULL,
359#endif
360#if defined(MBEDTLS_CIPHER_MODE_STREAM)
361 NULL,
362#endif
363 gcm_aes_setkey_wrap,
364 gcm_aes_setkey_wrap,
365 gcm_ctx_alloc,
366 gcm_ctx_free,
367};
368
369static const mbedtls_cipher_info_t aes_128_gcm_info = {
370 MBEDTLS_CIPHER_AES_128_GCM,
371 MBEDTLS_MODE_GCM,
372 128,
373 "AES-128-GCM",
374 12,
375 MBEDTLS_CIPHER_VARIABLE_IV_LEN,
376 16,
377 &gcm_aes_info
378};
379
380static const mbedtls_cipher_info_t aes_192_gcm_info = {
381 MBEDTLS_CIPHER_AES_192_GCM,
382 MBEDTLS_MODE_GCM,
383 192,
384 "AES-192-GCM",
385 12,
386 MBEDTLS_CIPHER_VARIABLE_IV_LEN,
387 16,
388 &gcm_aes_info
389};
390
391static const mbedtls_cipher_info_t aes_256_gcm_info = {
392 MBEDTLS_CIPHER_AES_256_GCM,
393 MBEDTLS_MODE_GCM,
394 256,
395 "AES-256-GCM",
396 12,
397 MBEDTLS_CIPHER_VARIABLE_IV_LEN,
398 16,
399 &gcm_aes_info
400};
401#endif /* MBEDTLS_GCM_C */
402
403#if defined(MBEDTLS_CCM_C)
404static int ccm_aes_setkey_wrap( void *ctx, const unsigned char *key,
405 unsigned int key_bitlen )
406{
407 return mbedtls_ccm_setkey( (mbedtls_ccm_context *) ctx, MBEDTLS_CIPHER_ID_AES,
408 key, key_bitlen );
409}
410
411static const mbedtls_cipher_base_t ccm_aes_info = {
412 MBEDTLS_CIPHER_ID_AES,
413 NULL,
414#if defined(MBEDTLS_CIPHER_MODE_CBC)
415 NULL,
416#endif
417#if defined(MBEDTLS_CIPHER_MODE_CFB)
418 NULL,
419#endif
420#if defined(MBEDTLS_CIPHER_MODE_CTR)
421 NULL,
422#endif
423#if defined(MBEDTLS_CIPHER_MODE_STREAM)
424 NULL,
425#endif
426 ccm_aes_setkey_wrap,
427 ccm_aes_setkey_wrap,
428 ccm_ctx_alloc,
429 ccm_ctx_free,
430};
431
432static const mbedtls_cipher_info_t aes_128_ccm_info = {
433 MBEDTLS_CIPHER_AES_128_CCM,
434 MBEDTLS_MODE_CCM,
435 128,
436 "AES-128-CCM",
437 12,
438 MBEDTLS_CIPHER_VARIABLE_IV_LEN,
439 16,
440 &ccm_aes_info
441};
442
443static const mbedtls_cipher_info_t aes_192_ccm_info = {
444 MBEDTLS_CIPHER_AES_192_CCM,
445 MBEDTLS_MODE_CCM,
446 192,
447 "AES-192-CCM",
448 12,
449 MBEDTLS_CIPHER_VARIABLE_IV_LEN,
450 16,
451 &ccm_aes_info
452};
453
454static const mbedtls_cipher_info_t aes_256_ccm_info = {
455 MBEDTLS_CIPHER_AES_256_CCM,
456 MBEDTLS_MODE_CCM,
457 256,
458 "AES-256-CCM",
459 12,
460 MBEDTLS_CIPHER_VARIABLE_IV_LEN,
461 16,
462 &ccm_aes_info
463};
464#endif /* MBEDTLS_CCM_C */
465
466#endif /* MBEDTLS_AES_C */
467
468#if defined(MBEDTLS_CAMELLIA_C)
469
470static int camellia_crypt_ecb_wrap( void *ctx, mbedtls_operation_t operation,
471 const unsigned char *input, unsigned char *output )
472{
473 return mbedtls_camellia_crypt_ecb( (mbedtls_camellia_context *) ctx, operation, input,
474 output );
475}
476
477#if defined(MBEDTLS_CIPHER_MODE_CBC)
478static int camellia_crypt_cbc_wrap( void *ctx, mbedtls_operation_t operation,
479 size_t length, unsigned char *iv,
480 const unsigned char *input, unsigned char *output )
481{
482 return mbedtls_camellia_crypt_cbc( (mbedtls_camellia_context *) ctx, operation, length, iv,
483 input, output );
484}
485#endif /* MBEDTLS_CIPHER_MODE_CBC */
486
487#if defined(MBEDTLS_CIPHER_MODE_CFB)
488static int camellia_crypt_cfb128_wrap( void *ctx, mbedtls_operation_t operation,
489 size_t length, size_t *iv_off, unsigned char *iv,
490 const unsigned char *input, unsigned char *output )
491{
492 return mbedtls_camellia_crypt_cfb128( (mbedtls_camellia_context *) ctx, operation, length,
493 iv_off, iv, input, output );
494}
495#endif /* MBEDTLS_CIPHER_MODE_CFB */
496
497#if defined(MBEDTLS_CIPHER_MODE_CTR)
498static int camellia_crypt_ctr_wrap( void *ctx, size_t length, size_t *nc_off,
499 unsigned char *nonce_counter, unsigned char *stream_block,
500 const unsigned char *input, unsigned char *output )
501{
502 return mbedtls_camellia_crypt_ctr( (mbedtls_camellia_context *) ctx, length, nc_off,
503 nonce_counter, stream_block, input, output );
504}
505#endif /* MBEDTLS_CIPHER_MODE_CTR */
506
507static int camellia_setkey_dec_wrap( void *ctx, const unsigned char *key,
508 unsigned int key_bitlen )
509{
510 return mbedtls_camellia_setkey_dec( (mbedtls_camellia_context *) ctx, key, key_bitlen );
511}
512
513static int camellia_setkey_enc_wrap( void *ctx, const unsigned char *key,
514 unsigned int key_bitlen )
515{
516 return mbedtls_camellia_setkey_enc( (mbedtls_camellia_context *) ctx, key, key_bitlen );
517}
518
519static void * camellia_ctx_alloc( void )
520{
521 mbedtls_camellia_context *ctx;
522 ctx = mbedtls_calloc( 1, sizeof( mbedtls_camellia_context ) );
523
524 if( ctx == NULL )
525 return( NULL );
526
527 mbedtls_camellia_init( ctx );
528
529 return( ctx );
530}
531
532static void camellia_ctx_free( void *ctx )
533{
534 mbedtls_camellia_free( (mbedtls_camellia_context *) ctx );
535 mbedtls_free( ctx );
536}
537
538static const mbedtls_cipher_base_t camellia_info = {
539 MBEDTLS_CIPHER_ID_CAMELLIA,
540 camellia_crypt_ecb_wrap,
541#if defined(MBEDTLS_CIPHER_MODE_CBC)
542 camellia_crypt_cbc_wrap,
543#endif
544#if defined(MBEDTLS_CIPHER_MODE_CFB)
545 camellia_crypt_cfb128_wrap,
546#endif
547#if defined(MBEDTLS_CIPHER_MODE_CTR)
548 camellia_crypt_ctr_wrap,
549#endif
550#if defined(MBEDTLS_CIPHER_MODE_STREAM)
551 NULL,
552#endif
553 camellia_setkey_enc_wrap,
554 camellia_setkey_dec_wrap,
555 camellia_ctx_alloc,
556 camellia_ctx_free
557};
558
559static const mbedtls_cipher_info_t camellia_128_ecb_info = {
560 MBEDTLS_CIPHER_CAMELLIA_128_ECB,
561 MBEDTLS_MODE_ECB,
562 128,
563 "CAMELLIA-128-ECB",
564 16,
565 0,
566 16,
567 &camellia_info
568};
569
570static const mbedtls_cipher_info_t camellia_192_ecb_info = {
571 MBEDTLS_CIPHER_CAMELLIA_192_ECB,
572 MBEDTLS_MODE_ECB,
573 192,
574 "CAMELLIA-192-ECB",
575 16,
576 0,
577 16,
578 &camellia_info
579};
580
581static const mbedtls_cipher_info_t camellia_256_ecb_info = {
582 MBEDTLS_CIPHER_CAMELLIA_256_ECB,
583 MBEDTLS_MODE_ECB,
584 256,
585 "CAMELLIA-256-ECB",
586 16,
587 0,
588 16,
589 &camellia_info
590};
591
592#if defined(MBEDTLS_CIPHER_MODE_CBC)
593static const mbedtls_cipher_info_t camellia_128_cbc_info = {
594 MBEDTLS_CIPHER_CAMELLIA_128_CBC,
595 MBEDTLS_MODE_CBC,
596 128,
597 "CAMELLIA-128-CBC",
598 16,
599 0,
600 16,
601 &camellia_info
602};
603
604static const mbedtls_cipher_info_t camellia_192_cbc_info = {
605 MBEDTLS_CIPHER_CAMELLIA_192_CBC,
606 MBEDTLS_MODE_CBC,
607 192,
608 "CAMELLIA-192-CBC",
609 16,
610 0,
611 16,
612 &camellia_info
613};
614
615static const mbedtls_cipher_info_t camellia_256_cbc_info = {
616 MBEDTLS_CIPHER_CAMELLIA_256_CBC,
617 MBEDTLS_MODE_CBC,
618 256,
619 "CAMELLIA-256-CBC",
620 16,
621 0,
622 16,
623 &camellia_info
624};
625#endif /* MBEDTLS_CIPHER_MODE_CBC */
626
627#if defined(MBEDTLS_CIPHER_MODE_CFB)
628static const mbedtls_cipher_info_t camellia_128_cfb128_info = {
629 MBEDTLS_CIPHER_CAMELLIA_128_CFB128,
630 MBEDTLS_MODE_CFB,
631 128,
632 "CAMELLIA-128-CFB128",
633 16,
634 0,
635 16,
636 &camellia_info
637};
638
639static const mbedtls_cipher_info_t camellia_192_cfb128_info = {
640 MBEDTLS_CIPHER_CAMELLIA_192_CFB128,
641 MBEDTLS_MODE_CFB,
642 192,
643 "CAMELLIA-192-CFB128",
644 16,
645 0,
646 16,
647 &camellia_info
648};
649
650static const mbedtls_cipher_info_t camellia_256_cfb128_info = {
651 MBEDTLS_CIPHER_CAMELLIA_256_CFB128,
652 MBEDTLS_MODE_CFB,
653 256,
654 "CAMELLIA-256-CFB128",
655 16,
656 0,
657 16,
658 &camellia_info
659};
660#endif /* MBEDTLS_CIPHER_MODE_CFB */
661
662#if defined(MBEDTLS_CIPHER_MODE_CTR)
663static const mbedtls_cipher_info_t camellia_128_ctr_info = {
664 MBEDTLS_CIPHER_CAMELLIA_128_CTR,
665 MBEDTLS_MODE_CTR,
666 128,
667 "CAMELLIA-128-CTR",
668 16,
669 0,
670 16,
671 &camellia_info
672};
673
674static const mbedtls_cipher_info_t camellia_192_ctr_info = {
675 MBEDTLS_CIPHER_CAMELLIA_192_CTR,
676 MBEDTLS_MODE_CTR,
677 192,
678 "CAMELLIA-192-CTR",
679 16,
680 0,
681 16,
682 &camellia_info
683};
684
685static const mbedtls_cipher_info_t camellia_256_ctr_info = {
686 MBEDTLS_CIPHER_CAMELLIA_256_CTR,
687 MBEDTLS_MODE_CTR,
688 256,
689 "CAMELLIA-256-CTR",
690 16,
691 0,
692 16,
693 &camellia_info
694};
695#endif /* MBEDTLS_CIPHER_MODE_CTR */
696
697#if defined(MBEDTLS_GCM_C)
698static int gcm_camellia_setkey_wrap( void *ctx, const unsigned char *key,
699 unsigned int key_bitlen )
700{
701 return mbedtls_gcm_setkey( (mbedtls_gcm_context *) ctx, MBEDTLS_CIPHER_ID_CAMELLIA,
702 key, key_bitlen );
703}
704
705static const mbedtls_cipher_base_t gcm_camellia_info = {
706 MBEDTLS_CIPHER_ID_CAMELLIA,
707 NULL,
708#if defined(MBEDTLS_CIPHER_MODE_CBC)
709 NULL,
710#endif
711#if defined(MBEDTLS_CIPHER_MODE_CFB)
712 NULL,
713#endif
714#if defined(MBEDTLS_CIPHER_MODE_CTR)
715 NULL,
716#endif
717#if defined(MBEDTLS_CIPHER_MODE_STREAM)
718 NULL,
719#endif
720 gcm_camellia_setkey_wrap,
721 gcm_camellia_setkey_wrap,
722 gcm_ctx_alloc,
723 gcm_ctx_free,
724};
725
726static const mbedtls_cipher_info_t camellia_128_gcm_info = {
727 MBEDTLS_CIPHER_CAMELLIA_128_GCM,
728 MBEDTLS_MODE_GCM,
729 128,
730 "CAMELLIA-128-GCM",
731 12,
732 MBEDTLS_CIPHER_VARIABLE_IV_LEN,
733 16,
734 &gcm_camellia_info
735};
736
737static const mbedtls_cipher_info_t camellia_192_gcm_info = {
738 MBEDTLS_CIPHER_CAMELLIA_192_GCM,
739 MBEDTLS_MODE_GCM,
740 192,
741 "CAMELLIA-192-GCM",
742 12,
743 MBEDTLS_CIPHER_VARIABLE_IV_LEN,
744 16,
745 &gcm_camellia_info
746};
747
748static const mbedtls_cipher_info_t camellia_256_gcm_info = {
749 MBEDTLS_CIPHER_CAMELLIA_256_GCM,
750 MBEDTLS_MODE_GCM,
751 256,
752 "CAMELLIA-256-GCM",
753 12,
754 MBEDTLS_CIPHER_VARIABLE_IV_LEN,
755 16,
756 &gcm_camellia_info
757};
758#endif /* MBEDTLS_GCM_C */
759
760#if defined(MBEDTLS_CCM_C)
761static int ccm_camellia_setkey_wrap( void *ctx, const unsigned char *key,
762 unsigned int key_bitlen )
763{
764 return mbedtls_ccm_setkey( (mbedtls_ccm_context *) ctx, MBEDTLS_CIPHER_ID_CAMELLIA,
765 key, key_bitlen );
766}
767
768static const mbedtls_cipher_base_t ccm_camellia_info = {
769 MBEDTLS_CIPHER_ID_CAMELLIA,
770 NULL,
771#if defined(MBEDTLS_CIPHER_MODE_CBC)
772 NULL,
773#endif
774#if defined(MBEDTLS_CIPHER_MODE_CFB)
775 NULL,
776#endif
777#if defined(MBEDTLS_CIPHER_MODE_CTR)
778 NULL,
779#endif
780#if defined(MBEDTLS_CIPHER_MODE_STREAM)
781 NULL,
782#endif
783 ccm_camellia_setkey_wrap,
784 ccm_camellia_setkey_wrap,
785 ccm_ctx_alloc,
786 ccm_ctx_free,
787};
788
789static const mbedtls_cipher_info_t camellia_128_ccm_info = {
790 MBEDTLS_CIPHER_CAMELLIA_128_CCM,
791 MBEDTLS_MODE_CCM,
792 128,
793 "CAMELLIA-128-CCM",
794 12,
795 MBEDTLS_CIPHER_VARIABLE_IV_LEN,
796 16,
797 &ccm_camellia_info
798};
799
800static const mbedtls_cipher_info_t camellia_192_ccm_info = {
801 MBEDTLS_CIPHER_CAMELLIA_192_CCM,
802 MBEDTLS_MODE_CCM,
803 192,
804 "CAMELLIA-192-CCM",
805 12,
806 MBEDTLS_CIPHER_VARIABLE_IV_LEN,
807 16,
808 &ccm_camellia_info
809};
810
811static const mbedtls_cipher_info_t camellia_256_ccm_info = {
812 MBEDTLS_CIPHER_CAMELLIA_256_CCM,
813 MBEDTLS_MODE_CCM,
814 256,
815 "CAMELLIA-256-CCM",
816 12,
817 MBEDTLS_CIPHER_VARIABLE_IV_LEN,
818 16,
819 &ccm_camellia_info
820};
821#endif /* MBEDTLS_CCM_C */
822
823#endif /* MBEDTLS_CAMELLIA_C */
824
825#if defined(MBEDTLS_DES_C)
826
827static int des_crypt_ecb_wrap( void *ctx, mbedtls_operation_t operation,
828 const unsigned char *input, unsigned char *output )
829{
830 ((void) operation);
831 return mbedtls_des_crypt_ecb( (mbedtls_des_context *) ctx, input, output );
832}
833
834static int des3_crypt_ecb_wrap( void *ctx, mbedtls_operation_t operation,
835 const unsigned char *input, unsigned char *output )
836{
837 ((void) operation);
838 return mbedtls_des3_crypt_ecb( (mbedtls_des3_context *) ctx, input, output );
839}
840
841#if defined(MBEDTLS_CIPHER_MODE_CBC)
842static int des_crypt_cbc_wrap( void *ctx, mbedtls_operation_t operation, size_t length,
843 unsigned char *iv, const unsigned char *input, unsigned char *output )
844{
845 return mbedtls_des_crypt_cbc( (mbedtls_des_context *) ctx, operation, length, iv, input,
846 output );
847}
848#endif /* MBEDTLS_CIPHER_MODE_CBC */
849
850#if defined(MBEDTLS_CIPHER_MODE_CBC)
851static int des3_crypt_cbc_wrap( void *ctx, mbedtls_operation_t operation, size_t length,
852 unsigned char *iv, const unsigned char *input, unsigned char *output )
853{
854 return mbedtls_des3_crypt_cbc( (mbedtls_des3_context *) ctx, operation, length, iv, input,
855 output );
856}
857#endif /* MBEDTLS_CIPHER_MODE_CBC */
858
859static int des_setkey_dec_wrap( void *ctx, const unsigned char *key,
860 unsigned int key_bitlen )
861{
862 ((void) key_bitlen);
863
864 return mbedtls_des_setkey_dec( (mbedtls_des_context *) ctx, key );
865}
866
867static int des_setkey_enc_wrap( void *ctx, const unsigned char *key,
868 unsigned int key_bitlen )
869{
870 ((void) key_bitlen);
871
872 return mbedtls_des_setkey_enc( (mbedtls_des_context *) ctx, key );
873}
874
875static int des3_set2key_dec_wrap( void *ctx, const unsigned char *key,
876 unsigned int key_bitlen )
877{
878 ((void) key_bitlen);
879
880 return mbedtls_des3_set2key_dec( (mbedtls_des3_context *) ctx, key );
881}
882
883static int des3_set2key_enc_wrap( void *ctx, const unsigned char *key,
884 unsigned int key_bitlen )
885{
886 ((void) key_bitlen);
887
888 return mbedtls_des3_set2key_enc( (mbedtls_des3_context *) ctx, key );
889}
890
891static int des3_set3key_dec_wrap( void *ctx, const unsigned char *key,
892 unsigned int key_bitlen )
893{
894 ((void) key_bitlen);
895
896 return mbedtls_des3_set3key_dec( (mbedtls_des3_context *) ctx, key );
897}
898
899static int des3_set3key_enc_wrap( void *ctx, const unsigned char *key,
900 unsigned int key_bitlen )
901{
902 ((void) key_bitlen);
903
904 return mbedtls_des3_set3key_enc( (mbedtls_des3_context *) ctx, key );
905}
906
907static void * des_ctx_alloc( void )
908{
909 mbedtls_des_context *des = mbedtls_calloc( 1, sizeof( mbedtls_des_context ) );
910
911 if( des == NULL )
912 return( NULL );
913
914 mbedtls_des_init( des );
915
916 return( des );
917}
918
919static void des_ctx_free( void *ctx )
920{
921 mbedtls_des_free( (mbedtls_des_context *) ctx );
922 mbedtls_free( ctx );
923}
924
925static void * des3_ctx_alloc( void )
926{
927 mbedtls_des3_context *des3;
928 des3 = mbedtls_calloc( 1, sizeof( mbedtls_des3_context ) );
929
930 if( des3 == NULL )
931 return( NULL );
932
933 mbedtls_des3_init( des3 );
934
935 return( des3 );
936}
937
938static void des3_ctx_free( void *ctx )
939{
940 mbedtls_des3_free( (mbedtls_des3_context *) ctx );
941 mbedtls_free( ctx );
942}
943
944static const mbedtls_cipher_base_t des_info = {
945 MBEDTLS_CIPHER_ID_DES,
946 des_crypt_ecb_wrap,
947#if defined(MBEDTLS_CIPHER_MODE_CBC)
948 des_crypt_cbc_wrap,
949#endif
950#if defined(MBEDTLS_CIPHER_MODE_CFB)
951 NULL,
952#endif
953#if defined(MBEDTLS_CIPHER_MODE_CTR)
954 NULL,
955#endif
956#if defined(MBEDTLS_CIPHER_MODE_STREAM)
957 NULL,
958#endif
959 des_setkey_enc_wrap,
960 des_setkey_dec_wrap,
961 des_ctx_alloc,
962 des_ctx_free
963};
964
965static const mbedtls_cipher_info_t des_ecb_info = {
966 MBEDTLS_CIPHER_DES_ECB,
967 MBEDTLS_MODE_ECB,
968 MBEDTLS_KEY_LENGTH_DES,
969 "DES-ECB",
970 8,
971 0,
972 8,
973 &des_info
974};
975
976#if defined(MBEDTLS_CIPHER_MODE_CBC)
977static const mbedtls_cipher_info_t des_cbc_info = {
978 MBEDTLS_CIPHER_DES_CBC,
979 MBEDTLS_MODE_CBC,
980 MBEDTLS_KEY_LENGTH_DES,
981 "DES-CBC",
982 8,
983 0,
984 8,
985 &des_info
986};
987#endif /* MBEDTLS_CIPHER_MODE_CBC */
988
989static const mbedtls_cipher_base_t des_ede_info = {
990 MBEDTLS_CIPHER_ID_DES,
991 des3_crypt_ecb_wrap,
992#if defined(MBEDTLS_CIPHER_MODE_CBC)
993 des3_crypt_cbc_wrap,
994#endif
995#if defined(MBEDTLS_CIPHER_MODE_CFB)
996 NULL,
997#endif
998#if defined(MBEDTLS_CIPHER_MODE_CTR)
999 NULL,
1000#endif
1001#if defined(MBEDTLS_CIPHER_MODE_STREAM)
1002 NULL,
1003#endif
1004 des3_set2key_enc_wrap,
1005 des3_set2key_dec_wrap,
1006 des3_ctx_alloc,
1007 des3_ctx_free
1008};
1009
1010static const mbedtls_cipher_info_t des_ede_ecb_info = {
1011 MBEDTLS_CIPHER_DES_EDE_ECB,
1012 MBEDTLS_MODE_ECB,
1013 MBEDTLS_KEY_LENGTH_DES_EDE,
1014 "DES-EDE-ECB",
1015 8,
1016 0,
1017 8,
1018 &des_ede_info
1019};
1020
1021#if defined(MBEDTLS_CIPHER_MODE_CBC)
1022static const mbedtls_cipher_info_t des_ede_cbc_info = {
1023 MBEDTLS_CIPHER_DES_EDE_CBC,
1024 MBEDTLS_MODE_CBC,
1025 MBEDTLS_KEY_LENGTH_DES_EDE,
1026 "DES-EDE-CBC",
1027 8,
1028 0,
1029 8,
1030 &des_ede_info
1031};
1032#endif /* MBEDTLS_CIPHER_MODE_CBC */
1033
1034static const mbedtls_cipher_base_t des_ede3_info = {
1035 MBEDTLS_CIPHER_ID_3DES,
1036 des3_crypt_ecb_wrap,
1037#if defined(MBEDTLS_CIPHER_MODE_CBC)
1038 des3_crypt_cbc_wrap,
1039#endif
1040#if defined(MBEDTLS_CIPHER_MODE_CFB)
1041 NULL,
1042#endif
1043#if defined(MBEDTLS_CIPHER_MODE_CTR)
1044 NULL,
1045#endif
1046#if defined(MBEDTLS_CIPHER_MODE_STREAM)
1047 NULL,
1048#endif
1049 des3_set3key_enc_wrap,
1050 des3_set3key_dec_wrap,
1051 des3_ctx_alloc,
1052 des3_ctx_free
1053};
1054
1055static const mbedtls_cipher_info_t des_ede3_ecb_info = {
1056 MBEDTLS_CIPHER_DES_EDE3_ECB,
1057 MBEDTLS_MODE_ECB,
1058 MBEDTLS_KEY_LENGTH_DES_EDE3,
1059 "DES-EDE3-ECB",
1060 8,
1061 0,
1062 8,
1063 &des_ede3_info
1064};
1065#if defined(MBEDTLS_CIPHER_MODE_CBC)
1066static const mbedtls_cipher_info_t des_ede3_cbc_info = {
1067 MBEDTLS_CIPHER_DES_EDE3_CBC,
1068 MBEDTLS_MODE_CBC,
1069 MBEDTLS_KEY_LENGTH_DES_EDE3,
1070 "DES-EDE3-CBC",
1071 8,
1072 0,
1073 8,
1074 &des_ede3_info
1075};
1076#endif /* MBEDTLS_CIPHER_MODE_CBC */
1077#endif /* MBEDTLS_DES_C */
1078
1079#if defined(MBEDTLS_BLOWFISH_C)
1080
1081static int blowfish_crypt_ecb_wrap( void *ctx, mbedtls_operation_t operation,
1082 const unsigned char *input, unsigned char *output )
1083{
1084 return mbedtls_blowfish_crypt_ecb( (mbedtls_blowfish_context *) ctx, operation, input,
1085 output );
1086}
1087
1088#if defined(MBEDTLS_CIPHER_MODE_CBC)
1089static int blowfish_crypt_cbc_wrap( void *ctx, mbedtls_operation_t operation,
1090 size_t length, unsigned char *iv, const unsigned char *input,
1091 unsigned char *output )
1092{
1093 return mbedtls_blowfish_crypt_cbc( (mbedtls_blowfish_context *) ctx, operation, length, iv,
1094 input, output );
1095}
1096#endif /* MBEDTLS_CIPHER_MODE_CBC */
1097
1098#if defined(MBEDTLS_CIPHER_MODE_CFB)
1099static int blowfish_crypt_cfb64_wrap( void *ctx, mbedtls_operation_t operation,
1100 size_t length, size_t *iv_off, unsigned char *iv,
1101 const unsigned char *input, unsigned char *output )
1102{
1103 return mbedtls_blowfish_crypt_cfb64( (mbedtls_blowfish_context *) ctx, operation, length,
1104 iv_off, iv, input, output );
1105}
1106#endif /* MBEDTLS_CIPHER_MODE_CFB */
1107
1108#if defined(MBEDTLS_CIPHER_MODE_CTR)
1109static int blowfish_crypt_ctr_wrap( void *ctx, size_t length, size_t *nc_off,
1110 unsigned char *nonce_counter, unsigned char *stream_block,
1111 const unsigned char *input, unsigned char *output )
1112{
1113 return mbedtls_blowfish_crypt_ctr( (mbedtls_blowfish_context *) ctx, length, nc_off,
1114 nonce_counter, stream_block, input, output );
1115}
1116#endif /* MBEDTLS_CIPHER_MODE_CTR */
1117
1118static int blowfish_setkey_wrap( void *ctx, const unsigned char *key,
1119 unsigned int key_bitlen )
1120{
1121 return mbedtls_blowfish_setkey( (mbedtls_blowfish_context *) ctx, key, key_bitlen );
1122}
1123
1124static void * blowfish_ctx_alloc( void )
1125{
1126 mbedtls_blowfish_context *ctx;
1127 ctx = mbedtls_calloc( 1, sizeof( mbedtls_blowfish_context ) );
1128
1129 if( ctx == NULL )
1130 return( NULL );
1131
1132 mbedtls_blowfish_init( ctx );
1133
1134 return( ctx );
1135}
1136
1137static void blowfish_ctx_free( void *ctx )
1138{
1139 mbedtls_blowfish_free( (mbedtls_blowfish_context *) ctx );
1140 mbedtls_free( ctx );
1141}
1142
1143static const mbedtls_cipher_base_t blowfish_info = {
1144 MBEDTLS_CIPHER_ID_BLOWFISH,
1145 blowfish_crypt_ecb_wrap,
1146#if defined(MBEDTLS_CIPHER_MODE_CBC)
1147 blowfish_crypt_cbc_wrap,
1148#endif
1149#if defined(MBEDTLS_CIPHER_MODE_CFB)
1150 blowfish_crypt_cfb64_wrap,
1151#endif
1152#if defined(MBEDTLS_CIPHER_MODE_CTR)
1153 blowfish_crypt_ctr_wrap,
1154#endif
1155#if defined(MBEDTLS_CIPHER_MODE_STREAM)
1156 NULL,
1157#endif
1158 blowfish_setkey_wrap,
1159 blowfish_setkey_wrap,
1160 blowfish_ctx_alloc,
1161 blowfish_ctx_free
1162};
1163
1164static const mbedtls_cipher_info_t blowfish_ecb_info = {
1165 MBEDTLS_CIPHER_BLOWFISH_ECB,
1166 MBEDTLS_MODE_ECB,
1167 128,
1168 "BLOWFISH-ECB",
1169 8,
1170 MBEDTLS_CIPHER_VARIABLE_KEY_LEN,
1171 8,
1172 &blowfish_info
1173};
1174
1175#if defined(MBEDTLS_CIPHER_MODE_CBC)
1176static const mbedtls_cipher_info_t blowfish_cbc_info = {
1177 MBEDTLS_CIPHER_BLOWFISH_CBC,
1178 MBEDTLS_MODE_CBC,
1179 128,
1180 "BLOWFISH-CBC",
1181 8,
1182 MBEDTLS_CIPHER_VARIABLE_KEY_LEN,
1183 8,
1184 &blowfish_info
1185};
1186#endif /* MBEDTLS_CIPHER_MODE_CBC */
1187
1188#if defined(MBEDTLS_CIPHER_MODE_CFB)
1189static const mbedtls_cipher_info_t blowfish_cfb64_info = {
1190 MBEDTLS_CIPHER_BLOWFISH_CFB64,
1191 MBEDTLS_MODE_CFB,
1192 128,
1193 "BLOWFISH-CFB64",
1194 8,
1195 MBEDTLS_CIPHER_VARIABLE_KEY_LEN,
1196 8,
1197 &blowfish_info
1198};
1199#endif /* MBEDTLS_CIPHER_MODE_CFB */
1200
1201#if defined(MBEDTLS_CIPHER_MODE_CTR)
1202static const mbedtls_cipher_info_t blowfish_ctr_info = {
1203 MBEDTLS_CIPHER_BLOWFISH_CTR,
1204 MBEDTLS_MODE_CTR,
1205 128,
1206 "BLOWFISH-CTR",
1207 8,
1208 MBEDTLS_CIPHER_VARIABLE_KEY_LEN,
1209 8,
1210 &blowfish_info
1211};
1212#endif /* MBEDTLS_CIPHER_MODE_CTR */
1213#endif /* MBEDTLS_BLOWFISH_C */
1214
1215#if defined(MBEDTLS_ARC4_C)
1216static int arc4_crypt_stream_wrap( void *ctx, size_t length,
1217 const unsigned char *input,
1218 unsigned char *output )
1219{
1220 return( mbedtls_arc4_crypt( (mbedtls_arc4_context *) ctx, length, input, output ) );
1221}
1222
1223static int arc4_setkey_wrap( void *ctx, const unsigned char *key,
1224 unsigned int key_bitlen )
1225{
1226 /* we get key_bitlen in bits, arc4 expects it in bytes */
1227 if( key_bitlen % 8 != 0 )
1228 return( MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA );
1229
1230 mbedtls_arc4_setup( (mbedtls_arc4_context *) ctx, key, key_bitlen / 8 );
1231 return( 0 );
1232}
1233
1234static void * arc4_ctx_alloc( void )
1235{
1236 mbedtls_arc4_context *ctx;
1237 ctx = mbedtls_calloc( 1, sizeof( mbedtls_arc4_context ) );
1238
1239 if( ctx == NULL )
1240 return( NULL );
1241
1242 mbedtls_arc4_init( ctx );
1243
1244 return( ctx );
1245}
1246
1247static void arc4_ctx_free( void *ctx )
1248{
1249 mbedtls_arc4_free( (mbedtls_arc4_context *) ctx );
1250 mbedtls_free( ctx );
1251}
1252
1253static const mbedtls_cipher_base_t arc4_base_info = {
1254 MBEDTLS_CIPHER_ID_ARC4,
1255 NULL,
1256#if defined(MBEDTLS_CIPHER_MODE_CBC)
1257 NULL,
1258#endif
1259#if defined(MBEDTLS_CIPHER_MODE_CFB)
1260 NULL,
1261#endif
1262#if defined(MBEDTLS_CIPHER_MODE_CTR)
1263 NULL,
1264#endif
1265#if defined(MBEDTLS_CIPHER_MODE_STREAM)
1266 arc4_crypt_stream_wrap,
1267#endif
1268 arc4_setkey_wrap,
1269 arc4_setkey_wrap,
1270 arc4_ctx_alloc,
1271 arc4_ctx_free
1272};
1273
1274static const mbedtls_cipher_info_t arc4_128_info = {
1275 MBEDTLS_CIPHER_ARC4_128,
1276 MBEDTLS_MODE_STREAM,
1277 128,
1278 "ARC4-128",
1279 0,
1280 0,
1281 1,
1282 &arc4_base_info
1283};
1284#endif /* MBEDTLS_ARC4_C */
1285
1286#if defined(MBEDTLS_CIPHER_NULL_CIPHER)
1287static int null_crypt_stream( void *ctx, size_t length,
1288 const unsigned char *input,
1289 unsigned char *output )
1290{
1291 ((void) ctx);
1292 memmove( output, input, length );
1293 return( 0 );
1294}
1295
1296static int null_setkey( void *ctx, const unsigned char *key,
1297 unsigned int key_bitlen )
1298{
1299 ((void) ctx);
1300 ((void) key);
1301 ((void) key_bitlen);
1302
1303 return( 0 );
1304}
1305
1306static void * null_ctx_alloc( void )
1307{
1308 return( (void *) 1 );
1309}
1310
1311static void null_ctx_free( void *ctx )
1312{
1313 ((void) ctx);
1314}
1315
1316static const mbedtls_cipher_base_t null_base_info = {
1317 MBEDTLS_CIPHER_ID_NULL,
1318 NULL,
1319#if defined(MBEDTLS_CIPHER_MODE_CBC)
1320 NULL,
1321#endif
1322#if defined(MBEDTLS_CIPHER_MODE_CFB)
1323 NULL,
1324#endif
1325#if defined(MBEDTLS_CIPHER_MODE_CTR)
1326 NULL,
1327#endif
1328#if defined(MBEDTLS_CIPHER_MODE_STREAM)
1329 null_crypt_stream,
1330#endif
1331 null_setkey,
1332 null_setkey,
1333 null_ctx_alloc,
1334 null_ctx_free
1335};
1336
1337static const mbedtls_cipher_info_t null_cipher_info = {
1338 MBEDTLS_CIPHER_NULL,
1339 MBEDTLS_MODE_STREAM,
1340 0,
1341 "NULL",
1342 0,
1343 0,
1344 1,
1345 &null_base_info
1346};
1347#endif /* defined(MBEDTLS_CIPHER_NULL_CIPHER) */
1348
1349const mbedtls_cipher_definition_t mbedtls_cipher_definitions[] =
1350{
1351#if defined(MBEDTLS_AES_C)
1352 { MBEDTLS_CIPHER_AES_128_ECB, &aes_128_ecb_info },
1353 { MBEDTLS_CIPHER_AES_192_ECB, &aes_192_ecb_info },
1354 { MBEDTLS_CIPHER_AES_256_ECB, &aes_256_ecb_info },
1355#if defined(MBEDTLS_CIPHER_MODE_CBC)
1356 { MBEDTLS_CIPHER_AES_128_CBC, &aes_128_cbc_info },
1357 { MBEDTLS_CIPHER_AES_192_CBC, &aes_192_cbc_info },
1358 { MBEDTLS_CIPHER_AES_256_CBC, &aes_256_cbc_info },
1359#endif
1360#if defined(MBEDTLS_CIPHER_MODE_CFB)
1361 { MBEDTLS_CIPHER_AES_128_CFB128, &aes_128_cfb128_info },
1362 { MBEDTLS_CIPHER_AES_192_CFB128, &aes_192_cfb128_info },
1363 { MBEDTLS_CIPHER_AES_256_CFB128, &aes_256_cfb128_info },
1364#endif
1365#if defined(MBEDTLS_CIPHER_MODE_CTR)
1366 { MBEDTLS_CIPHER_AES_128_CTR, &aes_128_ctr_info },
1367 { MBEDTLS_CIPHER_AES_192_CTR, &aes_192_ctr_info },
1368 { MBEDTLS_CIPHER_AES_256_CTR, &aes_256_ctr_info },
1369#endif
1370#if defined(MBEDTLS_GCM_C)
1371 { MBEDTLS_CIPHER_AES_128_GCM, &aes_128_gcm_info },
1372 { MBEDTLS_CIPHER_AES_192_GCM, &aes_192_gcm_info },
1373 { MBEDTLS_CIPHER_AES_256_GCM, &aes_256_gcm_info },
1374#endif
1375#if defined(MBEDTLS_CCM_C)
1376 { MBEDTLS_CIPHER_AES_128_CCM, &aes_128_ccm_info },
1377 { MBEDTLS_CIPHER_AES_192_CCM, &aes_192_ccm_info },
1378 { MBEDTLS_CIPHER_AES_256_CCM, &aes_256_ccm_info },
1379#endif
1380#endif /* MBEDTLS_AES_C */
1381
1382#if defined(MBEDTLS_ARC4_C)
1383 { MBEDTLS_CIPHER_ARC4_128, &arc4_128_info },
1384#endif
1385
1386#if defined(MBEDTLS_BLOWFISH_C)
1387 { MBEDTLS_CIPHER_BLOWFISH_ECB, &blowfish_ecb_info },
1388#if defined(MBEDTLS_CIPHER_MODE_CBC)
1389 { MBEDTLS_CIPHER_BLOWFISH_CBC, &blowfish_cbc_info },
1390#endif
1391#if defined(MBEDTLS_CIPHER_MODE_CFB)
1392 { MBEDTLS_CIPHER_BLOWFISH_CFB64, &blowfish_cfb64_info },
1393#endif
1394#if defined(MBEDTLS_CIPHER_MODE_CTR)
1395 { MBEDTLS_CIPHER_BLOWFISH_CTR, &blowfish_ctr_info },
1396#endif
1397#endif /* MBEDTLS_BLOWFISH_C */
1398
1399#if defined(MBEDTLS_CAMELLIA_C)
1400 { MBEDTLS_CIPHER_CAMELLIA_128_ECB, &camellia_128_ecb_info },
1401 { MBEDTLS_CIPHER_CAMELLIA_192_ECB, &camellia_192_ecb_info },
1402 { MBEDTLS_CIPHER_CAMELLIA_256_ECB, &camellia_256_ecb_info },
1403#if defined(MBEDTLS_CIPHER_MODE_CBC)
1404 { MBEDTLS_CIPHER_CAMELLIA_128_CBC, &camellia_128_cbc_info },
1405 { MBEDTLS_CIPHER_CAMELLIA_192_CBC, &camellia_192_cbc_info },
1406 { MBEDTLS_CIPHER_CAMELLIA_256_CBC, &camellia_256_cbc_info },
1407#endif
1408#if defined(MBEDTLS_CIPHER_MODE_CFB)
1409 { MBEDTLS_CIPHER_CAMELLIA_128_CFB128, &camellia_128_cfb128_info },
1410 { MBEDTLS_CIPHER_CAMELLIA_192_CFB128, &camellia_192_cfb128_info },
1411 { MBEDTLS_CIPHER_CAMELLIA_256_CFB128, &camellia_256_cfb128_info },
1412#endif
1413#if defined(MBEDTLS_CIPHER_MODE_CTR)
1414 { MBEDTLS_CIPHER_CAMELLIA_128_CTR, &camellia_128_ctr_info },
1415 { MBEDTLS_CIPHER_CAMELLIA_192_CTR, &camellia_192_ctr_info },
1416 { MBEDTLS_CIPHER_CAMELLIA_256_CTR, &camellia_256_ctr_info },
1417#endif
1418#if defined(MBEDTLS_GCM_C)
1419 { MBEDTLS_CIPHER_CAMELLIA_128_GCM, &camellia_128_gcm_info },
1420 { MBEDTLS_CIPHER_CAMELLIA_192_GCM, &camellia_192_gcm_info },
1421 { MBEDTLS_CIPHER_CAMELLIA_256_GCM, &camellia_256_gcm_info },
1422#endif
1423#if defined(MBEDTLS_CCM_C)
1424 { MBEDTLS_CIPHER_CAMELLIA_128_CCM, &camellia_128_ccm_info },
1425 { MBEDTLS_CIPHER_CAMELLIA_192_CCM, &camellia_192_ccm_info },
1426 { MBEDTLS_CIPHER_CAMELLIA_256_CCM, &camellia_256_ccm_info },
1427#endif
1428#endif /* MBEDTLS_CAMELLIA_C */
1429
1430#if defined(MBEDTLS_DES_C)
1431 { MBEDTLS_CIPHER_DES_ECB, &des_ecb_info },
1432 { MBEDTLS_CIPHER_DES_EDE_ECB, &des_ede_ecb_info },
1433 { MBEDTLS_CIPHER_DES_EDE3_ECB, &des_ede3_ecb_info },
1434#if defined(MBEDTLS_CIPHER_MODE_CBC)
1435 { MBEDTLS_CIPHER_DES_CBC, &des_cbc_info },
1436 { MBEDTLS_CIPHER_DES_EDE_CBC, &des_ede_cbc_info },
1437 { MBEDTLS_CIPHER_DES_EDE3_CBC, &des_ede3_cbc_info },
1438#endif
1439#endif /* MBEDTLS_DES_C */
1440
1441#if defined(MBEDTLS_CIPHER_NULL_CIPHER)
1442 { MBEDTLS_CIPHER_NULL, &null_cipher_info },
1443#endif /* MBEDTLS_CIPHER_NULL_CIPHER */
1444
1445 { MBEDTLS_CIPHER_NONE, NULL }
1446};
1447
1448#define NUM_CIPHERS sizeof mbedtls_cipher_definitions / sizeof mbedtls_cipher_definitions[0]
1449int mbedtls_cipher_supported[NUM_CIPHERS];
1450
1451#endif /* MBEDTLS_CIPHER_C */
Note: See TracBrowser for help on using the repository browser.