grpc 1.69.0 → 1.71.0

data/third_party/boringssl-with-bazel/src/crypto/{bn_extra/convert.c → bn/convert.cc}

@@ -1,58 +1,16 @@
-/* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
- * All rights reserved.
- *
- * This package is an SSL implementation written
- * by Eric Young (eay@cryptsoft.com).
- * The implementation was written so as to conform with Netscapes SSL.
- *
- * This library is free for commercial and non-commercial use as long as
- * the following conditions are aheared to.  The following conditions
- * apply to all code found in this distribution, be it the RC4, RSA,
- * lhash, DES, etc., code; not just the SSL code.  The SSL documentation
- * included with this distribution is covered by the same copyright terms
- * except that the holder is Tim Hudson (tjh@cryptsoft.com).
- *
- * Copyright remains Eric Young's, and as such any Copyright notices in
- * the code are not to be removed.
- * If this package is used in a product, Eric Young should be given attribution
- * as the author of the parts of the library used.
- * This can be in the form of a textual message at program startup or
- * in documentation (online or textual) provided with the package.
- *
- * 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 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 acknowledgement:
- *    "This product includes cryptographic software written by
- *     Eric Young (eay@cryptsoft.com)"
- *    The word 'cryptographic' can be left out if the rouines from the library
- *    being used are not cryptographic related :-).
- * 4. If you include any Windows specific code (or a derivative thereof) from
- *    the apps directory (application code) you must include an acknowledgement:
- *    "This product includes software written by Tim Hudson (tjh@cryptsoft.com)"
- *
- * THIS SOFTWARE IS PROVIDED BY ERIC YOUNG ``AS IS'' AND
- * ANY EXPRESS 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 AUTHOR OR 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.
- *
- * The licence and distribution terms for any publically available version or
- * derivative of this code cannot be changed.  i.e. this code cannot simply be
- * copied and put under another distribution licence
- * [including the GNU Public Licence.] */
+// Copyright 1995-2016 The OpenSSL Project Authors. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     https://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
 
 #include <openssl/bn.h>
 
