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