grpc 1.24.0 → 1.25.0

data/third_party/boringssl/crypto/fipsmodule/modes/ccm.c

@@ -1,256 +0,0 @@
-/* ====================================================================
- * Copyright (c) 2011 The OpenSSL Project.  All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- *
- * 1. Redistributions of source code must retain the above copyright
- *    notice, this list of conditions and the following disclaimer.
- *
- * 2. Redistributions in binary form must reproduce the above copyright
- *    notice, this list of conditions and the following disclaimer in
- *    the documentation and/or other materials provided with the
- *    distribution.
- *
- * 3. All advertising materials mentioning features or use of this
- *    software must display the following acknowledgment:
- *    "This product includes software developed by the OpenSSL Project
- *    for use in the OpenSSL Toolkit. (http://www.openssl.org/)"
- *
- * 4. The names "OpenSSL Toolkit" and "OpenSSL Project" must not be used to
- *    endorse or promote products derived from this software without
- *    prior written permission. For written permission, please contact
- *    openssl-core@openssl.org.
- *
- * 5. Products derived from this software may not be called "OpenSSL"
- *    nor may "OpenSSL" appear in their names without prior written
- *    permission of the OpenSSL Project.
- *
- * 6. Redistributions of any form whatsoever must retain the following
- *    acknowledgment:
- *    "This product includes software developed by the OpenSSL Project
- *    for use in the OpenSSL Toolkit (http://www.openssl.org/)"
- *
- * THIS SOFTWARE IS PROVIDED BY THE OpenSSL PROJECT ``AS IS'' AND ANY
- * EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
- * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE OpenSSL PROJECT OR
- * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
- * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
- * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
- * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
- * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
- * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
- * OF THE POSSIBILITY OF SUCH DAMAGE.
- * ====================================================================
- */
-
-#include <assert.h>
-#include <string.h>
-
-#include <openssl/cpu.h>
-#include <openssl/mem.h>
-
-#include "../../internal.h"
-#include "internal.h"
-
-
-struct ccm128_state {
-  union {
-    uint64_t u[2];
-    uint8_t c[16];
-  } nonce, cmac;
-};
-
-int CRYPTO_ccm128_init(CCM128_CONTEXT *ctx, const void *key, block128_f block,
-                       ctr128_f ctr, unsigned M, unsigned L) {
-  if (M < 4 || M > 16 || (M & 1) != 0 || L < 2 || L > 8) {
-    return 0;
-  }
-  ctx->block = block;
-  ctx->ctr = ctr;
-  ctx->M = M;
-  ctx->L = L;
-  return 1;
-}
-
-size_t CRYPTO_ccm128_max_input(const CCM128_CONTEXT *ctx) {
-  return ctx->L >= sizeof(size_t) ? (size_t)-1
-                                  : (((size_t)1) << (ctx->L * 8)) - 1;
-}
-
-static int ccm128_init_state(const CCM128_CONTEXT *ctx,
-                             struct ccm128_state *state, const void *key,
-                             const uint8_t *nonce, size_t nonce_len,
-                             const uint8_t *aad, size_t aad_len,
-                             size_t plaintext_len) {
-  const block128_f block = ctx->block;
-  const unsigned M = ctx->M;
-  const unsigned L = ctx->L;
-
-  // |L| determines the expected |nonce_len| and the limit for |plaintext_len|.
-  if (plaintext_len > CRYPTO_ccm128_max_input(ctx) ||
-      nonce_len != 15 - L) {
-    return 0;
-  }
-
-  // Assemble the first block for computing the MAC.
-  OPENSSL_memset(state, 0, sizeof(*state));
-  state->nonce.c[0] = (uint8_t)((L - 1) | ((M - 2) / 2) << 3);
-  if (aad_len != 0) {
-    state->nonce.c[0] |= 0x40;  // Set AAD Flag
-  }
-  OPENSSL_memcpy(&state->nonce.c[1], nonce, nonce_len);
-  for (unsigned i = 0; i < L; i++) {
-    state->nonce.c[15 - i] = (uint8_t)(plaintext_len >> (8 * i));
-  }
-
-  (*block)(state->nonce.c, state->cmac.c, key);
-  size_t blocks = 1;
-
-  if (aad_len != 0) {
-    unsigned i;
-    // Cast to u64 to avoid the compiler complaining about invalid shifts.
-    uint64_t aad_len_u64 = aad_len;
-    if (aad_len_u64 < 0x10000 - 0x100) {
-      state->cmac.c[0] ^= (uint8_t)(aad_len_u64 >> 8);
-      state->cmac.c[1] ^= (uint8_t)aad_len_u64;
-      i = 2;
-    } else if (aad_len_u64 <= 0xffffffff) {
-      state->cmac.c[0] ^= 0xff;
-      state->cmac.c[1] ^= 0xfe;
-      state->cmac.c[2] ^= (uint8_t)(aad_len_u64 >> 24);
-      state->cmac.c[3] ^= (uint8_t)(aad_len_u64 >> 16);
-      state->cmac.c[4] ^= (uint8_t)(aad_len_u64 >> 8);
-      state->cmac.c[5] ^= (uint8_t)aad_len_u64;
-      i = 6;
-    } else {
-      state->cmac.c[0] ^= 0xff;
-      state->cmac.c[1] ^= 0xff;
-      state->cmac.c[2] ^= (uint8_t)(aad_len_u64 >> 56);
-      state->cmac.c[3] ^= (uint8_t)(aad_len_u64 >> 48);
-      state->cmac.c[4] ^= (uint8_t)(aad_len_u64 >> 40);
-      state->cmac.c[5] ^= (uint8_t)(aad_len_u64 >> 32);
-      state->cmac.c[6] ^= (uint8_t)(aad_len_u64 >> 24);
-      state->cmac.c[7] ^= (uint8_t)(aad_len_u64 >> 16);
-      state->cmac.c[8] ^= (uint8_t)(aad_len_u64 >> 8);
-      state->cmac.c[9] ^= (uint8_t)aad_len_u64;
-      i = 10;
-    }
-
-    do {
-      for (; i < 16 && aad_len != 0; i++) {
-        state->cmac.c[i] ^= *aad;
-        aad++;
-        aad_len--;
-      }
-      (*block)(state->cmac.c, state->cmac.c, key);
-      blocks++;
-      i = 0;
-    } while (aad_len != 0);
-  }
-
-  // Per RFC 3610, section 2.6, the total number of block cipher operations done
-  // must not exceed 2^61. There are two block cipher operations remaining per
-  // message block, plus one block at the end to encrypt the MAC.
-  size_t remaining_blocks = 2 * ((plaintext_len + 15) / 16) + 1;
-  if (plaintext_len + 15 < plaintext_len ||
-      remaining_blocks + blocks < blocks ||
-      (uint64_t) remaining_blocks + blocks > UINT64_C(1) << 61) {
-    return 0;
-  }
-
-  // Assemble the first block for encrypting and decrypting. The bottom |L|
-  // bytes are replaced with a counter and all bit the encoding of |L| is
-  // cleared in the first byte.
-  state->nonce.c[0] &= 7;
-  return 1;
-}
-
-static int ccm128_encrypt(const CCM128_CONTEXT *ctx, struct ccm128_state *state,
-                          const void *key, uint8_t *out, const uint8_t *in,
-                          size_t len) {
-  // The counter for encryption begins at one.
-  for (unsigned i = 0; i < ctx->L; i++) {
-    state->nonce.c[15 - i] = 0;
-  }
-  state->nonce.c[15] = 1;
-
-  uint8_t partial_buf[16];
-  unsigned num = 0;
-  if (ctx->ctr != NULL) {
-    CRYPTO_ctr128_encrypt_ctr32(in, out, len, key, state->nonce.c, partial_buf,
-                                &num, ctx->ctr);
-  } else {
-    CRYPTO_ctr128_encrypt(in, out, len, key, state->nonce.c, partial_buf, &num,
-                          ctx->block);
-  }
-  return 1;
-}
-
-static int ccm128_compute_mac(const CCM128_CONTEXT *ctx,
-                              struct ccm128_state *state, const void *key,
-                              uint8_t *out_tag, size_t tag_len,
-                              const uint8_t *in, size_t len) {
-  block128_f block = ctx->block;
-  if (tag_len != ctx->M) {
-    return 0;
-  }
-
-  // Incorporate |in| into the MAC.
-  union {
-    uint64_t u[2];
-    uint8_t c[16];
-  } tmp;
-  while (len >= 16) {
-    OPENSSL_memcpy(tmp.c, in, 16);
-    state->cmac.u[0] ^= tmp.u[0];
-    state->cmac.u[1] ^= tmp.u[1];
-    (*block)(state->cmac.c, state->cmac.c, key);
-    in += 16;
-    len -= 16;
-  }
-  if (len > 0) {
-    for (size_t i = 0; i < len; i++) {
-      state->cmac.c[i] ^= in[i];
-    }
-    (*block)(state->cmac.c, state->cmac.c, key);
-  }
-
-  // Encrypt the MAC with counter zero.
-  for (unsigned i = 0; i < ctx->L; i++) {
-    state->nonce.c[15 - i] = 0;
-  }
-  (*block)(state->nonce.c, tmp.c, key);
-  state->cmac.u[0] ^= tmp.u[0];
-  state->cmac.u[1] ^= tmp.u[1];
-
-  OPENSSL_memcpy(out_tag, state->cmac.c, tag_len);
-  return 1;
-}
-
-int CRYPTO_ccm128_encrypt(const CCM128_CONTEXT *ctx, const void *key,
-                          uint8_t *out, uint8_t *out_tag, size_t tag_len,
-                          const uint8_t *nonce, size_t nonce_len,
-                          const uint8_t *in, size_t len, const uint8_t *aad,
-                          size_t aad_len) {
-  struct ccm128_state state;
-  return ccm128_init_state(ctx, &state, key, nonce, nonce_len, aad, aad_len,
-                           len) &&
-         ccm128_compute_mac(ctx, &state, key, out_tag, tag_len, in, len) &&
-         ccm128_encrypt(ctx, &state, key, out, in, len);
-}
-
-int CRYPTO_ccm128_decrypt(const CCM128_CONTEXT *ctx, const void *key,
-                          uint8_t *out, uint8_t *out_tag, size_t tag_len,
-                          const uint8_t *nonce, size_t nonce_len,
-                          const uint8_t *in, size_t len, const uint8_t *aad,
-                          size_t aad_len) {
-  struct ccm128_state state;
-  return ccm128_init_state(ctx, &state, key, nonce, nonce_len, aad, aad_len,
-                           len) &&
-         ccm128_encrypt(ctx, &state, key, out, in, len) &&
-         ccm128_compute_mac(ctx, &state, key, out_tag, tag_len, out, len);
-}

