git.zerfleddert.de Git - proxmark3-svn/blob - common/mbedtls/cipher_wrap.c

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