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