source: azure_iot_hub_mbedtls/trunk/mbedtls-2.16.1/library/cipher_wrap.c@ 398

Last change on this file since 398 was 398, checked in by coas-nagasima, 5 years ago

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