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