@@ -78,8 +36,9 @@ static const char hextable[] = "0123456789abcdef";
 
 char *BN_bn2hex(const BIGNUM *bn) {
   int width = bn_minimal_width(bn);
-  char *buf = OPENSSL_malloc(1 /* leading '-' */ + 1 /* zero is non-empty */ +
-                             width * BN_BYTES * 2 + 1 /* trailing NUL */);
+  char *buf = reinterpret_cast<char *>(
+      OPENSSL_malloc(1 /* leading '-' */ + 1 /* zero is non-empty */ +
+                     width * BN_BYTES * 2 + 1 /* trailing NUL */));
   if (buf == NULL) {
     return NULL;
   }
@@ -112,7 +71,7 @@ char *BN_bn2hex(const BIGNUM *bn) {
 
 // decode_hex decodes |in_len| bytes of hex data from |in| and updates |bn|.
 static int decode_hex(BIGNUM *bn, const char *in, int in_len) {
-  if (in_len > INT_MAX/4) {
+  if (in_len > INT_MAX / 4) {
     OPENSSL_PUT_ERROR(BN, BN_R_BIGNUM_TOO_LONG);
     return 0;
   }
@@ -163,8 +122,7 @@ static int decode_dec(BIGNUM *bn, const char *in, int in_len) {
     l *= 10;
     l += in[i] - '0';
     if (++j == BN_DEC_NUM) {
-      if (!BN_mul_word(bn, BN_DEC_CONV) ||
-          !BN_add_word(bn, l)) {
+      if (!BN_mul_word(bn, BN_DEC_CONV) || !BN_add_word(bn, l)) {
         return 0;
       }
       l = 0;
@@ -174,10 +132,11 @@ static int decode_dec(BIGNUM *bn, const char *in, int in_len) {
   return 1;
 }
 
-typedef int (*decode_func) (BIGNUM *bn, const char *in, int in_len);
-typedef int (*char_test_func) (int c);
+typedef int (*decode_func)(BIGNUM *bn, const char *in, int in_len);
+typedef int (*char_test_func)(int c);
 
-static int bn_x2bn(BIGNUM **outp, const char *in, decode_func decode, char_test_func want_char) {
+static int bn_x2bn(BIGNUM **outp, const char *in, decode_func decode,
+                   char_test_func want_char) {
   BIGNUM *ret = NULL;
   int neg = 0, i;
   int num;
@@ -191,7 +150,8 @@ static int bn_x2bn(BIGNUM **outp, const char *in, decode_func decode, char_test_
     in++;
   }
 
-  for (i = 0; want_char((unsigned char)in[i]) && i + neg < INT_MAX; i++) {}
+  for (i = 0; want_char((unsigned char)in[i]) && i + neg < INT_MAX; i++) {
+  }
 
   num = i + neg;
   if (outp == NULL) {
@@ -238,7 +198,7 @@ char *BN_bn2dec(const BIGNUM *a) {
   // and fix at the end.
   BIGNUM *copy = NULL;
   CBB cbb;
-  if (!CBB_init(&cbb, 16) ||
+  if (!CBB_init(&cbb, 16) || //
       !CBB_add_u8(&cbb, 0 /* trailing NUL */)) {
     goto err;
   }
@@ -270,7 +230,7 @@ char *BN_bn2dec(const BIGNUM *a) {
     }
   }
 
-  if (BN_is_negative(a) &&
+  if (BN_is_negative(a) && //
       !CBB_add_u8(&cbb, '-')) {
     goto err;
   }
@@ -282,7 +242,7 @@ char *BN_bn2dec(const BIGNUM *a) {
   }
 
   // Reverse the buffer.
-  for (size_t i = 0; i < len/2; i++) {
+  for (size_t i = 0; i < len / 2; i++) {
     uint8_t tmp = data[i];
     data[i] = data[len - 1 - i];
     data[len - 1 - i] = tmp;
@@ -308,7 +268,7 @@ int BN_asc2bn(BIGNUM **outp, const char *in) {
   }
 
   if (in[0] == '0' && (in[1] == 'X' || in[1] == 'x')) {
-    if (!BN_hex2bn(outp, in+2)) {
+    if (!BN_hex2bn(outp, in + 2)) {
       return 0;
     }
   } else {
@@ -377,9 +337,7 @@ size_t BN_bn2mpi(const BIGNUM *in, uint8_t *out) {
   }
 
   const size_t len = bytes + extend;
-  if (len < bytes ||
-      4 + len < len ||
-      (len & 0xffffffff) != len) {
+  if (len < bytes || 4 + len < len || (len & 0xffffffff) != len) {
     // If we cannot represent the number then we emit zero as the interface
     // doesn't allow an error to be signalled.
     if (out) {
@@ -411,9 +369,9 @@ BIGNUM *BN_mpi2bn(const uint8_t *in, size_t len, BIGNUM *out) {
     OPENSSL_PUT_ERROR(BN, BN_R_BAD_ENCODING);
     return NULL;
   }
-  const size_t in_len = ((size_t)in[0] << 24) |
-                        ((size_t)in[1] << 16) |
-                        ((size_t)in[2] << 8) |
+  const size_t in_len = ((size_t)in[0] << 24) | //
+                        ((size_t)in[1] << 16) | //
+                        ((size_t)in[2] << 8) | //
                         ((size_t)in[3]);
   if (in_len != len - 4) {
     OPENSSL_PUT_ERROR(BN, BN_R_BAD_ENCODING);
@@ -449,7 +407,7 @@ BIGNUM *BN_mpi2bn(const uint8_t *in, size_t len, BIGNUM *out) {
 }
 
 int BN_bn2binpad(const BIGNUM *in, uint8_t *out, int len) {
-  if (len < 0 ||
+  if (len < 0 || //
       !BN_bn2bin_padded(out, (size_t)len, in)) {
     return -1;
   }
@@ -457,7 +415,7 @@ int BN_bn2binpad(const BIGNUM *in, uint8_t *out, int len) {
 }
 
 int BN_bn2lebinpad(const BIGNUM *in, uint8_t *out, int len) {
-  if (len < 0 ||
+  if (len < 0 || //
       !BN_bn2le_padded(out, (size_t)len, in)) {
     return -1;
   }

data/third_party/boringssl-with-bazel/src/crypto/buf/buf.cc

@@ -0,0 +1,118 @@
+// Copyright 1995-2016 The OpenSSL Project Authors. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     https://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include <openssl/buf.h>
+
+#include <string.h>
+
+#include <openssl/err.h>
+#include <openssl/mem.h>
+
+#include "../internal.h"
+
+
+BUF_MEM *BUF_MEM_new(void) {
+  return reinterpret_cast<BUF_MEM *>(OPENSSL_zalloc(sizeof(BUF_MEM)));
+}
+
+void BUF_MEM_free(BUF_MEM *buf) {
+  if (buf == nullptr) {
+    return;
+  }
+  OPENSSL_free(buf->data);
+  OPENSSL_free(buf);
+}
+
+int BUF_MEM_reserve(BUF_MEM *buf, size_t cap) {
+  if (buf->max >= cap) {
+    return 1;
+  }
+
+  size_t n = cap + 3;
+  if (n < cap) {
+    OPENSSL_PUT_ERROR(BUF, ERR_R_OVERFLOW);
+    return 0;
+  }
+  n = n / 3;
+  size_t alloc_size = n * 4;
+  if (alloc_size / 4 != n) {
+    OPENSSL_PUT_ERROR(BUF, ERR_R_OVERFLOW);
+    return 0;
+  }
+
+  char *new_buf =
+      reinterpret_cast<char *>(OPENSSL_realloc(buf->data, alloc_size));
+  if (new_buf == NULL) {
+    return 0;
+  }
+
+  buf->data = new_buf;
+  buf->max = alloc_size;
+  return 1;
+}
+
+size_t BUF_MEM_grow(BUF_MEM *buf, size_t len) {
+  if (!BUF_MEM_reserve(buf, len)) {
+    return 0;
+  }
+  if (buf->length < len) {
+    OPENSSL_memset(&buf->data[buf->length], 0, len - buf->length);
+  }
+  buf->length = len;
+  return len;
+}
+
+size_t BUF_MEM_grow_clean(BUF_MEM *buf, size_t len) {
+  return BUF_MEM_grow(buf, len);
+}
+
+int BUF_MEM_append(BUF_MEM *buf, const void *in, size_t len) {
+  // Work around a C language bug. See https://crbug.com/1019588.
+  if (len == 0) {
+    return 1;
+  }
+  size_t new_len = buf->length + len;
+  if (new_len < len) {
+    OPENSSL_PUT_ERROR(BUF, ERR_R_OVERFLOW);
+    return 0;
+  }
+  if (!BUF_MEM_reserve(buf, new_len)) {
+    return 0;
+  }
+  OPENSSL_memcpy(buf->data + buf->length, in, len);
+  buf->length = new_len;
+  return 1;
+}
+
+char *BUF_strdup(const char *str) { return OPENSSL_strdup(str); }
+
+size_t BUF_strnlen(const char *str, size_t max_len) {
+  return OPENSSL_strnlen(str, max_len);
+}
+
+char *BUF_strndup(const char *str, size_t size) {
+  return OPENSSL_strndup(str, size);
+}
+
+size_t BUF_strlcpy(char *dst, const char *src, size_t dst_size) {
+  return OPENSSL_strlcpy(dst, src, dst_size);
+}
+
+size_t BUF_strlcat(char *dst, const char *src, size_t dst_size) {
+  return OPENSSL_strlcat(dst, src, dst_size);
+}
+
+void *BUF_memdup(const void *data, size_t size) {
+  return OPENSSL_memdup(data, size);
+}

data/third_party/boringssl-with-bazel/src/crypto/bytestring/asn1_compat.cc

@@ -0,0 +1,53 @@
+// Copyright 2016 The BoringSSL Authors
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     https://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+
+#include <openssl/bytestring.h>
+
+#include <assert.h>
+#include <limits.h>
+#include <string.h>
+
+#include <openssl/mem.h>
+
+#include "internal.h"
+#include "../internal.h"
+
+
+int CBB_finish_i2d(CBB *cbb, uint8_t **outp) {
+  assert(!cbb->is_child);
+  assert(cbb->u.base.can_resize);
+
+  uint8_t *der;
+  size_t der_len;
+  if (!CBB_finish(cbb, &der, &der_len)) {
+    CBB_cleanup(cbb);
+    return -1;
+  }
+  if (der_len > INT_MAX) {
+    OPENSSL_free(der);
+    return -1;
+  }
+  if (outp != NULL) {
+    if (*outp == NULL) {
+      *outp = der;
+      der = NULL;
+    } else {
+      OPENSSL_memcpy(*outp, der, der_len);
+      *outp += der_len;
+    }
+  }
+  OPENSSL_free(der);
+  return (int)der_len;
+}

data/third_party/boringssl-with-bazel/src/crypto/bytestring/{ber.c → ber.cc}

@@ -1,16 +1,16 @@
-/* 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. */
+// Copyright 2014 The BoringSSL Authors
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     https://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
 
 #include <openssl/bytestring.h>
 

data/third_party/boringssl-with-bazel/src/crypto/bytestring/{cbb.c → cbb.cc}

@@ -1,16 +1,16 @@
-/* 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. */
+// Copyright 2014 The BoringSSL Authors
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     https://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
 
 #include <openssl/bytestring.h>
 
@@ -18,15 +18,13 @@
 #include <limits.h>
 #include <string.h>
 
-#include <openssl/mem.h>
 #include <openssl/err.h>
+#include <openssl/mem.h>
 
 #include "../internal.h"
 
 
-void CBB_zero(CBB *cbb) {
-  OPENSSL_memset(cbb, 0, sizeof(CBB));
-}
+void CBB_zero(CBB *cbb) { OPENSSL_memset(cbb, 0, sizeof(CBB)); }
 
 static void cbb_init(CBB *cbb, uint8_t *buf, size_t cap, int can_resize) {
   cbb->is_child = 0;
@@ -41,7 +39,7 @@ static void cbb_init(CBB *cbb, uint8_t *buf, size_t cap, int can_resize) {
 int CBB_init(CBB *cbb, size_t initial_capacity) {
   CBB_zero(cbb);
 
-  uint8_t *buf = OPENSSL_malloc(initial_capacity);
+  uint8_t *buf = reinterpret_cast<uint8_t *>(OPENSSL_malloc(initial_capacity));
   if (initial_capacity > 0 && buf == NULL) {
     return 0;
   }
@@ -92,7 +90,8 @@ static int cbb_buffer_reserve(struct cbb_buffer_st *base, uint8_t **out,
     if (newcap < base->cap || newcap < newlen) {
       newcap = newlen;
     }
-    uint8_t *newbuf = OPENSSL_realloc(base->buf, newcap);
+    uint8_t *newbuf =
+        reinterpret_cast<uint8_t *>(OPENSSL_realloc(base->buf, newcap));
     if (newbuf == NULL) {
       goto err;
     }
@@ -200,13 +199,13 @@ int CBB_flush(CBB *cbb) {
   assert(child->base == base);
   size_t child_start = child->offset + child->pending_len_len;
 
-  if (!CBB_flush(cbb->child) ||
-      child_start < child->offset ||
+  size_t len;
+  if (!CBB_flush(cbb->child) || child_start < child->offset ||
       base->len < child_start) {
     goto err;
   }
 
-  size_t len = base->len - child_start;
+  len = base->len - child_start;
 
   if (child->pending_is_asn1) {
     // For ASN.1 we assume that we'll only need a single byte for the length.
@@ -215,7 +214,7 @@ int CBB_flush(CBB *cbb) {
     uint8_t len_len;
     uint8_t initial_length_byte;
 
-    assert (child->pending_len_len == 1);
+    assert(child->pending_len_len == 1);
 
     if (len > 0xfffffffe) {
       OPENSSL_PUT_ERROR(CRYPTO, ERR_R_OVERFLOW);
@@ -403,8 +402,7 @@ int CBB_add_zeros(CBB *cbb, size_t len) {
 }
 
 int CBB_add_space(CBB *cbb, uint8_t **out_data, size_t len) {
-  if (!CBB_flush(cbb) ||
-      !cbb_buffer_add(cbb_get_base(cbb), out_data, len)) {
+  if (!CBB_flush(cbb) || !cbb_buffer_add(cbb_get_base(cbb), out_data, len)) {
     return 0;
   }
   return 1;
@@ -421,9 +419,7 @@ int CBB_reserve(CBB *cbb, uint8_t **out_data, size_t len) {
 int CBB_did_write(CBB *cbb, size_t len) {
   struct cbb_buffer_st *base = cbb_get_base(cbb);
   size_t newlen = base->len + len;
-  if (cbb->child != NULL ||
-      newlen < base->len ||
-      newlen > base->cap) {
+  if (cbb->child != NULL || newlen < base->len || newlen > base->cap) {
     return 0;
   }
   base->len = newlen;
@@ -450,33 +446,23 @@ static int cbb_add_u(CBB *cbb, uint64_t v, size_t len_len) {
   return 1;
 }
 
-int CBB_add_u8(CBB *cbb, uint8_t value) {
-  return cbb_add_u(cbb, value, 1);
-}
+int CBB_add_u8(CBB *cbb, uint8_t value) { return cbb_add_u(cbb, value, 1); }
 
-int CBB_add_u16(CBB *cbb, uint16_t value) {
-  return cbb_add_u(cbb, value, 2);
-}
+int CBB_add_u16(CBB *cbb, uint16_t value) { return cbb_add_u(cbb, value, 2); }
 
 int CBB_add_u16le(CBB *cbb, uint16_t value) {
   return CBB_add_u16(cbb, CRYPTO_bswap2(value));
 }
 
-int CBB_add_u24(CBB *cbb, uint32_t value) {
-  return cbb_add_u(cbb, value, 3);
-}
+int CBB_add_u24(CBB *cbb, uint32_t value) { return cbb_add_u(cbb, value, 3); }
 
-int CBB_add_u32(CBB *cbb, uint32_t value) {
-  return cbb_add_u(cbb, value, 4);
-}
+int CBB_add_u32(CBB *cbb, uint32_t value) { return cbb_add_u(cbb, value, 4); }
 
 int CBB_add_u32le(CBB *cbb, uint32_t value) {
   return CBB_add_u32(cbb, CRYPTO_bswap4(value));
 }
 
-int CBB_add_u64(CBB *cbb, uint64_t value) {
-  return cbb_add_u(cbb, value, 8);
-}
+int CBB_add_u64(CBB *cbb, uint64_t value) { return cbb_add_u(cbb, value, 8); }
 
 int CBB_add_u64le(CBB *cbb, uint64_t value) {
   return CBB_add_u64(cbb, CRYPTO_bswap8(value));
@@ -501,13 +487,13 @@ int CBB_add_asn1_uint64(CBB *cbb, uint64_t value) {
 
 int CBB_add_asn1_uint64_with_tag(CBB *cbb, uint64_t value, CBS_ASN1_TAG tag) {
   CBB child;
+  int started = 0;
   if (!CBB_add_asn1(cbb, &child, tag)) {
     goto err;
   }
 
-  int started = 0;
   for (size_t i = 0; i < 8; i++) {
-    uint8_t byte = (value >> 8*(7-i)) & 0xff;
+    uint8_t byte = (value >> 8 * (7 - i)) & 0xff;
     if (!started) {
       if (byte == 0) {
         // Don't encode leading zeros.
@@ -573,8 +559,7 @@ err:
 int CBB_add_asn1_octet_string(CBB *cbb, const uint8_t *data, size_t data_len) {
   CBB child;
   if (!CBB_add_asn1(cbb, &child, CBS_ASN1_OCTETSTRING) ||
-      !CBB_add_bytes(&child, data, data_len) ||
-      !CBB_flush(cbb)) {
+      !CBB_add_bytes(&child, data, data_len) || !CBB_flush(cbb)) {
     cbb_on_error(cbb);
     return 0;
   }
@@ -585,8 +570,7 @@ int CBB_add_asn1_octet_string(CBB *cbb, const uint8_t *data, size_t data_len) {
 int CBB_add_asn1_bool(CBB *cbb, int value) {
   CBB child;
   if (!CBB_add_asn1(cbb, &child, CBS_ASN1_BOOLEAN) ||
-      !CBB_add_u8(&child, value != 0 ? 0xff : 0) ||
-      !CBB_flush(cbb)) {
+      !CBB_add_u8(&child, value != 0 ? 0xff : 0) || !CBB_flush(cbb)) {
     cbb_on_error(cbb);
     return 0;
   }
@@ -620,24 +604,20 @@ int CBB_add_asn1_oid_from_text(CBB *cbb, const char *text, size_t len) {
 
   // OIDs must have at least two components.
   uint64_t a, b;
-  if (!parse_dotted_decimal(&cbs, &a) ||
-      !parse_dotted_decimal(&cbs, &b)) {
+  if (!parse_dotted_decimal(&cbs, &a) || !parse_dotted_decimal(&cbs, &b)) {
     return 0;
   }
 
   // The first component is encoded as 40 * |a| + |b|. This assumes that |a| is
   // 0, 1, or 2 and that, when it is 0 or 1, |b| is at most 39.
-  if (a > 2 ||
-      (a < 2 && b > 39) ||
-      b > UINT64_MAX - 80 ||
+  if (a > 2 || (a < 2 && b > 39) || b > UINT64_MAX - 80 ||
       !add_base128_integer(cbb, 40u * a + b)) {
     return 0;
   }
 
   // The remaining components are encoded unmodified.
   while (CBS_len(&cbs) > 0) {
-    if (!parse_dotted_decimal(&cbs, &a) ||
-        !add_base128_integer(cbb, a)) {
+    if (!parse_dotted_decimal(&cbs, &a) || !add_base128_integer(cbb, a)) {
       return 0;
     }
   }
@@ -648,7 +628,8 @@ int CBB_add_asn1_oid_from_text(CBB *cbb, const char *text, size_t len) {
 static int compare_set_of_element(const void *a_ptr, const void *b_ptr) {
   // See X.690, section 11.6 for the ordering. They are sorted in ascending
   // order by their DER encoding.
-  const CBS *a = a_ptr, *b = b_ptr;
+  const CBS *a = reinterpret_cast<const CBS *>(a_ptr),
+            *b = reinterpret_cast<const CBS *>(b_ptr);
   size_t a_len = CBS_len(a), b_len = CBS_len(b);
   size_t min_len = a_len < b_len ? a_len : b_len;
   int ret = OPENSSL_memcmp(CBS_data(a), CBS_data(b), min_len);
@@ -687,8 +668,12 @@ int CBB_flush_asn1_set_of(CBB *cbb) {
   // remain valid as we rewrite |cbb|.
   int ret = 0;
   size_t buf_len = CBB_len(cbb);
-  uint8_t *buf = OPENSSL_memdup(CBB_data(cbb), buf_len);
-  CBS *children = OPENSSL_calloc(num_children, sizeof(CBS));
+  uint8_t *buf =
+      reinterpret_cast<uint8_t *>(OPENSSL_memdup(CBB_data(cbb), buf_len));
+  CBS *children =
+      reinterpret_cast<CBS *>(OPENSSL_calloc(num_children, sizeof(CBS)));
+  uint8_t *out;
+  size_t offset = 0;
   if (buf == NULL || children == NULL) {
     goto err;
   }
@@ -701,8 +686,7 @@ int CBB_flush_asn1_set_of(CBB *cbb) {
   qsort(children, num_children, sizeof(CBS), compare_set_of_element);
 
   // Write the contents back in the new order.
-  uint8_t *out = (uint8_t *)CBB_data(cbb);
-  size_t offset = 0;
+  out = (uint8_t *)CBB_data(cbb);
   for (size_t i = 0; i < num_children; i++) {
     OPENSSL_memcpy(out + offset, CBS_data(&children[i]), CBS_len(&children[i]));
     offset += CBS_len(&children[i]);