data/third_party/boringssl/include/openssl/lhash_macros.h

@@ -1,174 +0,0 @@
-/* Copyright (c) 2014, Google Inc.
- *
- * Permission to use, copy, modify, and/or distribute this software for any
- * purpose with or without fee is hereby granted, provided that the above
- * copyright notice and this permission notice appear in all copies.
- *
- * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
- * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
- * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY
- * SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
- * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION
- * OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN
- * CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. */
-
-#if !defined(IN_LHASH_H)
-#error "Don't include this file directly. Include lhash.h"
-#endif
-
-// ASN1_OBJECT
-#define lh_ASN1_OBJECT_new(hash, comp)                                       \
-  ((LHASH_OF(ASN1_OBJECT) *)lh_new(                                          \
-      CHECKED_CAST(lhash_hash_func, uint32_t(*)(const ASN1_OBJECT *), hash), \
-      CHECKED_CAST(lhash_cmp_func,                                           \
-                   int (*)(const ASN1_OBJECT *a, const ASN1_OBJECT *b),      \
-                   comp)))
-
-#define lh_ASN1_OBJECT_free(lh) \
-  lh_free(CHECKED_CAST(_LHASH *, LHASH_OF(ASN1_OBJECT) *, lh));
-
-#define lh_ASN1_OBJECT_num_items(lh) \
-  lh_num_items(CHECKED_CAST(_LHASH *, LHASH_OF(ASN1_OBJECT) *, lh))
-
-#define lh_ASN1_OBJECT_retrieve(lh, data)                  \
-  ((ASN1_OBJECT *)lh_retrieve(                             \
-      CHECKED_CAST(_LHASH *, LHASH_OF(ASN1_OBJECT) *, lh), \
-      CHECKED_CAST(void *, ASN1_OBJECT *, data)))
-
-#define lh_ASN1_OBJECT_insert(lh, old_data, data)                \
-  lh_insert(CHECKED_CAST(_LHASH *, LHASH_OF(ASN1_OBJECT) *, lh), \
-            CHECKED_CAST(void **, ASN1_OBJECT **, old_data),     \
-            CHECKED_CAST(void *, ASN1_OBJECT *, data))
-
-#define lh_ASN1_OBJECT_delete(lh, data)                    \
-  ((ASN1_OBJECT *)lh_delete(                               \
-      CHECKED_CAST(_LHASH *, LHASH_OF(ASN1_OBJECT) *, lh), \
-      CHECKED_CAST(void *, ASN1_OBJECT *, data)))
-
-#define lh_ASN1_OBJECT_doall(lh, func)                          \
-  lh_doall(CHECKED_CAST(_LHASH *, LHASH_OF(ASN1_OBJECT) *, lh), \
-           CHECKED_CAST(void (*)(void *), void (*)(ASN1_OBJECT *), func));
-
-#define lh_ASN1_OBJECT_doall_arg(lh, func, arg)                     \
-  lh_doall_arg(CHECKED_CAST(_LHASH *, LHASH_OF(ASN1_OBJECT) *, lh), \
-               CHECKED_CAST(void (*)(void *, void *),               \
-                            void (*)(ASN1_OBJECT *, void *), func), \
-               arg);
-
-
-// CONF_VALUE
-#define lh_CONF_VALUE_new(hash, comp)                                       \
-  ((LHASH_OF(CONF_VALUE) *)lh_new(                                          \
-      CHECKED_CAST(lhash_hash_func, uint32_t(*)(const CONF_VALUE *), hash), \
-      CHECKED_CAST(lhash_cmp_func,                                          \
-                   int (*)(const CONF_VALUE *a, const CONF_VALUE *b), comp)))
-
-#define lh_CONF_VALUE_free(lh) \
-  lh_free(CHECKED_CAST(_LHASH *, LHASH_OF(CONF_VALUE) *, lh));
-
-#define lh_CONF_VALUE_num_items(lh) \
-  lh_num_items(CHECKED_CAST(_LHASH *, LHASH_OF(CONF_VALUE) *, lh))
-
-#define lh_CONF_VALUE_retrieve(lh, data)                  \
-  ((CONF_VALUE *)lh_retrieve(                             \
-      CHECKED_CAST(_LHASH *, LHASH_OF(CONF_VALUE) *, lh), \
-      CHECKED_CAST(void *, CONF_VALUE *, data)))
-
-#define lh_CONF_VALUE_insert(lh, old_data, data)                \
-  lh_insert(CHECKED_CAST(_LHASH *, LHASH_OF(CONF_VALUE) *, lh), \
-            CHECKED_CAST(void **, CONF_VALUE **, old_data),     \
-            CHECKED_CAST(void *, CONF_VALUE *, data))
-
-#define lh_CONF_VALUE_delete(lh, data)                                         \
-  ((CONF_VALUE *)lh_delete(CHECKED_CAST(_LHASH *, LHASH_OF(CONF_VALUE) *, lh), \
-                           CHECKED_CAST(void *, CONF_VALUE *, data)))
-
-#define lh_CONF_VALUE_doall(lh, func)                          \
-  lh_doall(CHECKED_CAST(_LHASH *, LHASH_OF(CONF_VALUE) *, lh), \
-           CHECKED_CAST(void (*)(void *), void (*)(CONF_VALUE *), func));
-
-#define lh_CONF_VALUE_doall_arg(lh, func, arg)                     \
-  lh_doall_arg(CHECKED_CAST(_LHASH *, LHASH_OF(CONF_VALUE) *, lh), \
-               CHECKED_CAST(void (*)(void *, void *),              \
-                            void (*)(CONF_VALUE *, void *), func), \
-               arg);
-
-
-// CRYPTO_BUFFER
-#define lh_CRYPTO_BUFFER_new(hash, comp)                                       \
-  ((LHASH_OF(CRYPTO_BUFFER) *)lh_new(                                          \
-      CHECKED_CAST(lhash_hash_func, uint32_t(*)(const CRYPTO_BUFFER *), hash), \
-      CHECKED_CAST(lhash_cmp_func,                                             \
-                   int (*)(const CRYPTO_BUFFER *a, const CRYPTO_BUFFER *b),    \
-                   comp)))
-
-#define lh_CRYPTO_BUFFER_free(lh) \
-  lh_free(CHECKED_CAST(_LHASH *, LHASH_OF(CRYPTO_BUFFER) *, lh));
-
-#define lh_CRYPTO_BUFFER_num_items(lh) \
-  lh_num_items(CHECKED_CAST(_LHASH *, LHASH_OF(CRYPTO_BUFFER) *, lh))
-
-#define lh_CRYPTO_BUFFER_retrieve(lh, data)                  \
-  ((CRYPTO_BUFFER *)lh_retrieve(                             \
-      CHECKED_CAST(_LHASH *, LHASH_OF(CRYPTO_BUFFER) *, lh), \
-      CHECKED_CAST(void *, CRYPTO_BUFFER *, data)))
-
-#define lh_CRYPTO_BUFFER_insert(lh, old_data, data)                \
-  lh_insert(CHECKED_CAST(_LHASH *, LHASH_OF(CRYPTO_BUFFER) *, lh), \
-            CHECKED_CAST(void **, CRYPTO_BUFFER **, old_data),     \
-            CHECKED_CAST(void *, CRYPTO_BUFFER *, data))
-
-#define lh_CRYPTO_BUFFER_delete(lh, data)                    \
-  ((CRYPTO_BUFFER *)lh_delete(                               \
-      CHECKED_CAST(_LHASH *, LHASH_OF(CRYPTO_BUFFER) *, lh), \
-      CHECKED_CAST(void *, CRYPTO_BUFFER *, data)))
-
-#define lh_CRYPTO_BUFFER_doall(lh, func)                          \
-  lh_doall(CHECKED_CAST(_LHASH *, LHASH_OF(CRYPTO_BUFFER) *, lh), \
-           CHECKED_CAST(void (*)(void *), void (*)(CRYPTO_BUFFER *), func));
-
-#define lh_CRYPTO_BUFFER_doall_arg(lh, func, arg)                     \
-  lh_doall_arg(CHECKED_CAST(_LHASH *, LHASH_OF(CRYPTO_BUFFER) *, lh), \
-               CHECKED_CAST(void (*)(void *, void *),                 \
-                            void (*)(CRYPTO_BUFFER *, void *), func), \
-               arg);
-
-
-// SSL_SESSION
-#define lh_SSL_SESSION_new(hash, comp)                                       \
-  ((LHASH_OF(SSL_SESSION) *)lh_new(                                          \
-      CHECKED_CAST(lhash_hash_func, uint32_t(*)(const SSL_SESSION *), hash), \
-      CHECKED_CAST(lhash_cmp_func,                                           \
-                   int (*)(const SSL_SESSION *a, const SSL_SESSION *b),      \
-                   comp)))
-
-#define lh_SSL_SESSION_free(lh) \
-  lh_free(CHECKED_CAST(_LHASH *, LHASH_OF(SSL_SESSION) *, lh));
-
-#define lh_SSL_SESSION_num_items(lh) \
-  lh_num_items(CHECKED_CAST(_LHASH *, LHASH_OF(SSL_SESSION) *, lh))
-
-#define lh_SSL_SESSION_retrieve(lh, data)                  \
-  ((SSL_SESSION *)lh_retrieve(                             \
-      CHECKED_CAST(_LHASH *, LHASH_OF(SSL_SESSION) *, lh), \
-      CHECKED_CAST(void *, SSL_SESSION *, data)))
-
-#define lh_SSL_SESSION_insert(lh, old_data, data)                \
-  lh_insert(CHECKED_CAST(_LHASH *, LHASH_OF(SSL_SESSION) *, lh), \
-            CHECKED_CAST(void **, SSL_SESSION **, old_data),     \
-            CHECKED_CAST(void *, SSL_SESSION *, data))
-
-#define lh_SSL_SESSION_delete(lh, data)                    \
-  ((SSL_SESSION *)lh_delete(                               \
-      CHECKED_CAST(_LHASH *, LHASH_OF(SSL_SESSION) *, lh), \
-      CHECKED_CAST(void *, SSL_SESSION *, data)))
-
-#define lh_SSL_SESSION_doall(lh, func)                          \
-  lh_doall(CHECKED_CAST(_LHASH *, LHASH_OF(SSL_SESSION) *, lh), \
-           CHECKED_CAST(void (*)(void *), void (*)(SSL_SESSION *), func));
-
-#define lh_SSL_SESSION_doall_arg(lh, func, arg)                     \
-  lh_doall_arg(CHECKED_CAST(_LHASH *, LHASH_OF(SSL_SESSION) *, lh), \
-               CHECKED_CAST(void (*)(void *, void *),               \
-                            void (*)(SSL_SESSION *, void *), func), \
-               arg);

