git.sur5r.net Git - freertos/blob - FreeRTOS-Labs/Source/mbedtls/library/cipher_wrap.c

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