legacy-libs/grpc/deps/grpc/third_party/boringssl/crypto/cipher_extra/e_tls.c

   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; }