1 /* Copyright (c) 2014, Google Inc. 2 * 3 * Permission to use, copy, modify, and/or distribute this software for any 4 * purpose with or without fee is hereby granted, provided that the above 5 * copyright notice and this permission notice appear in all copies. 6 * 7 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES 8 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF 9 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY 10 * SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES 11 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION 12 * OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN 13 * CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. */ 14 15 #include <assert.h> 16 #include <limits.h> 17 #include <string.h> 18 19 #include <openssl/aead.h> 20 #include <openssl/cipher.h> 21 #include <openssl/err.h> 22 #include <openssl/hmac.h> 23 #include <openssl/md5.h> 24 #include <openssl/mem.h> 25 #include <openssl/sha.h> 26 #include <openssl/type_check.h> 27 28 #include "../fipsmodule/cipher/internal.h" 29 #include "../internal.h" 30 #include "internal.h" 31 32 33 typedef struct { 34 EVP_CIPHER_CTX cipher_ctx; 35 HMAC_CTX hmac_ctx; 36 // mac_key is the portion of the key used for the MAC. It is retained 37 // separately for the constant-time CBC code. 38 uint8_t mac_key[EVP_MAX_MD_SIZE]; 39 uint8_t mac_key_len; 40 // implicit_iv is one iff this is a pre-TLS-1.1 CBC cipher without an explicit 41 // IV. 42 char implicit_iv; 43 } AEAD_TLS_CTX; 44 45 OPENSSL_COMPILE_ASSERT(EVP_MAX_MD_SIZE < 256, mac_key_len_fits_in_uint8_t); 46 47 static void aead_tls_cleanup(EVP_AEAD_CTX *ctx) { 48 AEAD_TLS_CTX *tls_ctx = (AEAD_TLS_CTX *)ctx->aead_state; 49 EVP_CIPHER_CTX_cleanup(&tls_ctx->cipher_ctx); 50 HMAC_CTX_cleanup(&tls_ctx->hmac_ctx); 51 OPENSSL_free(tls_ctx); 52 ctx->aead_state = NULL; 53 } 54 55 static int aead_tls_init(EVP_AEAD_CTX *ctx, const uint8_t *key, size_t key_len, 56 size_t tag_len, enum evp_aead_direction_t dir, 57 const EVP_CIPHER *cipher, const EVP_MD *md, 58 char implicit_iv) { 59 if (tag_len != EVP_AEAD_DEFAULT_TAG_LENGTH && 60 tag_len != EVP_MD_size(md)) { 61 OPENSSL_PUT_ERROR(CIPHER, CIPHER_R_UNSUPPORTED_TAG_SIZE); 62 return 0; 63 } 64 65 if (key_len != EVP_AEAD_key_length(ctx->aead)) { 66 OPENSSL_PUT_ERROR(CIPHER, CIPHER_R_BAD_KEY_LENGTH); 67 return 0; 68 } 69 70 size_t mac_key_len = EVP_MD_size(md); 71 size_t enc_key_len = EVP_CIPHER_key_length(cipher); 72 assert(mac_key_len + enc_key_len + 73 (implicit_iv ? EVP_CIPHER_iv_length(cipher) : 0) == key_len); 74 75 AEAD_TLS_CTX *tls_ctx = OPENSSL_malloc(sizeof(AEAD_TLS_CTX)); 76 if (tls_ctx == NULL) { 77 OPENSSL_PUT_ERROR(CIPHER, ERR_R_MALLOC_FAILURE); 78 return 0; 79 } 80 EVP_CIPHER_CTX_init(&tls_ctx->cipher_ctx); 81 HMAC_CTX_init(&tls_ctx->hmac_ctx); 82 assert(mac_key_len <= EVP_MAX_MD_SIZE); 83 OPENSSL_memcpy(tls_ctx->mac_key, key, mac_key_len); 84 tls_ctx->mac_key_len = (uint8_t)mac_key_len; 85 tls_ctx->implicit_iv = implicit_iv; 86 87 ctx->aead_state = tls_ctx; 88 if (!EVP_CipherInit_ex(&tls_ctx->cipher_ctx, cipher, NULL, &key[mac_key_len], 89 implicit_iv ? &key[mac_key_len + enc_key_len] : NULL, 90 dir == evp_aead_seal) || 91 !HMAC_Init_ex(&tls_ctx->hmac_ctx, key, mac_key_len, md, NULL)) { 92 aead_tls_cleanup(ctx); 93 ctx->aead_state = NULL; 94 return 0; 95 } 96 EVP_CIPHER_CTX_set_padding(&tls_ctx->cipher_ctx, 0); 97 98 return 1; 99 } 100 101 static size_t aead_tls_tag_len(const EVP_AEAD_CTX *ctx, const size_t in_len, 102 const size_t extra_in_len) { 103 assert(extra_in_len == 0); 104 AEAD_TLS_CTX *tls_ctx = (AEAD_TLS_CTX *)ctx->aead_state; 105 106 const size_t hmac_len = HMAC_size(&tls_ctx->hmac_ctx); 107 if (EVP_CIPHER_CTX_mode(&tls_ctx->cipher_ctx) != EVP_CIPH_CBC_MODE) { 108 // The NULL cipher. 109 return hmac_len; 110 } 111 112 const size_t block_size = EVP_CIPHER_CTX_block_size(&tls_ctx->cipher_ctx); 113 // An overflow of |in_len + hmac_len| doesn't affect the result mod 114 // |block_size|, provided that |block_size| is a smaller power of two. 115 assert(block_size != 0 && (block_size & (block_size - 1)) == 0); 116 const size_t pad_len = block_size - (in_len + hmac_len) % block_size; 117 return hmac_len + pad_len; 118 } 119 120 static int aead_tls_seal_scatter(const EVP_AEAD_CTX *ctx, uint8_t *out, 121 uint8_t *out_tag, size_t *out_tag_len, 122 const size_t max_out_tag_len, 123 const uint8_t *nonce, const size_t nonce_len, 124 const uint8_t *in, const size_t in_len, 125 const uint8_t *extra_in, 126 const size_t extra_in_len, const uint8_t *ad, 127 const size_t ad_len) { 128 AEAD_TLS_CTX *tls_ctx = (AEAD_TLS_CTX *)ctx->aead_state; 129 130 if (!tls_ctx->cipher_ctx.encrypt) { 131 // Unlike a normal AEAD, a TLS AEAD may only be used in one direction. 132 OPENSSL_PUT_ERROR(CIPHER, CIPHER_R_INVALID_OPERATION); 133 return 0; 134 } 135 136 if (in_len > INT_MAX) { 137 // EVP_CIPHER takes int as input. 138 OPENSSL_PUT_ERROR(CIPHER, CIPHER_R_TOO_LARGE); 139 return 0; 140 } 141 142 if (max_out_tag_len < aead_tls_tag_len(ctx, in_len, extra_in_len)) { 143 OPENSSL_PUT_ERROR(CIPHER, CIPHER_R_BUFFER_TOO_SMALL); 144 return 0; 145 } 146 147 if (nonce_len != EVP_AEAD_nonce_length(ctx->aead)) { 148 OPENSSL_PUT_ERROR(CIPHER, CIPHER_R_INVALID_NONCE_SIZE); 149 return 0; 150 } 151 152 if (ad_len != 13 - 2 /* length bytes */) { 153 OPENSSL_PUT_ERROR(CIPHER, CIPHER_R_INVALID_AD_SIZE); 154 return 0; 155 } 156 157 // To allow for CBC mode which changes cipher length, |ad| doesn't include the 158 // length for legacy ciphers. 159 uint8_t ad_extra[2]; 160 ad_extra[0] = (uint8_t)(in_len >> 8); 161 ad_extra[1] = (uint8_t)(in_len & 0xff); 162 163 // Compute the MAC. This must be first in case the operation is being done 164 // in-place. 165 uint8_t mac[EVP_MAX_MD_SIZE]; 166 unsigned mac_len; 167 if (!HMAC_Init_ex(&tls_ctx->hmac_ctx, NULL, 0, NULL, NULL) || 168 !HMAC_Update(&tls_ctx->hmac_ctx, ad, ad_len) || 169 !HMAC_Update(&tls_ctx->hmac_ctx, ad_extra, sizeof(ad_extra)) || 170 !HMAC_Update(&tls_ctx->hmac_ctx, in, in_len) || 171 !HMAC_Final(&tls_ctx->hmac_ctx, mac, &mac_len)) { 172 return 0; 173 } 174 175 // Configure the explicit IV. 176 if (EVP_CIPHER_CTX_mode(&tls_ctx->cipher_ctx) == EVP_CIPH_CBC_MODE && 177 !tls_ctx->implicit_iv && 178 !EVP_EncryptInit_ex(&tls_ctx->cipher_ctx, NULL, NULL, NULL, nonce)) { 179 return 0; 180 } 181 182 // Encrypt the input. 183 int len; 184 if (!EVP_EncryptUpdate(&tls_ctx->cipher_ctx, out, &len, in, (int)in_len)) { 185 return 0; 186 } 187 188 unsigned block_size = EVP_CIPHER_CTX_block_size(&tls_ctx->cipher_ctx); 189 190 // Feed the MAC into the cipher in two steps. First complete the final partial 191 // block from encrypting the input and split the result between |out| and 192 // |out_tag|. Then feed the rest. 193 194 const size_t early_mac_len = (block_size - (in_len % block_size)) % block_size; 195 if (early_mac_len != 0) { 196 assert(len + block_size - early_mac_len == in_len); 197 uint8_t buf[EVP_MAX_BLOCK_LENGTH]; 198 int buf_len; 199 if (!EVP_EncryptUpdate(&tls_ctx->cipher_ctx, buf, &buf_len, mac, 200 (int)early_mac_len)) { 201 return 0; 202 } 203 assert(buf_len == (int)block_size); 204 OPENSSL_memcpy(out + len, buf, block_size - early_mac_len); 205 OPENSSL_memcpy(out_tag, buf + block_size - early_mac_len, early_mac_len); 206 } 207 size_t tag_len = early_mac_len; 208 209 if (!EVP_EncryptUpdate(&tls_ctx->cipher_ctx, out_tag + tag_len, &len, 210 mac + tag_len, mac_len - tag_len)) { 211 return 0; 212 } 213 tag_len += len; 214 215 if (block_size > 1) { 216 assert(block_size <= 256); 217 assert(EVP_CIPHER_CTX_mode(&tls_ctx->cipher_ctx) == EVP_CIPH_CBC_MODE); 218 219 // Compute padding and feed that into the cipher. 220 uint8_t padding[256]; 221 unsigned padding_len = block_size - ((in_len + mac_len) % block_size); 222 OPENSSL_memset(padding, padding_len - 1, padding_len); 223 if (!EVP_EncryptUpdate(&tls_ctx->cipher_ctx, out_tag + tag_len, &len, 224 padding, (int)padding_len)) { 225 return 0; 226 } 227 tag_len += len; 228 } 229 230 if (!EVP_EncryptFinal_ex(&tls_ctx->cipher_ctx, out_tag + tag_len, &len)) { 231 return 0; 232 } 233 assert(len == 0); // Padding is explicit. 234 assert(tag_len == aead_tls_tag_len(ctx, in_len, extra_in_len)); 235 236 *out_tag_len = tag_len; 237 return 1; 238 } 239 240 static int aead_tls_open(const EVP_AEAD_CTX *ctx, uint8_t *out, size_t *out_len, 241 size_t max_out_len, const uint8_t *nonce, 242 size_t nonce_len, const uint8_t *in, size_t in_len, 243 const uint8_t *ad, size_t ad_len) { 244 AEAD_TLS_CTX *tls_ctx = (AEAD_TLS_CTX *)ctx->aead_state; 245 246 if (tls_ctx->cipher_ctx.encrypt) { 247 // Unlike a normal AEAD, a TLS AEAD may only be used in one direction. 248 OPENSSL_PUT_ERROR(CIPHER, CIPHER_R_INVALID_OPERATION); 249 return 0; 250 } 251 252 if (in_len < HMAC_size(&tls_ctx->hmac_ctx)) { 253 OPENSSL_PUT_ERROR(CIPHER, CIPHER_R_BAD_DECRYPT); 254 return 0; 255 } 256 257 if (max_out_len < in_len) { 258 // This requires that the caller provide space for the MAC, even though it 259 // will always be removed on return. 260 OPENSSL_PUT_ERROR(CIPHER, CIPHER_R_BUFFER_TOO_SMALL); 261 return 0; 262 } 263 264 if (nonce_len != EVP_AEAD_nonce_length(ctx->aead)) { 265 OPENSSL_PUT_ERROR(CIPHER, CIPHER_R_INVALID_NONCE_SIZE); 266 return 0; 267 } 268 269 if (ad_len != 13 - 2 /* length bytes */) { 270 OPENSSL_PUT_ERROR(CIPHER, CIPHER_R_INVALID_AD_SIZE); 271 return 0; 272 } 273 274 if (in_len > INT_MAX) { 275 // EVP_CIPHER takes int as input. 276 OPENSSL_PUT_ERROR(CIPHER, CIPHER_R_TOO_LARGE); 277 return 0; 278 } 279 280 // Configure the explicit IV. 281 if (EVP_CIPHER_CTX_mode(&tls_ctx->cipher_ctx) == EVP_CIPH_CBC_MODE && 282 !tls_ctx->implicit_iv && 283 !EVP_DecryptInit_ex(&tls_ctx->cipher_ctx, NULL, NULL, NULL, nonce)) { 284 return 0; 285 } 286 287 // Decrypt to get the plaintext + MAC + padding. 288 size_t total = 0; 289 int len; 290 if (!EVP_DecryptUpdate(&tls_ctx->cipher_ctx, out, &len, in, (int)in_len)) { 291 return 0; 292 } 293 total += len; 294 if (!EVP_DecryptFinal_ex(&tls_ctx->cipher_ctx, out + total, &len)) { 295 return 0; 296 } 297 total += len; 298 assert(total == in_len); 299 300 // Remove CBC padding. Code from here on is timing-sensitive with respect to 301 // |padding_ok| and |data_plus_mac_len| for CBC ciphers. 302 size_t data_plus_mac_len; 303 crypto_word_t padding_ok; 304 if (EVP_CIPHER_CTX_mode(&tls_ctx->cipher_ctx) == EVP_CIPH_CBC_MODE) { 305 if (!EVP_tls_cbc_remove_padding( 306 &padding_ok, &data_plus_mac_len, out, total, 307 EVP_CIPHER_CTX_block_size(&tls_ctx->cipher_ctx), 308 HMAC_size(&tls_ctx->hmac_ctx))) { 309 // Publicly invalid. This can be rejected in non-constant time. 310 OPENSSL_PUT_ERROR(CIPHER, CIPHER_R_BAD_DECRYPT); 311 return 0; 312 } 313 } else { 314 padding_ok = CONSTTIME_TRUE_W; 315 data_plus_mac_len = total; 316 // |data_plus_mac_len| = |total| = |in_len| at this point. |in_len| has 317 // already been checked against the MAC size at the top of the function. 318 assert(data_plus_mac_len >= HMAC_size(&tls_ctx->hmac_ctx)); 319 } 320 size_t data_len = data_plus_mac_len - HMAC_size(&tls_ctx->hmac_ctx); 321 322 // At this point, if the padding is valid, the first |data_plus_mac_len| bytes 323 // after |out| are the plaintext and MAC. Otherwise, |data_plus_mac_len| is 324 // still large enough to extract a MAC, but it will be irrelevant. 325 326 // To allow for CBC mode which changes cipher length, |ad| doesn't include the 327 // length for legacy ciphers. 328 uint8_t ad_fixed[13]; 329 OPENSSL_memcpy(ad_fixed, ad, 11); 330 ad_fixed[11] = (uint8_t)(data_len >> 8); 331 ad_fixed[12] = (uint8_t)(data_len & 0xff); 332 ad_len += 2; 333 334 // Compute the MAC and extract the one in the record. 335 uint8_t mac[EVP_MAX_MD_SIZE]; 336 size_t mac_len; 337 uint8_t record_mac_tmp[EVP_MAX_MD_SIZE]; 338 uint8_t *record_mac; 339 if (EVP_CIPHER_CTX_mode(&tls_ctx->cipher_ctx) == EVP_CIPH_CBC_MODE && 340 EVP_tls_cbc_record_digest_supported(tls_ctx->hmac_ctx.md)) { 341 if (!EVP_tls_cbc_digest_record(tls_ctx->hmac_ctx.md, mac, &mac_len, 342 ad_fixed, out, data_plus_mac_len, total, 343 tls_ctx->mac_key, tls_ctx->mac_key_len)) { 344 OPENSSL_PUT_ERROR(CIPHER, CIPHER_R_BAD_DECRYPT); 345 return 0; 346 } 347 assert(mac_len == HMAC_size(&tls_ctx->hmac_ctx)); 348 349 record_mac = record_mac_tmp; 350 EVP_tls_cbc_copy_mac(record_mac, mac_len, out, data_plus_mac_len, total); 351 } else { 352 // We should support the constant-time path for all CBC-mode ciphers 353 // implemented. 354 assert(EVP_CIPHER_CTX_mode(&tls_ctx->cipher_ctx) != EVP_CIPH_CBC_MODE); 355 356 unsigned mac_len_u; 357 if (!HMAC_Init_ex(&tls_ctx->hmac_ctx, NULL, 0, NULL, NULL) || 358 !HMAC_Update(&tls_ctx->hmac_ctx, ad_fixed, ad_len) || 359 !HMAC_Update(&tls_ctx->hmac_ctx, out, data_len) || 360 !HMAC_Final(&tls_ctx->hmac_ctx, mac, &mac_len_u)) { 361 return 0; 362 } 363 mac_len = mac_len_u; 364 365 assert(mac_len == HMAC_size(&tls_ctx->hmac_ctx)); 366 record_mac = &out[data_len]; 367 } 368 369 // Perform the MAC check and the padding check in constant-time. It should be 370 // safe to simply perform the padding check first, but it would not be under a 371 // different choice of MAC location on padding failure. See 372 // EVP_tls_cbc_remove_padding. 373 crypto_word_t good = 374 constant_time_eq_int(CRYPTO_memcmp(record_mac, mac, mac_len), 0); 375 good &= padding_ok; 376 if (!good) { 377 OPENSSL_PUT_ERROR(CIPHER, CIPHER_R_BAD_DECRYPT); 378 return 0; 379 } 380 381 // End of timing-sensitive code. 382 383 *out_len = data_len; 384 return 1; 385 } 386 387 static int aead_aes_128_cbc_sha1_tls_init(EVP_AEAD_CTX *ctx, const uint8_t *key, 388 size_t key_len, size_t tag_len, 389 enum evp_aead_direction_t dir) { 390 return aead_tls_init(ctx, key, key_len, tag_len, dir, EVP_aes_128_cbc(), 391 EVP_sha1(), 0); 392 } 393 394 static int aead_aes_128_cbc_sha1_tls_implicit_iv_init( 395 EVP_AEAD_CTX *ctx, const uint8_t *key, size_t key_len, size_t tag_len, 396 enum evp_aead_direction_t dir) { 397 return aead_tls_init(ctx, key, key_len, tag_len, dir, EVP_aes_128_cbc(), 398 EVP_sha1(), 1); 399 } 400 401 static int aead_aes_128_cbc_sha256_tls_init(EVP_AEAD_CTX *ctx, 402 const uint8_t *key, size_t key_len, 403 size_t tag_len, 404 enum evp_aead_direction_t dir) { 405 return aead_tls_init(ctx, key, key_len, tag_len, dir, EVP_aes_128_cbc(), 406 EVP_sha256(), 0); 407 } 408 409 static int aead_aes_256_cbc_sha1_tls_init(EVP_AEAD_CTX *ctx, const uint8_t *key, 410 size_t key_len, size_t tag_len, 411 enum evp_aead_direction_t dir) { 412 return aead_tls_init(ctx, key, key_len, tag_len, dir, EVP_aes_256_cbc(), 413 EVP_sha1(), 0); 414 } 415 416 static int aead_aes_256_cbc_sha1_tls_implicit_iv_init( 417 EVP_AEAD_CTX *ctx, const uint8_t *key, size_t key_len, size_t tag_len, 418 enum evp_aead_direction_t dir) { 419 return aead_tls_init(ctx, key, key_len, tag_len, dir, EVP_aes_256_cbc(), 420 EVP_sha1(), 1); 421 } 422 423 static int aead_aes_256_cbc_sha256_tls_init(EVP_AEAD_CTX *ctx, 424 const uint8_t *key, size_t key_len, 425 size_t tag_len, 426 enum evp_aead_direction_t dir) { 427 return aead_tls_init(ctx, key, key_len, tag_len, dir, EVP_aes_256_cbc(), 428 EVP_sha256(), 0); 429 } 430 431 static int aead_aes_256_cbc_sha384_tls_init(EVP_AEAD_CTX *ctx, 432 const uint8_t *key, size_t key_len, 433 size_t tag_len, 434 enum evp_aead_direction_t dir) { 435 return aead_tls_init(ctx, key, key_len, tag_len, dir, EVP_aes_256_cbc(), 436 EVP_sha384(), 0); 437 } 438 439 static int aead_des_ede3_cbc_sha1_tls_init(EVP_AEAD_CTX *ctx, 440 const uint8_t *key, size_t key_len, 441 size_t tag_len, 442 enum evp_aead_direction_t dir) { 443 return aead_tls_init(ctx, key, key_len, tag_len, dir, EVP_des_ede3_cbc(), 444 EVP_sha1(), 0); 445 } 446 447 static int aead_des_ede3_cbc_sha1_tls_implicit_iv_init( 448 EVP_AEAD_CTX *ctx, const uint8_t *key, size_t key_len, size_t tag_len, 449 enum evp_aead_direction_t dir) { 450 return aead_tls_init(ctx, key, key_len, tag_len, dir, EVP_des_ede3_cbc(), 451 EVP_sha1(), 1); 452 } 453 454 static int aead_tls_get_iv(const EVP_AEAD_CTX *ctx, const uint8_t **out_iv, 455 size_t *out_iv_len) { 456 const AEAD_TLS_CTX *tls_ctx = (AEAD_TLS_CTX*) ctx->aead_state; 457 const size_t iv_len = EVP_CIPHER_CTX_iv_length(&tls_ctx->cipher_ctx); 458 if (iv_len <= 1) { 459 return 0; 460 } 461 462 *out_iv = tls_ctx->cipher_ctx.iv; 463 *out_iv_len = iv_len; 464 return 1; 465 } 466 467 static int aead_null_sha1_tls_init(EVP_AEAD_CTX *ctx, const uint8_t *key, 468 size_t key_len, size_t tag_len, 469 enum evp_aead_direction_t dir) { 470 return aead_tls_init(ctx, key, key_len, tag_len, dir, EVP_enc_null(), 471 EVP_sha1(), 1 /* implicit iv */); 472 } 473 474 static const EVP_AEAD aead_aes_128_cbc_sha1_tls = { 475 SHA_DIGEST_LENGTH + 16, // key len (SHA1 + AES128) 476 16, // nonce len (IV) 477 16 + SHA_DIGEST_LENGTH, // overhead (padding + SHA1) 478 SHA_DIGEST_LENGTH, // max tag length 479 0, // seal_scatter_supports_extra_in 480 481 NULL, // init 482 aead_aes_128_cbc_sha1_tls_init, 483 aead_tls_cleanup, 484 aead_tls_open, 485 aead_tls_seal_scatter, 486 NULL, // open_gather 487 NULL, // get_iv 488 aead_tls_tag_len, 489 }; 490 491 static const EVP_AEAD aead_aes_128_cbc_sha1_tls_implicit_iv = { 492 SHA_DIGEST_LENGTH + 16 + 16, // key len (SHA1 + AES128 + IV) 493 0, // nonce len 494 16 + SHA_DIGEST_LENGTH, // overhead (padding + SHA1) 495 SHA_DIGEST_LENGTH, // max tag length 496 0, // seal_scatter_supports_extra_in 497 498 NULL, // init 499 aead_aes_128_cbc_sha1_tls_implicit_iv_init, 500 aead_tls_cleanup, 501 aead_tls_open, 502 aead_tls_seal_scatter, 503 NULL, // open_gather 504 aead_tls_get_iv, // get_iv 505 aead_tls_tag_len, 506 }; 507 508 static const EVP_AEAD aead_aes_128_cbc_sha256_tls = { 509 SHA256_DIGEST_LENGTH + 16, // key len (SHA256 + AES128) 510 16, // nonce len (IV) 511 16 + SHA256_DIGEST_LENGTH, // overhead (padding + SHA256) 512 SHA256_DIGEST_LENGTH, // max tag length 513 0, // seal_scatter_supports_extra_in 514 515 NULL, // init 516 aead_aes_128_cbc_sha256_tls_init, 517 aead_tls_cleanup, 518 aead_tls_open, 519 aead_tls_seal_scatter, 520 NULL, // open_gather 521 NULL, // get_iv 522 aead_tls_tag_len, 523 }; 524 525 static const EVP_AEAD aead_aes_256_cbc_sha1_tls = { 526 SHA_DIGEST_LENGTH + 32, // key len (SHA1 + AES256) 527 16, // nonce len (IV) 528 16 + SHA_DIGEST_LENGTH, // overhead (padding + SHA1) 529 SHA_DIGEST_LENGTH, // max tag length 530 0, // seal_scatter_supports_extra_in 531 532 NULL, // init 533 aead_aes_256_cbc_sha1_tls_init, 534 aead_tls_cleanup, 535 aead_tls_open, 536 aead_tls_seal_scatter, 537 NULL, // open_gather 538 NULL, // get_iv 539 aead_tls_tag_len, 540 }; 541 542 static const EVP_AEAD aead_aes_256_cbc_sha1_tls_implicit_iv = { 543 SHA_DIGEST_LENGTH + 32 + 16, // key len (SHA1 + AES256 + IV) 544 0, // nonce len 545 16 + SHA_DIGEST_LENGTH, // overhead (padding + SHA1) 546 SHA_DIGEST_LENGTH, // max tag length 547 0, // seal_scatter_supports_extra_in 548 549 NULL, // init 550 aead_aes_256_cbc_sha1_tls_implicit_iv_init, 551 aead_tls_cleanup, 552 aead_tls_open, 553 aead_tls_seal_scatter, 554 NULL, // open_gather 555 aead_tls_get_iv, // get_iv 556 aead_tls_tag_len, 557 }; 558 559 static const EVP_AEAD aead_aes_256_cbc_sha256_tls = { 560 SHA256_DIGEST_LENGTH + 32, // key len (SHA256 + AES256) 561 16, // nonce len (IV) 562 16 + SHA256_DIGEST_LENGTH, // overhead (padding + SHA256) 563 SHA256_DIGEST_LENGTH, // max tag length 564 0, // seal_scatter_supports_extra_in 565 566 NULL, // init 567 aead_aes_256_cbc_sha256_tls_init, 568 aead_tls_cleanup, 569 aead_tls_open, 570 aead_tls_seal_scatter, 571 NULL, // open_gather 572 NULL, // get_iv 573 aead_tls_tag_len, 574 }; 575 576 static const EVP_AEAD aead_aes_256_cbc_sha384_tls = { 577 SHA384_DIGEST_LENGTH + 32, // key len (SHA384 + AES256) 578 16, // nonce len (IV) 579 16 + SHA384_DIGEST_LENGTH, // overhead (padding + SHA384) 580 SHA384_DIGEST_LENGTH, // max tag length 581 0, // seal_scatter_supports_extra_in 582 583 NULL, // init 584 aead_aes_256_cbc_sha384_tls_init, 585 aead_tls_cleanup, 586 aead_tls_open, 587 aead_tls_seal_scatter, 588 NULL, // open_gather 589 NULL, // get_iv 590 aead_tls_tag_len, 591 }; 592 593 static const EVP_AEAD aead_des_ede3_cbc_sha1_tls = { 594 SHA_DIGEST_LENGTH + 24, // key len (SHA1 + 3DES) 595 8, // nonce len (IV) 596 8 + SHA_DIGEST_LENGTH, // overhead (padding + SHA1) 597 SHA_DIGEST_LENGTH, // max tag length 598 0, // seal_scatter_supports_extra_in 599 600 NULL, // init 601 aead_des_ede3_cbc_sha1_tls_init, 602 aead_tls_cleanup, 603 aead_tls_open, 604 aead_tls_seal_scatter, 605 NULL, // open_gather 606 NULL, // get_iv 607 aead_tls_tag_len, 608 }; 609 610 static const EVP_AEAD aead_des_ede3_cbc_sha1_tls_implicit_iv = { 611 SHA_DIGEST_LENGTH + 24 + 8, // key len (SHA1 + 3DES + IV) 612 0, // nonce len 613 8 + SHA_DIGEST_LENGTH, // overhead (padding + SHA1) 614 SHA_DIGEST_LENGTH, // max tag length 615 0, // seal_scatter_supports_extra_in 616 617 NULL, // init 618 aead_des_ede3_cbc_sha1_tls_implicit_iv_init, 619 aead_tls_cleanup, 620 aead_tls_open, 621 aead_tls_seal_scatter, 622 NULL, // open_gather 623 aead_tls_get_iv, // get_iv 624 aead_tls_tag_len, 625 }; 626 627 static const EVP_AEAD aead_null_sha1_tls = { 628 SHA_DIGEST_LENGTH, // key len 629 0, // nonce len 630 SHA_DIGEST_LENGTH, // overhead (SHA1) 631 SHA_DIGEST_LENGTH, // max tag length 632 0, // seal_scatter_supports_extra_in 633 634 NULL, // init 635 aead_null_sha1_tls_init, 636 aead_tls_cleanup, 637 aead_tls_open, 638 aead_tls_seal_scatter, 639 NULL, // open_gather 640 NULL, // get_iv 641 aead_tls_tag_len, 642 }; 643 644 const EVP_AEAD *EVP_aead_aes_128_cbc_sha1_tls(void) { 645 return &aead_aes_128_cbc_sha1_tls; 646 } 647 648 const EVP_AEAD *EVP_aead_aes_128_cbc_sha1_tls_implicit_iv(void) { 649 return &aead_aes_128_cbc_sha1_tls_implicit_iv; 650 } 651 652 const EVP_AEAD *EVP_aead_aes_128_cbc_sha256_tls(void) { 653 return &aead_aes_128_cbc_sha256_tls; 654 } 655 656 const EVP_AEAD *EVP_aead_aes_256_cbc_sha1_tls(void) { 657 return &aead_aes_256_cbc_sha1_tls; 658 } 659 660 const EVP_AEAD *EVP_aead_aes_256_cbc_sha1_tls_implicit_iv(void) { 661 return &aead_aes_256_cbc_sha1_tls_implicit_iv; 662 } 663 664 const EVP_AEAD *EVP_aead_aes_256_cbc_sha256_tls(void) { 665 return &aead_aes_256_cbc_sha256_tls; 666 } 667 668 const EVP_AEAD *EVP_aead_aes_256_cbc_sha384_tls(void) { 669 return &aead_aes_256_cbc_sha384_tls; 670 } 671 672 const EVP_AEAD *EVP_aead_des_ede3_cbc_sha1_tls(void) { 673 return &aead_des_ede3_cbc_sha1_tls; 674 } 675 676 const EVP_AEAD *EVP_aead_des_ede3_cbc_sha1_tls_implicit_iv(void) { 677 return &aead_des_ede3_cbc_sha1_tls_implicit_iv; 678 } 679 680 const EVP_AEAD *EVP_aead_null_sha1_tls(void) { return &aead_null_sha1_tls; } 681
