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