1 /** 2 * \file cipher_wrap.c 3 * 4 * \brief Generic cipher wrapper for mbed TLS 5 * 6 * \author Adriaan de Jong <dejong@fox-it.com> 7 * 8 * Copyright (C) 2006-2015, ARM Limited, All Rights Reserved 9 * SPDX-License-Identifier: Apache-2.0 10 * 11 * Licensed under the Apache License, Version 2.0 (the "License"); you may 12 * not use this file except in compliance with the License. 13 * You may obtain a copy of the License at 14 * 15 * http://www.apache.org/licenses/LICENSE-2.0 16 * 17 * Unless required by applicable law or agreed to in writing, software 18 * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT 19 * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 20 * See the License for the specific language governing permissions and 21 * limitations under the License. 22 * 23 * 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_AES_C) 37 #include "mbedtls/aes.h" 38 #endif 39 40 #if defined(MBEDTLS_ARC4_C) 41 #include "mbedtls/arc4.h" 42 #endif 43 44 #if defined(MBEDTLS_CAMELLIA_C) 45 #include "mbedtls/camellia.h" 46 #endif 47 48 #if defined(MBEDTLS_DES_C) 49 #include "mbedtls/des.h" 50 #endif 51 52 #if defined(MBEDTLS_BLOWFISH_C) 53 #include "mbedtls/blowfish.h" 54 #endif 55 56 #if defined(MBEDTLS_GCM_C) 57 #include "mbedtls/gcm.h" 58 #endif 59 60 #if defined(MBEDTLS_CCM_C) 61 #include "mbedtls/ccm.h" 62 #endif 63 64 #if defined(MBEDTLS_CIPHER_NULL_CIPHER) 65 #include <string.h> 66 #endif 67 68 #if defined(MBEDTLS_PLATFORM_C) 69 #include "mbedtls/platform.h" 70 #else 71 #include <stdlib.h> 72 #define mbedtls_calloc calloc 73 #define mbedtls_free free 74 #endif 75 76 #if defined(MBEDTLS_GCM_C) 77 /* shared by all GCM ciphers */ 78 static void *gcm_ctx_alloc( void ) 79 { 80 void *ctx = mbedtls_calloc( 1, sizeof( mbedtls_gcm_context ) ); 81 82 if( ctx != NULL ) 83 mbedtls_gcm_init( (mbedtls_gcm_context *) ctx ); 84 85 return( ctx ); 86 } 87 88 static void gcm_ctx_free( void *ctx ) 89 { 90 mbedtls_gcm_free( ctx ); 91 mbedtls_free( ctx ); 92 } 93 #endif /* MBEDTLS_GCM_C */ 94 95 #if defined(MBEDTLS_CCM_C) 96 /* shared by all CCM ciphers */ 97 static void *ccm_ctx_alloc( void ) 98 { 99 void *ctx = mbedtls_calloc( 1, sizeof( mbedtls_ccm_context ) ); 100 101 if( ctx != NULL ) 102 mbedtls_ccm_init( (mbedtls_ccm_context *) ctx ); 103 104 return( ctx ); 105 } 106 107 static void ccm_ctx_free( void *ctx ) 108 { 109 mbedtls_ccm_free( ctx ); 110 mbedtls_free( ctx ); 111 } 112 #endif /* MBEDTLS_CCM_C */ 113 114 #if defined(MBEDTLS_AES_C) 115 116 static int aes_crypt_ecb_wrap( void *ctx, mbedtls_operation_t operation, 117 const unsigned char *input, unsigned char *output ) 118 { 119 return mbedtls_aes_crypt_ecb( (mbedtls_aes_context *) ctx, operation, input, output ); 120 } 121 122 #if defined(MBEDTLS_CIPHER_MODE_CBC) 123 static int aes_crypt_cbc_wrap( void *ctx, mbedtls_operation_t operation, size_t length, 124 unsigned char *iv, const unsigned char *input, unsigned char *output ) 125 { 126 return mbedtls_aes_crypt_cbc( (mbedtls_aes_context *) ctx, operation, length, iv, input, 127 output ); 128 } 129 #endif /* MBEDTLS_CIPHER_MODE_CBC */ 130 131 #if defined(MBEDTLS_CIPHER_MODE_CFB) 132 static int aes_crypt_cfb128_wrap( void *ctx, mbedtls_operation_t operation, 133 size_t length, size_t *iv_off, unsigned char *iv, 134 const unsigned char *input, unsigned char *output ) 135 { 136 return mbedtls_aes_crypt_cfb128( (mbedtls_aes_context *) ctx, operation, length, iv_off, iv, 137 input, output ); 138 } 139 #endif /* MBEDTLS_CIPHER_MODE_CFB */ 140 141 #if defined(MBEDTLS_CIPHER_MODE_CTR) 142 static int aes_crypt_ctr_wrap( void *ctx, size_t length, size_t *nc_off, 143 unsigned char *nonce_counter, unsigned char *stream_block, 144 const unsigned char *input, unsigned char *output ) 145 { 146 return mbedtls_aes_crypt_ctr( (mbedtls_aes_context *) ctx, length, nc_off, nonce_counter, 147 stream_block, input, output ); 148 } 149 #endif /* MBEDTLS_CIPHER_MODE_CTR */ 150 151 static int aes_setkey_dec_wrap( void *ctx, const unsigned char *key, 152 unsigned int key_bitlen ) 153 { 154 return mbedtls_aes_setkey_dec( (mbedtls_aes_context *) ctx, key, key_bitlen ); 155 } 156 157 static int aes_setkey_enc_wrap( void *ctx, const unsigned char *key, 158 unsigned int key_bitlen ) 159 { 160 return mbedtls_aes_setkey_enc( (mbedtls_aes_context *) ctx, key, key_bitlen ); 161 } 162 163 static void * aes_ctx_alloc( void ) 164 { 165 mbedtls_aes_context *aes = mbedtls_calloc( 1, sizeof( mbedtls_aes_context ) ); 166 167 if( aes == NULL ) 168 return( NULL ); 169 170 mbedtls_aes_init( aes ); 171 172 return( aes ); 173 } 174 175 static void aes_ctx_free( void *ctx ) 176 { 177 mbedtls_aes_free( (mbedtls_aes_context *) ctx ); 178 mbedtls_free( ctx ); 179 } 180 181 static const mbedtls_cipher_base_t aes_info = { 182 MBEDTLS_CIPHER_ID_AES, 183 aes_crypt_ecb_wrap, 184 #if defined(MBEDTLS_CIPHER_MODE_CBC) 185 aes_crypt_cbc_wrap, 186 #endif 187 #if defined(MBEDTLS_CIPHER_MODE_CFB) 188 aes_crypt_cfb128_wrap, 189 #endif 190 #if defined(MBEDTLS_CIPHER_MODE_CTR) 191 aes_crypt_ctr_wrap, 192 #endif 193 #if defined(MBEDTLS_CIPHER_MODE_STREAM) 194 NULL, 195 #endif 196 aes_setkey_enc_wrap, 197 aes_setkey_dec_wrap, 198 aes_ctx_alloc, 199 aes_ctx_free 200 }; 201 202 static const mbedtls_cipher_info_t aes_128_ecb_info = { 203 MBEDTLS_CIPHER_AES_128_ECB, 204 MBEDTLS_MODE_ECB, 205 128, 206 "AES-128-ECB", 207 16, 208 0, 209 16, 210 &aes_info 211 }; 212 213 static const mbedtls_cipher_info_t aes_192_ecb_info = { 214 MBEDTLS_CIPHER_AES_192_ECB, 215 MBEDTLS_MODE_ECB, 216 192, 217 "AES-192-ECB", 218 16, 219 0, 220 16, 221 &aes_info 222 }; 223 224 static const mbedtls_cipher_info_t aes_256_ecb_info = { 225 MBEDTLS_CIPHER_AES_256_ECB, 226 MBEDTLS_MODE_ECB, 227 256, 228 "AES-256-ECB", 229 16, 230 0, 231 16, 232 &aes_info 233 }; 234 235 #if defined(MBEDTLS_CIPHER_MODE_CBC) 236 static const mbedtls_cipher_info_t aes_128_cbc_info = { 237 MBEDTLS_CIPHER_AES_128_CBC, 238 MBEDTLS_MODE_CBC, 239 128, 240 "AES-128-CBC", 241 16, 242 0, 243 16, 244 &aes_info 245 }; 246 247 static const mbedtls_cipher_info_t aes_192_cbc_info = { 248 MBEDTLS_CIPHER_AES_192_CBC, 249 MBEDTLS_MODE_CBC, 250 192, 251 "AES-192-CBC", 252 16, 253 0, 254 16, 255 &aes_info 256 }; 257 258 static const mbedtls_cipher_info_t aes_256_cbc_info = { 259 MBEDTLS_CIPHER_AES_256_CBC, 260 MBEDTLS_MODE_CBC, 261 256, 262 "AES-256-CBC", 263 16, 264 0, 265 16, 266 &aes_info 267 }; 268 #endif /* MBEDTLS_CIPHER_MODE_CBC */ 269 270 #if defined(MBEDTLS_CIPHER_MODE_CFB) 271 static const mbedtls_cipher_info_t aes_128_cfb128_info = { 272 MBEDTLS_CIPHER_AES_128_CFB128, 273 MBEDTLS_MODE_CFB, 274 128, 275 "AES-128-CFB128", 276 16, 277 0, 278 16, 279 &aes_info 280 }; 281 282 static const mbedtls_cipher_info_t aes_192_cfb128_info = { 283 MBEDTLS_CIPHER_AES_192_CFB128, 284 MBEDTLS_MODE_CFB, 285 192, 286 "AES-192-CFB128", 287 16, 288 0, 289 16, 290 &aes_info 291 }; 292 293 static const mbedtls_cipher_info_t aes_256_cfb128_info = { 294 MBEDTLS_CIPHER_AES_256_CFB128, 295 MBEDTLS_MODE_CFB, 296 256, 297 "AES-256-CFB128", 298 16, 299 0, 300 16, 301 &aes_info 302 }; 303 #endif /* MBEDTLS_CIPHER_MODE_CFB */ 304 305 #if defined(MBEDTLS_CIPHER_MODE_CTR) 306 static const mbedtls_cipher_info_t aes_128_ctr_info = { 307 MBEDTLS_CIPHER_AES_128_CTR, 308 MBEDTLS_MODE_CTR, 309 128, 310 "AES-128-CTR", 311 16, 312 0, 313 16, 314 &aes_info 315 }; 316 317 static const mbedtls_cipher_info_t aes_192_ctr_info = { 318 MBEDTLS_CIPHER_AES_192_CTR, 319 MBEDTLS_MODE_CTR, 320 192, 321 "AES-192-CTR", 322 16, 323 0, 324 16, 325 &aes_info 326 }; 327 328 static const mbedtls_cipher_info_t aes_256_ctr_info = { 329 MBEDTLS_CIPHER_AES_256_CTR, 330 MBEDTLS_MODE_CTR, 331 256, 332 "AES-256-CTR", 333 16, 334 0, 335 16, 336 &aes_info 337 }; 338 #endif /* MBEDTLS_CIPHER_MODE_CTR */ 339 340 #if defined(MBEDTLS_GCM_C) 341 static int gcm_aes_setkey_wrap( void *ctx, const unsigned char *key, 342 unsigned int key_bitlen ) 343 { 344 return mbedtls_gcm_setkey( (mbedtls_gcm_context *) ctx, MBEDTLS_CIPHER_ID_AES, 345 key, key_bitlen ); 346 } 347 348 static const mbedtls_cipher_base_t gcm_aes_info = { 349 MBEDTLS_CIPHER_ID_AES, 350 NULL, 351 #if defined(MBEDTLS_CIPHER_MODE_CBC) 352 NULL, 353 #endif 354 #if defined(MBEDTLS_CIPHER_MODE_CFB) 355 NULL, 356 #endif 357 #if defined(MBEDTLS_CIPHER_MODE_CTR) 358 NULL, 359 #endif 360 #if defined(MBEDTLS_CIPHER_MODE_STREAM) 361 NULL, 362 #endif 363 gcm_aes_setkey_wrap, 364 gcm_aes_setkey_wrap, 365 gcm_ctx_alloc, 366 gcm_ctx_free, 367 }; 368 369 static const mbedtls_cipher_info_t aes_128_gcm_info = { 370 MBEDTLS_CIPHER_AES_128_GCM, 371 MBEDTLS_MODE_GCM, 372 128, 373 "AES-128-GCM", 374 12, 375 MBEDTLS_CIPHER_VARIABLE_IV_LEN, 376 16, 377 &gcm_aes_info 378 }; 379 380 static const mbedtls_cipher_info_t aes_192_gcm_info = { 381 MBEDTLS_CIPHER_AES_192_GCM, 382 MBEDTLS_MODE_GCM, 383 192, 384 "AES-192-GCM", 385 12, 386 MBEDTLS_CIPHER_VARIABLE_IV_LEN, 387 16, 388 &gcm_aes_info 389 }; 390 391 static const mbedtls_cipher_info_t aes_256_gcm_info = { 392 MBEDTLS_CIPHER_AES_256_GCM, 393 MBEDTLS_MODE_GCM, 394 256, 395 "AES-256-GCM", 396 12, 397 MBEDTLS_CIPHER_VARIABLE_IV_LEN, 398 16, 399 &gcm_aes_info 400 }; 401 #endif /* MBEDTLS_GCM_C */ 402 403 #if defined(MBEDTLS_CCM_C) 404 static int ccm_aes_setkey_wrap( void *ctx, const unsigned char *key, 405 unsigned int key_bitlen ) 406 { 407 return mbedtls_ccm_setkey( (mbedtls_ccm_context *) ctx, MBEDTLS_CIPHER_ID_AES, 408 key, key_bitlen ); 409 } 410 411 static const mbedtls_cipher_base_t ccm_aes_info = { 412 MBEDTLS_CIPHER_ID_AES, 413 NULL, 414 #if defined(MBEDTLS_CIPHER_MODE_CBC) 415 NULL, 416 #endif 417 #if defined(MBEDTLS_CIPHER_MODE_CFB) 418 NULL, 419 #endif 420 #if defined(MBEDTLS_CIPHER_MODE_CTR) 421 NULL, 422 #endif 423 #if defined(MBEDTLS_CIPHER_MODE_STREAM) 424 NULL, 425 #endif 426 ccm_aes_setkey_wrap, 427 ccm_aes_setkey_wrap, 428 ccm_ctx_alloc, 429 ccm_ctx_free, 430 }; 431 432 static const mbedtls_cipher_info_t aes_128_ccm_info = { 433 MBEDTLS_CIPHER_AES_128_CCM, 434 MBEDTLS_MODE_CCM, 435 128, 436 "AES-128-CCM", 437 12, 438 MBEDTLS_CIPHER_VARIABLE_IV_LEN, 439 16, 440 &ccm_aes_info 441 }; 442 443 static const mbedtls_cipher_info_t aes_192_ccm_info = { 444 MBEDTLS_CIPHER_AES_192_CCM, 445 MBEDTLS_MODE_CCM, 446 192, 447 "AES-192-CCM", 448 12, 449 MBEDTLS_CIPHER_VARIABLE_IV_LEN, 450 16, 451 &ccm_aes_info 452 }; 453 454 static const mbedtls_cipher_info_t aes_256_ccm_info = { 455 MBEDTLS_CIPHER_AES_256_CCM, 456 MBEDTLS_MODE_CCM, 457 256, 458 "AES-256-CCM", 459 12, 460 MBEDTLS_CIPHER_VARIABLE_IV_LEN, 461 16, 462 &ccm_aes_info 463 }; 464 #endif /* MBEDTLS_CCM_C */ 465 466 #endif /* MBEDTLS_AES_C */ 467 468 #if defined(MBEDTLS_CAMELLIA_C) 469 470 static int camellia_crypt_ecb_wrap( void *ctx, mbedtls_operation_t operation, 471 const unsigned char *input, unsigned char *output ) 472 { 473 return mbedtls_camellia_crypt_ecb( (mbedtls_camellia_context *) ctx, operation, input, 474 output ); 475 } 476 477 #if defined(MBEDTLS_CIPHER_MODE_CBC) 478 static int camellia_crypt_cbc_wrap( void *ctx, mbedtls_operation_t operation, 479 size_t length, unsigned char *iv, 480 const unsigned char *input, unsigned char *output ) 481 { 482 return mbedtls_camellia_crypt_cbc( (mbedtls_camellia_context *) ctx, operation, length, iv, 483 input, output ); 484 } 485 #endif /* MBEDTLS_CIPHER_MODE_CBC */ 486 487 #if defined(MBEDTLS_CIPHER_MODE_CFB) 488 static int camellia_crypt_cfb128_wrap( void *ctx, mbedtls_operation_t operation, 489 size_t length, size_t *iv_off, unsigned char *iv, 490 const unsigned char *input, unsigned char *output ) 491 { 492 return mbedtls_camellia_crypt_cfb128( (mbedtls_camellia_context *) ctx, operation, length, 493 iv_off, iv, input, output ); 494 } 495 #endif /* MBEDTLS_CIPHER_MODE_CFB */ 496 497 #if defined(MBEDTLS_CIPHER_MODE_CTR) 498 static int camellia_crypt_ctr_wrap( void *ctx, size_t length, size_t *nc_off, 499 unsigned char *nonce_counter, unsigned char *stream_block, 500 const unsigned char *input, unsigned char *output ) 501 { 502 return mbedtls_camellia_crypt_ctr( (mbedtls_camellia_context *) ctx, length, nc_off, 503 nonce_counter, stream_block, input, output ); 504 } 505 #endif /* MBEDTLS_CIPHER_MODE_CTR */ 506 507 static int camellia_setkey_dec_wrap( void *ctx, const unsigned char *key, 508 unsigned int key_bitlen ) 509 { 510 return mbedtls_camellia_setkey_dec( (mbedtls_camellia_context *) ctx, key, key_bitlen ); 511 } 512 513 static int camellia_setkey_enc_wrap( void *ctx, const unsigned char *key, 514 unsigned int key_bitlen ) 515 { 516 return mbedtls_camellia_setkey_enc( (mbedtls_camellia_context *) ctx, key, key_bitlen ); 517 } 518 519 static void * camellia_ctx_alloc( void ) 520 { 521 mbedtls_camellia_context *ctx; 522 ctx = mbedtls_calloc( 1, sizeof( mbedtls_camellia_context ) ); 523 524 if( ctx == NULL ) 525 return( NULL ); 526 527 mbedtls_camellia_init( ctx ); 528 529 return( ctx ); 530 } 531 532 static void camellia_ctx_free( void *ctx ) 533 { 534 mbedtls_camellia_free( (mbedtls_camellia_context *) ctx ); 535 mbedtls_free( ctx ); 536 } 537 538 static const mbedtls_cipher_base_t camellia_info = { 539 MBEDTLS_CIPHER_ID_CAMELLIA, 540 camellia_crypt_ecb_wrap, 541 #if defined(MBEDTLS_CIPHER_MODE_CBC) 542 camellia_crypt_cbc_wrap, 543 #endif 544 #if defined(MBEDTLS_CIPHER_MODE_CFB) 545 camellia_crypt_cfb128_wrap, 546 #endif 547 #if defined(MBEDTLS_CIPHER_MODE_CTR) 548 camellia_crypt_ctr_wrap, 549 #endif 550 #if defined(MBEDTLS_CIPHER_MODE_STREAM) 551 NULL, 552 #endif 553 camellia_setkey_enc_wrap, 554 camellia_setkey_dec_wrap, 555 camellia_ctx_alloc, 556 camellia_ctx_free 557 }; 558 559 static const mbedtls_cipher_info_t camellia_128_ecb_info = { 560 MBEDTLS_CIPHER_CAMELLIA_128_ECB, 561 MBEDTLS_MODE_ECB, 562 128, 563 "CAMELLIA-128-ECB", 564 16, 565 0, 566 16, 567 &camellia_info 568 }; 569 570 static const mbedtls_cipher_info_t camellia_192_ecb_info = { 571 MBEDTLS_CIPHER_CAMELLIA_192_ECB, 572 MBEDTLS_MODE_ECB, 573 192, 574 "CAMELLIA-192-ECB", 575 16, 576 0, 577 16, 578 &camellia_info 579 }; 580 581 static const mbedtls_cipher_info_t camellia_256_ecb_info = { 582 MBEDTLS_CIPHER_CAMELLIA_256_ECB, 583 MBEDTLS_MODE_ECB, 584 256, 585 "CAMELLIA-256-ECB", 586 16, 587 0, 588 16, 589 &camellia_info 590 }; 591 592 #if defined(MBEDTLS_CIPHER_MODE_CBC) 593 static const mbedtls_cipher_info_t camellia_128_cbc_info = { 594 MBEDTLS_CIPHER_CAMELLIA_128_CBC, 595 MBEDTLS_MODE_CBC, 596 128, 597 "CAMELLIA-128-CBC", 598 16, 599 0, 600 16, 601 &camellia_info 602 }; 603 604 static const mbedtls_cipher_info_t camellia_192_cbc_info = { 605 MBEDTLS_CIPHER_CAMELLIA_192_CBC, 606 MBEDTLS_MODE_CBC, 607 192, 608 "CAMELLIA-192-CBC", 609 16, 610 0, 611 16, 612 &camellia_info 613 }; 614 615 static const mbedtls_cipher_info_t camellia_256_cbc_info = { 616 MBEDTLS_CIPHER_CAMELLIA_256_CBC, 617 MBEDTLS_MODE_CBC, 618 256, 619 "CAMELLIA-256-CBC", 620 16, 621 0, 622 16, 623 &camellia_info 624 }; 625 #endif /* MBEDTLS_CIPHER_MODE_CBC */ 626 627 #if defined(MBEDTLS_CIPHER_MODE_CFB) 628 static const mbedtls_cipher_info_t camellia_128_cfb128_info = { 629 MBEDTLS_CIPHER_CAMELLIA_128_CFB128, 630 MBEDTLS_MODE_CFB, 631 128, 632 "CAMELLIA-128-CFB128", 633 16, 634 0, 635 16, 636 &camellia_info 637 }; 638 639 static const mbedtls_cipher_info_t camellia_192_cfb128_info = { 640 MBEDTLS_CIPHER_CAMELLIA_192_CFB128, 641 MBEDTLS_MODE_CFB, 642 192, 643 "CAMELLIA-192-CFB128", 644 16, 645 0, 646 16, 647 &camellia_info 648 }; 649 650 static const mbedtls_cipher_info_t camellia_256_cfb128_info = { 651 MBEDTLS_CIPHER_CAMELLIA_256_CFB128, 652 MBEDTLS_MODE_CFB, 653 256, 654 "CAMELLIA-256-CFB128", 655 16, 656 0, 657 16, 658 &camellia_info 659 }; 660 #endif /* MBEDTLS_CIPHER_MODE_CFB */ 661 662 #if defined(MBEDTLS_CIPHER_MODE_CTR) 663 static const mbedtls_cipher_info_t camellia_128_ctr_info = { 664 MBEDTLS_CIPHER_CAMELLIA_128_CTR, 665 MBEDTLS_MODE_CTR, 666 128, 667 "CAMELLIA-128-CTR", 668 16, 669 0, 670 16, 671 &camellia_info 672 }; 673 674 static const mbedtls_cipher_info_t camellia_192_ctr_info = { 675 MBEDTLS_CIPHER_CAMELLIA_192_CTR, 676 MBEDTLS_MODE_CTR, 677 192, 678 "CAMELLIA-192-CTR", 679 16, 680 0, 681 16, 682 &camellia_info 683 }; 684 685 static const mbedtls_cipher_info_t camellia_256_ctr_info = { 686 MBEDTLS_CIPHER_CAMELLIA_256_CTR, 687 MBEDTLS_MODE_CTR, 688 256, 689 "CAMELLIA-256-CTR", 690 16, 691 0, 692 16, 693 &camellia_info 694 }; 695 #endif /* MBEDTLS_CIPHER_MODE_CTR */ 696 697 #if defined(MBEDTLS_GCM_C) 698 static int gcm_camellia_setkey_wrap( void *ctx, const unsigned char *key, 699 unsigned int key_bitlen ) 700 { 701 return mbedtls_gcm_setkey( (mbedtls_gcm_context *) ctx, MBEDTLS_CIPHER_ID_CAMELLIA, 702 key, key_bitlen ); 703 } 704 705 static const mbedtls_cipher_base_t gcm_camellia_info = { 706 MBEDTLS_CIPHER_ID_CAMELLIA, 707 NULL, 708 #if defined(MBEDTLS_CIPHER_MODE_CBC) 709 NULL, 710 #endif 711 #if defined(MBEDTLS_CIPHER_MODE_CFB) 712 NULL, 713 #endif 714 #if defined(MBEDTLS_CIPHER_MODE_CTR) 715 NULL, 716 #endif 717 #if defined(MBEDTLS_CIPHER_MODE_STREAM) 718 NULL, 719 #endif 720 gcm_camellia_setkey_wrap, 721 gcm_camellia_setkey_wrap, 722 gcm_ctx_alloc, 723 gcm_ctx_free, 724 }; 725 726 static const mbedtls_cipher_info_t camellia_128_gcm_info = { 727 MBEDTLS_CIPHER_CAMELLIA_128_GCM, 728 MBEDTLS_MODE_GCM, 729 128, 730 "CAMELLIA-128-GCM", 731 12, 732 MBEDTLS_CIPHER_VARIABLE_IV_LEN, 733 16, 734 &gcm_camellia_info 735 }; 736 737 static const mbedtls_cipher_info_t camellia_192_gcm_info = { 738 MBEDTLS_CIPHER_CAMELLIA_192_GCM, 739 MBEDTLS_MODE_GCM, 740 192, 741 "CAMELLIA-192-GCM", 742 12, 743 MBEDTLS_CIPHER_VARIABLE_IV_LEN, 744 16, 745 &gcm_camellia_info 746 }; 747 748 static const mbedtls_cipher_info_t camellia_256_gcm_info = { 749 MBEDTLS_CIPHER_CAMELLIA_256_GCM, 750 MBEDTLS_MODE_GCM, 751 256, 752 "CAMELLIA-256-GCM", 753 12, 754 MBEDTLS_CIPHER_VARIABLE_IV_LEN, 755 16, 756 &gcm_camellia_info 757 }; 758 #endif /* MBEDTLS_GCM_C */ 759 760 #if defined(MBEDTLS_CCM_C) 761 static int ccm_camellia_setkey_wrap( void *ctx, const unsigned char *key, 762 unsigned int key_bitlen ) 763 { 764 return mbedtls_ccm_setkey( (mbedtls_ccm_context *) ctx, MBEDTLS_CIPHER_ID_CAMELLIA, 765 key, key_bitlen ); 766 } 767 768 static const mbedtls_cipher_base_t ccm_camellia_info = { 769 MBEDTLS_CIPHER_ID_CAMELLIA, 770 NULL, 771 #if defined(MBEDTLS_CIPHER_MODE_CBC) 772 NULL, 773 #endif 774 #if defined(MBEDTLS_CIPHER_MODE_CFB) 775 NULL, 776 #endif 777 #if defined(MBEDTLS_CIPHER_MODE_CTR) 778 NULL, 779 #endif 780 #if defined(MBEDTLS_CIPHER_MODE_STREAM) 781 NULL, 782 #endif 783 ccm_camellia_setkey_wrap, 784 ccm_camellia_setkey_wrap, 785 ccm_ctx_alloc, 786 ccm_ctx_free, 787 }; 788 789 static const mbedtls_cipher_info_t camellia_128_ccm_info = { 790 MBEDTLS_CIPHER_CAMELLIA_128_CCM, 791 MBEDTLS_MODE_CCM, 792 128, 793 "CAMELLIA-128-CCM", 794 12, 795 MBEDTLS_CIPHER_VARIABLE_IV_LEN, 796 16, 797 &ccm_camellia_info 798 }; 799 800 static const mbedtls_cipher_info_t camellia_192_ccm_info = { 801 MBEDTLS_CIPHER_CAMELLIA_192_CCM, 802 MBEDTLS_MODE_CCM, 803 192, 804 "CAMELLIA-192-CCM", 805 12, 806 MBEDTLS_CIPHER_VARIABLE_IV_LEN, 807 16, 808 &ccm_camellia_info 809 }; 810 811 static const mbedtls_cipher_info_t camellia_256_ccm_info = { 812 MBEDTLS_CIPHER_CAMELLIA_256_CCM, 813 MBEDTLS_MODE_CCM, 814 256, 815 "CAMELLIA-256-CCM", 816 12, 817 MBEDTLS_CIPHER_VARIABLE_IV_LEN, 818 16, 819 &ccm_camellia_info 820 }; 821 #endif /* MBEDTLS_CCM_C */ 822 823 #endif /* MBEDTLS_CAMELLIA_C */ 824 825 #if defined(MBEDTLS_DES_C) 826 827 static int des_crypt_ecb_wrap( void *ctx, mbedtls_operation_t operation, 828 const unsigned char *input, unsigned char *output ) 829 { 830 ((void) operation); 831 return mbedtls_des_crypt_ecb( (mbedtls_des_context *) ctx, input, output ); 832 } 833 834 static int des3_crypt_ecb_wrap( void *ctx, mbedtls_operation_t operation, 835 const unsigned char *input, unsigned char *output ) 836 { 837 ((void) operation); 838 return mbedtls_des3_crypt_ecb( (mbedtls_des3_context *) ctx, input, output ); 839 } 840 841 #if defined(MBEDTLS_CIPHER_MODE_CBC) 842 static int des_crypt_cbc_wrap( void *ctx, mbedtls_operation_t operation, size_t length, 843 unsigned char *iv, const unsigned char *input, unsigned char *output ) 844 { 845 return mbedtls_des_crypt_cbc( (mbedtls_des_context *) ctx, operation, length, iv, input, 846 output ); 847 } 848 #endif /* MBEDTLS_CIPHER_MODE_CBC */ 849 850 #if defined(MBEDTLS_CIPHER_MODE_CBC) 851 static int des3_crypt_cbc_wrap( void *ctx, mbedtls_operation_t operation, size_t length, 852 unsigned char *iv, const unsigned char *input, unsigned char *output ) 853 { 854 return mbedtls_des3_crypt_cbc( (mbedtls_des3_context *) ctx, operation, length, iv, input, 855 output ); 856 } 857 #endif /* MBEDTLS_CIPHER_MODE_CBC */ 858 859 static int des_setkey_dec_wrap( void *ctx, const unsigned char *key, 860 unsigned int key_bitlen ) 861 { 862 ((void) key_bitlen); 863 864 return mbedtls_des_setkey_dec( (mbedtls_des_context *) ctx, key ); 865 } 866 867 static int des_setkey_enc_wrap( void *ctx, const unsigned char *key, 868 unsigned int key_bitlen ) 869 { 870 ((void) key_bitlen); 871 872 return mbedtls_des_setkey_enc( (mbedtls_des_context *) ctx, key ); 873 } 874 875 static int des3_set2key_dec_wrap( void *ctx, const unsigned char *key, 876 unsigned int key_bitlen ) 877 { 878 ((void) key_bitlen); 879 880 return mbedtls_des3_set2key_dec( (mbedtls_des3_context *) ctx, key ); 881 } 882 883 static int des3_set2key_enc_wrap( void *ctx, const unsigned char *key, 884 unsigned int key_bitlen ) 885 { 886 ((void) key_bitlen); 887 888 return mbedtls_des3_set2key_enc( (mbedtls_des3_context *) ctx, key ); 889 } 890 891 static int des3_set3key_dec_wrap( void *ctx, const unsigned char *key, 892 unsigned int key_bitlen ) 893 { 894 ((void) key_bitlen); 895 896 return mbedtls_des3_set3key_dec( (mbedtls_des3_context *) ctx, key ); 897 } 898 899 static int des3_set3key_enc_wrap( void *ctx, const unsigned char *key, 900 unsigned int key_bitlen ) 901 { 902 ((void) key_bitlen); 903 904 return mbedtls_des3_set3key_enc( (mbedtls_des3_context *) ctx, key ); 905 } 906 907 static void * des_ctx_alloc( void ) 908 { 909 mbedtls_des_context *des = mbedtls_calloc( 1, sizeof( mbedtls_des_context ) ); 910 911 if( des == NULL ) 912 return( NULL ); 913 914 mbedtls_des_init( des ); 915 916 return( des ); 917 } 918 919 static void des_ctx_free( void *ctx ) 920 { 921 mbedtls_des_free( (mbedtls_des_context *) ctx ); 922 mbedtls_free( ctx ); 923 } 924 925 static void * des3_ctx_alloc( void ) 926 { 927 mbedtls_des3_context *des3; 928 des3 = mbedtls_calloc( 1, sizeof( mbedtls_des3_context ) ); 929 930 if( des3 == NULL ) 931 return( NULL ); 932 933 mbedtls_des3_init( des3 ); 934 935 return( des3 ); 936 } 937 938 static void des3_ctx_free( void *ctx ) 939 { 940 mbedtls_des3_free( (mbedtls_des3_context *) ctx ); 941 mbedtls_free( ctx ); 942 } 943 944 static const mbedtls_cipher_base_t des_info = { 945 MBEDTLS_CIPHER_ID_DES, 946 des_crypt_ecb_wrap, 947 #if defined(MBEDTLS_CIPHER_MODE_CBC) 948 des_crypt_cbc_wrap, 949 #endif 950 #if defined(MBEDTLS_CIPHER_MODE_CFB) 951 NULL, 952 #endif 953 #if defined(MBEDTLS_CIPHER_MODE_CTR) 954 NULL, 955 #endif 956 #if defined(MBEDTLS_CIPHER_MODE_STREAM) 957 NULL, 958 #endif 959 des_setkey_enc_wrap, 960 des_setkey_dec_wrap, 961 des_ctx_alloc, 962 des_ctx_free 963 }; 964 965 static const mbedtls_cipher_info_t des_ecb_info = { 966 MBEDTLS_CIPHER_DES_ECB, 967 MBEDTLS_MODE_ECB, 968 MBEDTLS_KEY_LENGTH_DES, 969 "DES-ECB", 970 8, 971 0, 972 8, 973 &des_info 974 }; 975 976 #if defined(MBEDTLS_CIPHER_MODE_CBC) 977 static const mbedtls_cipher_info_t des_cbc_info = { 978 MBEDTLS_CIPHER_DES_CBC, 979 MBEDTLS_MODE_CBC, 980 MBEDTLS_KEY_LENGTH_DES, 981 "DES-CBC", 982 8, 983 0, 984 8, 985 &des_info 986 }; 987 #endif /* MBEDTLS_CIPHER_MODE_CBC */ 988 989 static const mbedtls_cipher_base_t des_ede_info = { 990 MBEDTLS_CIPHER_ID_DES, 991 des3_crypt_ecb_wrap, 992 #if defined(MBEDTLS_CIPHER_MODE_CBC) 993 des3_crypt_cbc_wrap, 994 #endif 995 #if defined(MBEDTLS_CIPHER_MODE_CFB) 996 NULL, 997 #endif 998 #if defined(MBEDTLS_CIPHER_MODE_CTR) 999 NULL, 1000 #endif 1001 #if defined(MBEDTLS_CIPHER_MODE_STREAM) 1002 NULL, 1003 #endif 1004 des3_set2key_enc_wrap, 1005 des3_set2key_dec_wrap, 1006 des3_ctx_alloc, 1007 des3_ctx_free 1008 }; 1009 1010 static const mbedtls_cipher_info_t des_ede_ecb_info = { 1011 MBEDTLS_CIPHER_DES_EDE_ECB, 1012 MBEDTLS_MODE_ECB, 1013 MBEDTLS_KEY_LENGTH_DES_EDE, 1014 "DES-EDE-ECB", 1015 8, 1016 0, 1017 8, 1018 &des_ede_info 1019 }; 1020 1021 #if defined(MBEDTLS_CIPHER_MODE_CBC) 1022 static const mbedtls_cipher_info_t des_ede_cbc_info = { 1023 MBEDTLS_CIPHER_DES_EDE_CBC, 1024 MBEDTLS_MODE_CBC, 1025 MBEDTLS_KEY_LENGTH_DES_EDE, 1026 "DES-EDE-CBC", 1027 8, 1028 0, 1029 8, 1030 &des_ede_info 1031 }; 1032 #endif /* MBEDTLS_CIPHER_MODE_CBC */ 1033 1034 static const mbedtls_cipher_base_t des_ede3_info = { 1035 MBEDTLS_CIPHER_ID_3DES, 1036 des3_crypt_ecb_wrap, 1037 #if defined(MBEDTLS_CIPHER_MODE_CBC) 1038 des3_crypt_cbc_wrap, 1039 #endif 1040 #if defined(MBEDTLS_CIPHER_MODE_CFB) 1041 NULL, 1042 #endif 1043 #if defined(MBEDTLS_CIPHER_MODE_CTR) 1044 NULL, 1045 #endif 1046 #if defined(MBEDTLS_CIPHER_MODE_STREAM) 1047 NULL, 1048 #endif 1049 des3_set3key_enc_wrap, 1050 des3_set3key_dec_wrap, 1051 des3_ctx_alloc, 1052 des3_ctx_free 1053 }; 1054 1055 static const mbedtls_cipher_info_t des_ede3_ecb_info = { 1056 MBEDTLS_CIPHER_DES_EDE3_ECB, 1057 MBEDTLS_MODE_ECB, 1058 MBEDTLS_KEY_LENGTH_DES_EDE3, 1059 "DES-EDE3-ECB", 1060 8, 1061 0, 1062 8, 1063 &des_ede3_info 1064 }; 1065 #if defined(MBEDTLS_CIPHER_MODE_CBC) 1066 static const mbedtls_cipher_info_t des_ede3_cbc_info = { 1067 MBEDTLS_CIPHER_DES_EDE3_CBC, 1068 MBEDTLS_MODE_CBC, 1069 MBEDTLS_KEY_LENGTH_DES_EDE3, 1070 "DES-EDE3-CBC", 1071 8, 1072 0, 1073 8, 1074 &des_ede3_info 1075 }; 1076 #endif /* MBEDTLS_CIPHER_MODE_CBC */ 1077 #endif /* MBEDTLS_DES_C */ 1078 1079 #if defined(MBEDTLS_BLOWFISH_C) 1080 1081 static int blowfish_crypt_ecb_wrap( void *ctx, mbedtls_operation_t operation, 1082 const unsigned char *input, unsigned char *output ) 1083 { 1084 return mbedtls_blowfish_crypt_ecb( (mbedtls_blowfish_context *) ctx, operation, input, 1085 output ); 1086 } 1087 1088 #if defined(MBEDTLS_CIPHER_MODE_CBC) 1089 static int blowfish_crypt_cbc_wrap( void *ctx, mbedtls_operation_t operation, 1090 size_t length, unsigned char *iv, const unsigned char *input, 1091 unsigned char *output ) 1092 { 1093 return mbedtls_blowfish_crypt_cbc( (mbedtls_blowfish_context *) ctx, operation, length, iv, 1094 input, output ); 1095 } 1096 #endif /* MBEDTLS_CIPHER_MODE_CBC */ 1097 1098 #if defined(MBEDTLS_CIPHER_MODE_CFB) 1099 static int blowfish_crypt_cfb64_wrap( void *ctx, mbedtls_operation_t operation, 1100 size_t length, size_t *iv_off, unsigned char *iv, 1101 const unsigned char *input, unsigned char *output ) 1102 { 1103 return mbedtls_blowfish_crypt_cfb64( (mbedtls_blowfish_context *) ctx, operation, length, 1104 iv_off, iv, input, output ); 1105 } 1106 #endif /* MBEDTLS_CIPHER_MODE_CFB */ 1107 1108 #if defined(MBEDTLS_CIPHER_MODE_CTR) 1109 static int blowfish_crypt_ctr_wrap( void *ctx, size_t length, size_t *nc_off, 1110 unsigned char *nonce_counter, unsigned char *stream_block, 1111 const unsigned char *input, unsigned char *output ) 1112 { 1113 return mbedtls_blowfish_crypt_ctr( (mbedtls_blowfish_context *) ctx, length, nc_off, 1114 nonce_counter, stream_block, input, output ); 1115 } 1116 #endif /* MBEDTLS_CIPHER_MODE_CTR */ 1117 1118 static int blowfish_setkey_wrap( void *ctx, const unsigned char *key, 1119 unsigned int key_bitlen ) 1120 { 1121 return mbedtls_blowfish_setkey( (mbedtls_blowfish_context *) ctx, key, key_bitlen ); 1122 } 1123 1124 static void * blowfish_ctx_alloc( void ) 1125 { 1126 mbedtls_blowfish_context *ctx; 1127 ctx = mbedtls_calloc( 1, sizeof( mbedtls_blowfish_context ) ); 1128 1129 if( ctx == NULL ) 1130 return( NULL ); 1131 1132 mbedtls_blowfish_init( ctx ); 1133 1134 return( ctx ); 1135 } 1136 1137 static void blowfish_ctx_free( void *ctx ) 1138 { 1139 mbedtls_blowfish_free( (mbedtls_blowfish_context *) ctx ); 1140 mbedtls_free( ctx ); 1141 } 1142 1143 static const mbedtls_cipher_base_t blowfish_info = { 1144 MBEDTLS_CIPHER_ID_BLOWFISH, 1145 blowfish_crypt_ecb_wrap, 1146 #if defined(MBEDTLS_CIPHER_MODE_CBC) 1147 blowfish_crypt_cbc_wrap, 1148 #endif 1149 #if defined(MBEDTLS_CIPHER_MODE_CFB) 1150 blowfish_crypt_cfb64_wrap, 1151 #endif 1152 #if defined(MBEDTLS_CIPHER_MODE_CTR) 1153 blowfish_crypt_ctr_wrap, 1154 #endif 1155 #if defined(MBEDTLS_CIPHER_MODE_STREAM) 1156 NULL, 1157 #endif 1158 blowfish_setkey_wrap, 1159 blowfish_setkey_wrap, 1160 blowfish_ctx_alloc, 1161 blowfish_ctx_free 1162 }; 1163 1164 static const mbedtls_cipher_info_t blowfish_ecb_info = { 1165 MBEDTLS_CIPHER_BLOWFISH_ECB, 1166 MBEDTLS_MODE_ECB, 1167 128, 1168 "BLOWFISH-ECB", 1169 8, 1170 MBEDTLS_CIPHER_VARIABLE_KEY_LEN, 1171 8, 1172 &blowfish_info 1173 }; 1174 1175 #if defined(MBEDTLS_CIPHER_MODE_CBC) 1176 static const mbedtls_cipher_info_t blowfish_cbc_info = { 1177 MBEDTLS_CIPHER_BLOWFISH_CBC, 1178 MBEDTLS_MODE_CBC, 1179 128, 1180 "BLOWFISH-CBC", 1181 8, 1182 MBEDTLS_CIPHER_VARIABLE_KEY_LEN, 1183 8, 1184 &blowfish_info 1185 }; 1186 #endif /* MBEDTLS_CIPHER_MODE_CBC */ 1187 1188 #if defined(MBEDTLS_CIPHER_MODE_CFB) 1189 static const mbedtls_cipher_info_t blowfish_cfb64_info = { 1190 MBEDTLS_CIPHER_BLOWFISH_CFB64, 1191 MBEDTLS_MODE_CFB, 1192 128, 1193 "BLOWFISH-CFB64", 1194 8, 1195 MBEDTLS_CIPHER_VARIABLE_KEY_LEN, 1196 8, 1197 &blowfish_info 1198 }; 1199 #endif /* MBEDTLS_CIPHER_MODE_CFB */ 1200 1201 #if defined(MBEDTLS_CIPHER_MODE_CTR) 1202 static const mbedtls_cipher_info_t blowfish_ctr_info = { 1203 MBEDTLS_CIPHER_BLOWFISH_CTR, 1204 MBEDTLS_MODE_CTR, 1205 128, 1206 "BLOWFISH-CTR", 1207 8, 1208 MBEDTLS_CIPHER_VARIABLE_KEY_LEN, 1209 8, 1210 &blowfish_info 1211 }; 1212 #endif /* MBEDTLS_CIPHER_MODE_CTR */ 1213 #endif /* MBEDTLS_BLOWFISH_C */ 1214 1215 #if defined(MBEDTLS_ARC4_C) 1216 static int arc4_crypt_stream_wrap( void *ctx, size_t length, 1217 const unsigned char *input, 1218 unsigned char *output ) 1219 { 1220 return( mbedtls_arc4_crypt( (mbedtls_arc4_context *) ctx, length, input, output ) ); 1221 } 1222 1223 static int arc4_setkey_wrap( void *ctx, const unsigned char *key, 1224 unsigned int key_bitlen ) 1225 { 1226 /* we get key_bitlen in bits, arc4 expects it in bytes */ 1227 if( key_bitlen % 8 != 0 ) 1228 return( MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA ); 1229 1230 mbedtls_arc4_setup( (mbedtls_arc4_context *) ctx, key, key_bitlen / 8 ); 1231 return( 0 ); 1232 } 1233 1234 static void * arc4_ctx_alloc( void ) 1235 { 1236 mbedtls_arc4_context *ctx; 1237 ctx = mbedtls_calloc( 1, sizeof( mbedtls_arc4_context ) ); 1238 1239 if( ctx == NULL ) 1240 return( NULL ); 1241 1242 mbedtls_arc4_init( ctx ); 1243 1244 return( ctx ); 1245 } 1246 1247 static void arc4_ctx_free( void *ctx ) 1248 { 1249 mbedtls_arc4_free( (mbedtls_arc4_context *) ctx ); 1250 mbedtls_free( ctx ); 1251 } 1252 1253 static const mbedtls_cipher_base_t arc4_base_info = { 1254 MBEDTLS_CIPHER_ID_ARC4, 1255 NULL, 1256 #if defined(MBEDTLS_CIPHER_MODE_CBC) 1257 NULL, 1258 #endif 1259 #if defined(MBEDTLS_CIPHER_MODE_CFB) 1260 NULL, 1261 #endif 1262 #if defined(MBEDTLS_CIPHER_MODE_CTR) 1263 NULL, 1264 #endif 1265 #if defined(MBEDTLS_CIPHER_MODE_STREAM) 1266 arc4_crypt_stream_wrap, 1267 #endif 1268 arc4_setkey_wrap, 1269 arc4_setkey_wrap, 1270 arc4_ctx_alloc, 1271 arc4_ctx_free 1272 }; 1273 1274 static const mbedtls_cipher_info_t arc4_128_info = { 1275 MBEDTLS_CIPHER_ARC4_128, 1276 MBEDTLS_MODE_STREAM, 1277 128, 1278 "ARC4-128", 1279 0, 1280 0, 1281 1, 1282 &arc4_base_info 1283 }; 1284 #endif /* MBEDTLS_ARC4_C */ 1285 1286 #if defined(MBEDTLS_CIPHER_NULL_CIPHER) 1287 static int null_crypt_stream( void *ctx, size_t length, 1288 const unsigned char *input, 1289 unsigned char *output ) 1290 { 1291 ((void) ctx); 1292 memmove( output, input, length ); 1293 return( 0 ); 1294 } 1295 1296 static int null_setkey( void *ctx, const unsigned char *key, 1297 unsigned int key_bitlen ) 1298 { 1299 ((void) ctx); 1300 ((void) key); 1301 ((void) key_bitlen); 1302 1303 return( 0 ); 1304 } 1305 1306 static void * null_ctx_alloc( void ) 1307 { 1308 return( (void *) 1 ); 1309 } 1310 1311 static void null_ctx_free( void *ctx ) 1312 { 1313 ((void) ctx); 1314 } 1315 1316 static const mbedtls_cipher_base_t null_base_info = { 1317 MBEDTLS_CIPHER_ID_NULL, 1318 NULL, 1319 #if defined(MBEDTLS_CIPHER_MODE_CBC) 1320 NULL, 1321 #endif 1322 #if defined(MBEDTLS_CIPHER_MODE_CFB) 1323 NULL, 1324 #endif 1325 #if defined(MBEDTLS_CIPHER_MODE_CTR) 1326 NULL, 1327 #endif 1328 #if defined(MBEDTLS_CIPHER_MODE_STREAM) 1329 null_crypt_stream, 1330 #endif 1331 null_setkey, 1332 null_setkey, 1333 null_ctx_alloc, 1334 null_ctx_free 1335 }; 1336 1337 static const mbedtls_cipher_info_t null_cipher_info = { 1338 MBEDTLS_CIPHER_NULL, 1339 MBEDTLS_MODE_STREAM, 1340 0, 1341 "NULL", 1342 0, 1343 0, 1344 1, 1345 &null_base_info 1346 }; 1347 #endif /* defined(MBEDTLS_CIPHER_NULL_CIPHER) */ 1348 1349 const mbedtls_cipher_definition_t mbedtls_cipher_definitions[] = 1350 { 1351 #if defined(MBEDTLS_AES_C) 1352 { MBEDTLS_CIPHER_AES_128_ECB, &aes_128_ecb_info }, 1353 { MBEDTLS_CIPHER_AES_192_ECB, &aes_192_ecb_info }, 1354 { MBEDTLS_CIPHER_AES_256_ECB, &aes_256_ecb_info }, 1355 #if defined(MBEDTLS_CIPHER_MODE_CBC) 1356 { MBEDTLS_CIPHER_AES_128_CBC, &aes_128_cbc_info }, 1357 { MBEDTLS_CIPHER_AES_192_CBC, &aes_192_cbc_info }, 1358 { MBEDTLS_CIPHER_AES_256_CBC, &aes_256_cbc_info }, 1359 #endif 1360 #if defined(MBEDTLS_CIPHER_MODE_CFB) 1361 { MBEDTLS_CIPHER_AES_128_CFB128, &aes_128_cfb128_info }, 1362 { MBEDTLS_CIPHER_AES_192_CFB128, &aes_192_cfb128_info }, 1363 { MBEDTLS_CIPHER_AES_256_CFB128, &aes_256_cfb128_info }, 1364 #endif 1365 #if defined(MBEDTLS_CIPHER_MODE_CTR) 1366 { MBEDTLS_CIPHER_AES_128_CTR, &aes_128_ctr_info }, 1367 { MBEDTLS_CIPHER_AES_192_CTR, &aes_192_ctr_info }, 1368 { MBEDTLS_CIPHER_AES_256_CTR, &aes_256_ctr_info }, 1369 #endif 1370 #if defined(MBEDTLS_GCM_C) 1371 { MBEDTLS_CIPHER_AES_128_GCM, &aes_128_gcm_info }, 1372 { MBEDTLS_CIPHER_AES_192_GCM, &aes_192_gcm_info }, 1373 { MBEDTLS_CIPHER_AES_256_GCM, &aes_256_gcm_info }, 1374 #endif 1375 #if defined(MBEDTLS_CCM_C) 1376 { MBEDTLS_CIPHER_AES_128_CCM, &aes_128_ccm_info }, 1377 { MBEDTLS_CIPHER_AES_192_CCM, &aes_192_ccm_info }, 1378 { MBEDTLS_CIPHER_AES_256_CCM, &aes_256_ccm_info }, 1379 #endif 1380 #endif /* MBEDTLS_AES_C */ 1381 1382 #if defined(MBEDTLS_ARC4_C) 1383 { MBEDTLS_CIPHER_ARC4_128, &arc4_128_info }, 1384 #endif 1385 1386 #if defined(MBEDTLS_BLOWFISH_C) 1387 { MBEDTLS_CIPHER_BLOWFISH_ECB, &blowfish_ecb_info }, 1388 #if defined(MBEDTLS_CIPHER_MODE_CBC) 1389 { MBEDTLS_CIPHER_BLOWFISH_CBC, &blowfish_cbc_info }, 1390 #endif 1391 #if defined(MBEDTLS_CIPHER_MODE_CFB) 1392 { MBEDTLS_CIPHER_BLOWFISH_CFB64, &blowfish_cfb64_info }, 1393 #endif 1394 #if defined(MBEDTLS_CIPHER_MODE_CTR) 1395 { MBEDTLS_CIPHER_BLOWFISH_CTR, &blowfish_ctr_info }, 1396 #endif 1397 #endif /* MBEDTLS_BLOWFISH_C */ 1398 1399 #if defined(MBEDTLS_CAMELLIA_C) 1400 { MBEDTLS_CIPHER_CAMELLIA_128_ECB, &camellia_128_ecb_info }, 1401 { MBEDTLS_CIPHER_CAMELLIA_192_ECB, &camellia_192_ecb_info }, 1402 { MBEDTLS_CIPHER_CAMELLIA_256_ECB, &camellia_256_ecb_info }, 1403 #if defined(MBEDTLS_CIPHER_MODE_CBC) 1404 { MBEDTLS_CIPHER_CAMELLIA_128_CBC, &camellia_128_cbc_info }, 1405 { MBEDTLS_CIPHER_CAMELLIA_192_CBC, &camellia_192_cbc_info }, 1406 { MBEDTLS_CIPHER_CAMELLIA_256_CBC, &camellia_256_cbc_info }, 1407 #endif 1408 #if defined(MBEDTLS_CIPHER_MODE_CFB) 1409 { MBEDTLS_CIPHER_CAMELLIA_128_CFB128, &camellia_128_cfb128_info }, 1410 { MBEDTLS_CIPHER_CAMELLIA_192_CFB128, &camellia_192_cfb128_info }, 1411 { MBEDTLS_CIPHER_CAMELLIA_256_CFB128, &camellia_256_cfb128_info }, 1412 #endif 1413 #if defined(MBEDTLS_CIPHER_MODE_CTR) 1414 { MBEDTLS_CIPHER_CAMELLIA_128_CTR, &camellia_128_ctr_info }, 1415 { MBEDTLS_CIPHER_CAMELLIA_192_CTR, &camellia_192_ctr_info }, 1416 { MBEDTLS_CIPHER_CAMELLIA_256_CTR, &camellia_256_ctr_info }, 1417 #endif 1418 #if defined(MBEDTLS_GCM_C) 1419 { MBEDTLS_CIPHER_CAMELLIA_128_GCM, &camellia_128_gcm_info }, 1420 { MBEDTLS_CIPHER_CAMELLIA_192_GCM, &camellia_192_gcm_info }, 1421 { MBEDTLS_CIPHER_CAMELLIA_256_GCM, &camellia_256_gcm_info }, 1422 #endif 1423 #if defined(MBEDTLS_CCM_C) 1424 { MBEDTLS_CIPHER_CAMELLIA_128_CCM, &camellia_128_ccm_info }, 1425 { MBEDTLS_CIPHER_CAMELLIA_192_CCM, &camellia_192_ccm_info }, 1426 { MBEDTLS_CIPHER_CAMELLIA_256_CCM, &camellia_256_ccm_info }, 1427 #endif 1428 #endif /* MBEDTLS_CAMELLIA_C */ 1429 1430 #if defined(MBEDTLS_DES_C) 1431 { MBEDTLS_CIPHER_DES_ECB, &des_ecb_info }, 1432 { MBEDTLS_CIPHER_DES_EDE_ECB, &des_ede_ecb_info }, 1433 { MBEDTLS_CIPHER_DES_EDE3_ECB, &des_ede3_ecb_info }, 1434 #if defined(MBEDTLS_CIPHER_MODE_CBC) 1435 { MBEDTLS_CIPHER_DES_CBC, &des_cbc_info }, 1436 { MBEDTLS_CIPHER_DES_EDE_CBC, &des_ede_cbc_info }, 1437 { MBEDTLS_CIPHER_DES_EDE3_CBC, &des_ede3_cbc_info }, 1438 #endif 1439 #endif /* MBEDTLS_DES_C */ 1440 1441 #if defined(MBEDTLS_CIPHER_NULL_CIPHER) 1442 { MBEDTLS_CIPHER_NULL, &null_cipher_info }, 1443 #endif /* MBEDTLS_CIPHER_NULL_CIPHER */ 1444 1445 { MBEDTLS_CIPHER_NONE, NULL } 1446 }; 1447 1448 #define NUM_CIPHERS sizeof mbedtls_cipher_definitions / sizeof mbedtls_cipher_definitions[0] 1449 int mbedtls_cipher_supported[NUM_CIPHERS]; 1450 1451 #endif /* MBEDTLS_CIPHER_C */ 1452