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