data/third_party/boringssl/ssl/custom_extensions.cc

@@ -1,265 +0,0 @@
-/* Copyright (c) 2014, Google Inc.
- *
- * Permission to use, copy, modify, and/or distribute this software for any
- * purpose with or without fee is hereby granted, provided that the above
- * copyright notice and this permission notice appear in all copies.
- *
- * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
- * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
- * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY
- * SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
- * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION
- * OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN
- * CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. */
-
-#include <openssl/ssl.h>
-
-#include <assert.h>
-#include <string.h>
-
-#include <openssl/bytestring.h>
-#include <openssl/err.h>
-#include <openssl/mem.h>
-#include <openssl/stack.h>
-
-#include "internal.h"
-
-
-namespace bssl {
-
-void SSL_CUSTOM_EXTENSION_free(SSL_CUSTOM_EXTENSION *custom_extension) {
-  OPENSSL_free(custom_extension);
-}
-
-static const SSL_CUSTOM_EXTENSION *custom_ext_find(
-    STACK_OF(SSL_CUSTOM_EXTENSION) *stack,
-    unsigned *out_index, uint16_t value) {
-  for (size_t i = 0; i < sk_SSL_CUSTOM_EXTENSION_num(stack); i++) {
-    const SSL_CUSTOM_EXTENSION *ext = sk_SSL_CUSTOM_EXTENSION_value(stack, i);
-    if (ext->value == value) {
-      if (out_index != NULL) {
-        *out_index = i;
-      }
-      return ext;
-    }
-  }
-
-  return NULL;
-}
-
-// default_add_callback is used as the |add_callback| when the user doesn't
-// provide one. For servers, it does nothing while, for clients, it causes an
-// empty extension to be included.
-static int default_add_callback(SSL *ssl, unsigned extension_value,
-                                const uint8_t **out, size_t *out_len,
-                                int *out_alert_value, void *add_arg) {
-  if (ssl->server) {
-    return 0;
-  }
-  *out_len = 0;
-  return 1;
-}
-
-static int custom_ext_add_hello(SSL_HANDSHAKE *hs, CBB *extensions) {
-  SSL *const ssl = hs->ssl;
-  STACK_OF(SSL_CUSTOM_EXTENSION) *stack = ssl->ctx->client_custom_extensions;
-  if (ssl->server) {
-    stack = ssl->ctx->server_custom_extensions;
-  }
-
-  if (stack == NULL) {
-    return 1;
-  }
-
-  for (size_t i = 0; i < sk_SSL_CUSTOM_EXTENSION_num(stack); i++) {
-    const SSL_CUSTOM_EXTENSION *ext = sk_SSL_CUSTOM_EXTENSION_value(stack, i);
-
-    if (ssl->server &&
-        !(hs->custom_extensions.received & (1u << i))) {
-      // Servers cannot echo extensions that the client didn't send.
-      continue;
-    }
-
-    const uint8_t *contents;
-    size_t contents_len;
-    int alert = SSL_AD_DECODE_ERROR;
-    CBB contents_cbb;
-
-    switch (ext->add_callback(ssl, ext->value, &contents, &contents_len, &alert,
-                              ext->add_arg)) {
-      case 1:
-        if (!CBB_add_u16(extensions, ext->value) ||
-            !CBB_add_u16_length_prefixed(extensions, &contents_cbb) ||
-            !CBB_add_bytes(&contents_cbb, contents, contents_len) ||
-            !CBB_flush(extensions)) {
-          OPENSSL_PUT_ERROR(SSL, ERR_R_INTERNAL_ERROR);
-          ERR_add_error_dataf("extension %u", (unsigned) ext->value);
-          if (ext->free_callback && 0 < contents_len) {
-            ext->free_callback(ssl, ext->value, contents, ext->add_arg);
-          }
-          return 0;
-        }
-
-        if (ext->free_callback && 0 < contents_len) {
-          ext->free_callback(ssl, ext->value, contents, ext->add_arg);
-        }
-
-        if (!ssl->server) {
-          assert((hs->custom_extensions.sent & (1u << i)) == 0);
-          hs->custom_extensions.sent |= (1u << i);
-        }
-        break;
-
-      case 0:
-        break;
-
-      default:
-        ssl_send_alert(ssl, SSL3_AL_FATAL, alert);
-        OPENSSL_PUT_ERROR(SSL, SSL_R_CUSTOM_EXTENSION_ERROR);
-        ERR_add_error_dataf("extension %u", (unsigned) ext->value);
-        return 0;
-    }
-  }
-
-  return 1;
-}
-
-int custom_ext_add_clienthello(SSL_HANDSHAKE *hs, CBB *extensions) {
-  return custom_ext_add_hello(hs, extensions);
-}
-
-int custom_ext_parse_serverhello(SSL_HANDSHAKE *hs, int *out_alert,
-                                 uint16_t value, const CBS *extension) {
-  SSL *const ssl = hs->ssl;
-  unsigned index;
-  const SSL_CUSTOM_EXTENSION *ext =
-      custom_ext_find(ssl->ctx->client_custom_extensions, &index, value);
-
-  if (// Unknown extensions are not allowed in a ServerHello.
-      ext == NULL ||
-      // Also, if we didn't send the extension, that's also unacceptable.
-      !(hs->custom_extensions.sent & (1u << index))) {
-    OPENSSL_PUT_ERROR(SSL, SSL_R_UNEXPECTED_EXTENSION);
-    ERR_add_error_dataf("extension %u", (unsigned)value);
-    *out_alert = SSL_AD_UNSUPPORTED_EXTENSION;
-    return 0;
-  }
-
-  if (ext->parse_callback != NULL &&
-      !ext->parse_callback(ssl, value, CBS_data(extension), CBS_len(extension),
-                           out_alert, ext->parse_arg)) {
-    OPENSSL_PUT_ERROR(SSL, SSL_R_CUSTOM_EXTENSION_ERROR);
-    ERR_add_error_dataf("extension %u", (unsigned)ext->value);
-    return 0;
-  }
-
-  return 1;
-}
-
-int custom_ext_parse_clienthello(SSL_HANDSHAKE *hs, int *out_alert,
-                                 uint16_t value, const CBS *extension) {
-  SSL *const ssl = hs->ssl;
-  unsigned index;
-  const SSL_CUSTOM_EXTENSION *ext =
-      custom_ext_find(ssl->ctx->server_custom_extensions, &index, value);
-
-  if (ext == NULL) {
-    return 1;
-  }
-
-  assert((hs->custom_extensions.received & (1u << index)) == 0);
-  hs->custom_extensions.received |= (1u << index);
-
-  if (ext->parse_callback &&
-      !ext->parse_callback(ssl, value, CBS_data(extension), CBS_len(extension),
-                           out_alert, ext->parse_arg)) {
-    OPENSSL_PUT_ERROR(SSL, SSL_R_CUSTOM_EXTENSION_ERROR);
-    ERR_add_error_dataf("extension %u", (unsigned)ext->value);
-    return 0;
-  }
-
-  return 1;
-}
-
-int custom_ext_add_serverhello(SSL_HANDSHAKE *hs, CBB *extensions) {
-  return custom_ext_add_hello(hs, extensions);
-}
-
-// MAX_NUM_CUSTOM_EXTENSIONS is the maximum number of custom extensions that
-// can be set on an |SSL_CTX|. It's determined by the size of the bitset used
-// to track when an extension has been sent.
-#define MAX_NUM_CUSTOM_EXTENSIONS \
-  (sizeof(((SSL_HANDSHAKE *)NULL)->custom_extensions.sent) * 8)
-
-static int custom_ext_append(STACK_OF(SSL_CUSTOM_EXTENSION) **stack,
-                             unsigned extension_value,
-                             SSL_custom_ext_add_cb add_cb,
-                             SSL_custom_ext_free_cb free_cb, void *add_arg,
-                             SSL_custom_ext_parse_cb parse_cb,
-                             void *parse_arg) {
-  if (add_cb == NULL ||
-      0xffff < extension_value ||
-      SSL_extension_supported(extension_value) ||
-      // Specifying a free callback without an add callback is nonsensical
-      // and an error.
-      (*stack != NULL &&
-       (MAX_NUM_CUSTOM_EXTENSIONS <= sk_SSL_CUSTOM_EXTENSION_num(*stack) ||
-        custom_ext_find(*stack, NULL, extension_value) != NULL))) {
-    return 0;
-  }
-
-  SSL_CUSTOM_EXTENSION *ext =
-      (SSL_CUSTOM_EXTENSION *)OPENSSL_malloc(sizeof(SSL_CUSTOM_EXTENSION));
-  if (ext == NULL) {
-    return 0;
-  }
-  ext->add_callback = add_cb;
-  ext->add_arg = add_arg;
-  ext->free_callback = free_cb;
-  ext->parse_callback = parse_cb;
-  ext->parse_arg = parse_arg;
-  ext->value = extension_value;
-
-  if (*stack == NULL) {
-    *stack = sk_SSL_CUSTOM_EXTENSION_new_null();
-    if (*stack == NULL) {
-      SSL_CUSTOM_EXTENSION_free(ext);
-      return 0;
-    }
-  }
-
-  if (!sk_SSL_CUSTOM_EXTENSION_push(*stack, ext)) {
-    SSL_CUSTOM_EXTENSION_free(ext);
-    if (sk_SSL_CUSTOM_EXTENSION_num(*stack) == 0) {
-      sk_SSL_CUSTOM_EXTENSION_free(*stack);
-      *stack = NULL;
-    }
-    return 0;
-  }
-
-  return 1;
-}
-
-}  // namespace bssl
-
-using namespace bssl;
-
-int SSL_CTX_add_client_custom_ext(SSL_CTX *ctx, unsigned extension_value,
-                                  SSL_custom_ext_add_cb add_cb,
-                                  SSL_custom_ext_free_cb free_cb, void *add_arg,
-                                  SSL_custom_ext_parse_cb parse_cb,
-                                  void *parse_arg) {
-  return custom_ext_append(&ctx->client_custom_extensions, extension_value,
-                           add_cb ? add_cb : default_add_callback, free_cb,
-                           add_arg, parse_cb, parse_arg);
-}
-
-int SSL_CTX_add_server_custom_ext(SSL_CTX *ctx, unsigned extension_value,
-                                  SSL_custom_ext_add_cb add_cb,
-                                  SSL_custom_ext_free_cb free_cb, void *add_arg,
-                                  SSL_custom_ext_parse_cb parse_cb,
-                                  void *parse_arg) {
-  return custom_ext_append(&ctx->server_custom_extensions, extension_value,
-                           add_cb ? add_cb : default_add_callback, free_cb,
-                           add_arg, parse_cb, parse_arg);
-}