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