grpc 1.84.0 → 1.85.0.pre1

data/third_party/boringssl-with-bazel/crypto/bn/convert.cc

@@ -19,6 +19,8 @@
 #include <limits.h>
 #include <stdio.h>
 
+#include <algorithm>
+
 #include <openssl/bio.h>
 #include <openssl/bytestring.h>
 #include <openssl/err.h>
@@ -27,6 +29,8 @@
 #include "../fipsmodule/bn/internal.h"
 
 
+using namespace bssl;
+
 int BN_bn2cbb_padded(CBB *out, size_t len, const BIGNUM *in) {
   uint8_t *ptr;
   return CBB_add_space(out, &ptr, len) && BN_bn2bin_padded(ptr, len, in);
@@ -39,8 +43,8 @@ char *BN_bn2hex(const BIGNUM *bn) {
   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;
+  if (buf == nullptr) {
+    return nullptr;
   }
 
   char *p = buf;
@@ -69,20 +73,20 @@ char *BN_bn2hex(const BIGNUM *bn) {
   return buf;
 }
 
-// decode_hex decodes |in_len| bytes of hex data from |in| and updates |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) {
     OPENSSL_PUT_ERROR(BN, BN_R_BIGNUM_TOO_LONG);
     return 0;
   }
-  // |in_len| is the number of hex digits.
+  // `in_len` is the number of hex digits.
   if (!bn_expand(bn, in_len * 4)) {
     return 0;
   }
 
   int i = 0;
   while (in_len > 0) {
-    // Decode one |BN_ULONG| at a time.
+    // Decode one `BN_ULONG` at a time.
     int todo = BN_BYTES * 2;
     if (todo > in_len) {
       todo = in_len;
@@ -93,7 +97,7 @@ static int decode_hex(BIGNUM *bn, const char *in, int in_len) {
     for (j = todo; j > 0; j--) {
       uint8_t hex = 0;
       if (!OPENSSL_fromxdigit(&hex, in[in_len - j])) {
-        // This shouldn't happen. The caller checks |OPENSSL_isxdigit|.
+        // This shouldn't happen. The caller checks `OPENSSL_isxdigit`.
         assert(0);
       }
       word = (word << 4) | hex;
@@ -107,12 +111,12 @@ static int decode_hex(BIGNUM *bn, const char *in, int in_len) {
   return 1;
 }
 
-// decode_dec decodes |in_len| bytes of decimal data from |in| and updates |bn|.
+// decode_dec decodes `in_len` bytes of decimal data from `in` and updates `bn`.
 static int decode_dec(BIGNUM *bn, const char *in, int in_len) {
   int i, j;
   BN_ULONG l = 0;
 
-  // Decode |BN_DEC_NUM| digits at a time.
+  // Decode `BN_DEC_NUM` digits at a time.
   j = BN_DEC_NUM - (in_len % BN_DEC_NUM);
   if (j == BN_DEC_NUM) {
     j = 0;
@@ -137,11 +141,11 @@ typedef int (*char_test_func)(int c);
 
 static int bn_x2bn(BIGNUM **outp, const char *in, decode_func decode,
                    char_test_func want_char) {
-  BIGNUM *ret = NULL;
+  BIGNUM *ret = nullptr;
   int neg = 0, i;
   int num;
 
-  if (in == NULL || *in == 0) {
+  if (in == nullptr || *in == 0) {
     return 0;
   }
 
@@ -154,14 +158,14 @@ static int bn_x2bn(BIGNUM **outp, const char *in, decode_func decode,
   }
 
   num = i + neg;
-  if (outp == NULL) {
+  if (outp == nullptr) {
     return num;
   }
 
   // in is the start of the hex digits, and it is 'i' long
-  if (*outp == NULL) {
+  if (*outp == nullptr) {
     ret = BN_new();
-    if (ret == NULL) {
+    if (ret == nullptr) {
       return 0;
     }
   } else {
@@ -182,7 +186,7 @@ static int bn_x2bn(BIGNUM **outp, const char *in, decode_func decode,
   return num;
 
 err:
-  if (*outp == NULL) {
+  if (*outp == nullptr) {
     BN_free(ret);
   }
 
@@ -196,33 +200,32 @@ int BN_hex2bn(BIGNUM **outp, const char *in) {
 char *BN_bn2dec(const BIGNUM *a) {
   // It is easier to print strings little-endian, so we assemble it in reverse
   // and fix at the end.
-  BIGNUM *copy = NULL;
-  CBB cbb;
-  if (!CBB_init(&cbb, 16) || //
-      !CBB_add_u8(&cbb, 0 /* trailing NUL */)) {
-    goto err;
+  ScopedCBB cbb;
+  if (!CBB_init(cbb.get(), 16) || //
+      !CBB_add_u8(cbb.get(), 0 /* trailing NUL */)) {
+    return nullptr;
   }
 
   if (BN_is_zero(a)) {
-    if (!CBB_add_u8(&cbb, '0')) {
-      goto err;
+    if (!CBB_add_u8(cbb.get(), '0')) {
+      return nullptr;
     }
   } else {
-    copy = BN_dup(a);
-    if (copy == NULL) {
-      goto err;
+    UniquePtr<BIGNUM> copy(BN_dup(a));
+    if (copy == nullptr) {
+      return nullptr;
     }
 
-    while (!BN_is_zero(copy)) {
-      BN_ULONG word = BN_div_word(copy, BN_DEC_CONV);
+    while (!BN_is_zero(copy.get())) {
+      BN_ULONG word = BN_div_word(copy.get(), BN_DEC_CONV);
       if (word == (BN_ULONG)-1) {
-        goto err;
+        return nullptr;
       }
 
-      const int add_leading_zeros = !BN_is_zero(copy);
+      const int add_leading_zeros = !BN_is_zero(copy.get());
       for (int i = 0; i < BN_DEC_NUM && (add_leading_zeros || word != 0); i++) {
-        if (!CBB_add_u8(&cbb, '0' + word % 10)) {
-          goto err;
+        if (!CBB_add_u8(cbb.get(), '0' + word % 10)) {
+          return nullptr;
         }
         word /= 10;
       }
@@ -231,30 +234,18 @@ char *BN_bn2dec(const BIGNUM *a) {
   }
 
   if (BN_is_negative(a) && //
-      !CBB_add_u8(&cbb, '-')) {
-    goto err;
+      !CBB_add_u8(cbb.get(), '-')) {
+    return nullptr;
   }
 
   uint8_t *data;
   size_t len;
-  if (!CBB_finish(&cbb, &data, &len)) {
-    goto err;
-  }
-
-  // Reverse the buffer.
-  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;
+  if (!CBB_finish(cbb.get(), &data, &len)) {
+    return nullptr;
   }
 
-  BN_free(copy);
-  return (char *)data;
-
-err:
-  BN_free(copy);
-  CBB_cleanup(&cbb);
-  return NULL;
+  std::reverse(data, data + len);
+  return reinterpret_cast<char *>(data);
 }
 
 int BN_dec2bn(BIGNUM **outp, const char *in) {
@@ -285,38 +276,33 @@ int BN_asc2bn(BIGNUM **outp, const char *in) {
 }
 
 int BN_print(BIO *bp, const BIGNUM *a) {
-  int i, j, v, z = 0;
-  int ret = 0;
-
   if (a->neg && BIO_write(bp, "-", 1) != 1) {
-    goto end;
+    return 0;
   }
 
   if (BN_is_zero(a) && BIO_write(bp, "0", 1) != 1) {
-    goto end;
+    return 0;
   }
 
-  for (i = bn_minimal_width(a) - 1; i >= 0; i--) {
-    for (j = BN_BITS2 - 4; j >= 0; j -= 4) {
+  int z = 0;
+  for (int i = bn_minimal_width(a) - 1; i >= 0; i--) {
+    for (int j = BN_BITS2 - 4; j >= 0; j -= 4) {
       // strip leading zeros
-      v = ((int)(a->d[i] >> (long)j)) & 0x0f;
+      int v = ((int)(a->d[i] >> (long)j)) & 0x0f;
       if (z || v != 0) {
         if (BIO_write(bp, &hextable[v], 1) != 1) {
-          goto end;
+          return 0;
         }
         z = 1;
       }
     }
   }
-  ret = 1;
-
-end:
-  return ret;
+  return 1;
 }
 
 int BN_print_fp(FILE *fp, const BIGNUM *a) {
   BIO *b = BIO_new_fp(fp, BIO_NOCLOSE);
-  if (b == NULL) {
+  if (b == nullptr) {
     return 0;
   }
 
@@ -346,7 +332,7 @@ size_t BN_bn2mpi(const BIGNUM *in, uint8_t *out) {
     return 4;
   }
 
-  if (out == NULL) {
+  if (out == nullptr) {
     return 4 + len;
   }
 
@@ -367,7 +353,7 @@ size_t BN_bn2mpi(const BIGNUM *in, uint8_t *out) {
 BIGNUM *BN_mpi2bn(const uint8_t *in, size_t len, BIGNUM *out) {
   if (len < 4) {
     OPENSSL_PUT_ERROR(BN, BN_R_BAD_ENCODING);
-    return NULL;
+    return nullptr;
   }
   const size_t in_len = ((size_t)in[0] << 24) | //
                         ((size_t)in[1] << 16) | //
@@ -375,14 +361,14 @@ BIGNUM *BN_mpi2bn(const uint8_t *in, size_t len, BIGNUM *out) {
                         ((size_t)in[3]);
   if (in_len != len - 4) {
     OPENSSL_PUT_ERROR(BN, BN_R_BAD_ENCODING);
-    return NULL;
+    return nullptr;
   }
 
   int out_is_alloced = 0;
-  if (out == NULL) {
+  if (out == nullptr) {
     out = BN_new();
-    if (out == NULL) {
-      return NULL;
+    if (out == nullptr) {
+      return nullptr;
     }
     out_is_alloced = 1;
   }
@@ -393,11 +379,11 @@ BIGNUM *BN_mpi2bn(const uint8_t *in, size_t len, BIGNUM *out) {
   }
 
   in += 4;
-  if (BN_bin2bn(in, in_len, out) == NULL) {
+  if (BN_bin2bn(in, in_len, out) == nullptr) {
     if (out_is_alloced) {
       BN_free(out);
     }
-    return NULL;
+    return nullptr;
   }
   out->neg = ((*in) & 0x80) != 0;
   if (out->neg) {

data/third_party/boringssl-with-bazel/crypto/bn/div.cc

@@ -0,0 +1,102 @@
+// 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>
+
+#include <openssl/err.h>
+
+#include "../fipsmodule/bn/internal.h"
+#include "../internal.h"
+
+
+using namespace bssl;
+
+int BN_mod_pow2(BIGNUM *r, const BIGNUM *a, size_t e) {
+  if (e == 0 || a->width == 0) {
+    BN_zero(r);
+    return 1;
+  }
+
+  size_t num_words = 1 + ((e - 1) / BN_BITS2);
+
+  // If `a` definitely has less than `e` bits, just BN_copy.
+  if ((size_t)a->width < num_words) {
+    return BN_copy(r, a) != nullptr;
+  }
+
+  // Otherwise, first make sure we have enough space in `r`.
+  // Note that this will fail if num_words > INT_MAX.
+  if (!bn_wexpand(r, num_words)) {
+    return 0;
+  }
+
+  // Copy the content of `a` into `r`.
+  OPENSSL_memcpy(r->d, a->d, num_words * sizeof(BN_ULONG));
+
+  // If `e` isn't word-aligned, we have to mask off some of our bits.
+  size_t top_word_exponent = e % (sizeof(BN_ULONG) * 8);
+  if (top_word_exponent != 0) {
+    r->d[num_words - 1] &= (((BN_ULONG)1) << top_word_exponent) - 1;
+  }
+
+  // Fill in the remaining fields of `r`.
+  r->neg = a->neg;
+  r->width = (int)num_words;
+  bn_set_minimal_width(r);
+  return 1;
+}
+
+int BN_nnmod_pow2(BIGNUM *r, const BIGNUM *a, size_t e) {
+  if (!BN_mod_pow2(r, a, e)) {
+    return 0;
+  }
+
+  // If the returned value was non-negative, we're done.
+  if (BN_is_zero(r) || !r->neg) {
+    return 1;
+  }
+
+  size_t num_words = 1 + (e - 1) / BN_BITS2;
+
+  // Expand `r` to the size of our modulus.
+  if (!bn_wexpand(r, num_words)) {
+    return 0;
+  }
+
+  // Clear the upper words of `r`.
+  OPENSSL_memset(&r->d[r->width], 0, (num_words - r->width) * BN_BYTES);
+
+  // Set parameters of `r`.
+  r->neg = 0;
+  r->width = (int)num_words;
+
+  // Now, invert every word. The idea here is that we want to compute 2^e-`x`,
+  // which is actually equivalent to the twos-complement representation of `x`
+  // in `e` bits, which is -x = ~x + 1.
+  for (int i = 0; i < r->width; i++) {
+    r->d[i] = ~r->d[i];
+  }
+
+  // If our exponent doesn't span the top word, we have to mask the rest.
+  size_t top_word_exponent = e % BN_BITS2;
+  if (top_word_exponent != 0) {
+    r->d[r->width - 1] &= (((BN_ULONG)1) << top_word_exponent) - 1;
+  }
+
+  // Keep the minimal-width invariant for `BIGNUM`.
+  bn_set_minimal_width(r);
+
+  // Finally, add one, for the reason described above.
+  return BN_add(r, r, BN_value_one());
+}

data/third_party/boringssl-with-bazel/crypto/bn/exponentiation.cc

@@ -21,8 +21,10 @@
 #include "../fipsmodule/bn/internal.h"
 
 
+using namespace bssl;
+
 int BN_exp(BIGNUM *r, const BIGNUM *a, const BIGNUM *p, BN_CTX *ctx) {
-  bssl::BN_CTXScope scope(ctx);
+  BN_CTXScope scope(ctx);
   BIGNUM *rr;
   if (r == a || r == p) {
     rr = BN_CTX_get(ctx);
@@ -31,17 +33,17 @@ int BN_exp(BIGNUM *r, const BIGNUM *a, const BIGNUM *p, BN_CTX *ctx) {
   }
 
   BIGNUM *v = BN_CTX_get(ctx);
-  if (rr == NULL || v == NULL) {
+  if (rr == nullptr || v == nullptr) {
     return 0;
   }
 
-  if (BN_copy(v, a) == NULL) {
+  if (BN_copy(v, a) == nullptr) {
     return 0;
   }
   int bits = BN_num_bits(p);
 
   if (BN_is_odd(p)) {
-    if (BN_copy(rr, a) == NULL) {
+    if (BN_copy(rr, a) == nullptr) {
       return 0;
     }
   } else {
@@ -78,8 +80,8 @@ static int mod_exp_even(BIGNUM *r, const BIGNUM *a, const BIGNUM *p,
     return BN_one(r);
   }
 
-  // Make a copy of |a|, in case it aliases |r|.
-  bssl::BN_CTXScope scope(ctx);
+  // Make a copy of `a`, in case it aliases `r`.
+  BN_CTXScope scope(ctx);
   BIGNUM *tmp = BN_CTX_get(ctx);
   if (tmp == nullptr || !BN_copy(tmp, a)) {
     return 0;
@@ -114,7 +116,7 @@ int BN_mod_exp(BIGNUM *r, const BIGNUM *a, const BIGNUM *p, const BIGNUM *m,
   }
 
   if (BN_is_odd(m)) {
-    return BN_mod_exp_mont(r, a, p, m, ctx, NULL);
+    return BN_mod_exp_mont(r, a, p, m, ctx, nullptr);
   }
 
   return mod_exp_even(r, a, p, m, ctx);
@@ -123,62 +125,44 @@ int BN_mod_exp(BIGNUM *r, const BIGNUM *a, const BIGNUM *p, const BIGNUM *m,
 int BN_mod_exp_mont_word(BIGNUM *rr, BN_ULONG a, const BIGNUM *p,
                          const BIGNUM *m, BN_CTX *ctx,
                          const BN_MONT_CTX *mont) {
-  BIGNUM a_bignum;
-  BN_init(&a_bignum);
-
-  int ret = 0;
-
   // BN_mod_exp_mont requires reduced inputs.
   if (bn_minimal_width(m) == 1) {
     a %= m->d[0];
   }
 
-  if (!BN_set_word(&a_bignum, a)) {
+  UniquePtr<BIGNUM> a_bignum(BN_new());
+  if (a_bignum == nullptr || !BN_set_word(a_bignum.get(), a)) {
     OPENSSL_PUT_ERROR(BN, ERR_R_INTERNAL_ERROR);
-    goto err;
+    return 0;
   }
 
-  ret = BN_mod_exp_mont(rr, &a_bignum, p, m, ctx, mont);
-
-err:
-  BN_free(&a_bignum);
-
-  return ret;
+  return BN_mod_exp_mont(rr, a_bignum.get(), p, m, ctx, mont);
 }
 
 int BN_mod_exp2_mont(BIGNUM *rr, const BIGNUM *a1, const BIGNUM *p1,
                      const BIGNUM *a2, const BIGNUM *p2, const BIGNUM *m,
                      BN_CTX *ctx, const BN_MONT_CTX *mont) {
-  BIGNUM tmp;
-  BN_init(&tmp);
-
-  int ret = 0;
-  BN_MONT_CTX *new_mont = NULL;
-
   // Allocate a montgomery context if it was not supplied by the caller.
-  if (mont == NULL) {
-    new_mont = BN_MONT_CTX_new_for_modulus(m, ctx);
-    if (new_mont == NULL) {
-      goto err;
+  UniquePtr<BN_MONT_CTX> new_mont;
+  if (mont == nullptr) {
+    new_mont.reset(BN_MONT_CTX_new_for_modulus(m, ctx));
+    if (new_mont == nullptr) {
+      return 0;
     }
-    mont = new_mont;
+    mont = new_mont.get();
   }
 
   // BN_mod_mul_montgomery removes one Montgomery factor, so passing one
   // Montgomery-encoded and one non-Montgomery-encoded value gives a
   // non-Montgomery-encoded result.
-  if (!BN_mod_exp_mont(rr, a1, p1, m, ctx, mont) ||
-      !BN_mod_exp_mont(&tmp, a2, p2, m, ctx, mont) ||
+  UniquePtr<BIGNUM> tmp(BN_new());
+  if (tmp == nullptr ||  //
+      !BN_mod_exp_mont(rr, a1, p1, m, ctx, mont) ||
+      !BN_mod_exp_mont(tmp.get(), a2, p2, m, ctx, mont) ||
       !BN_to_montgomery(rr, rr, mont, ctx) ||
-      !BN_mod_mul_montgomery(rr, rr, &tmp, mont, ctx)) {
-    goto err;
+      !BN_mod_mul_montgomery(rr, rr, tmp.get(), mont, ctx)) {
+    return 0;
   }
 
-  ret = 1;
-
-err:
-  BN_MONT_CTX_free(new_mont);
-  BN_free(&tmp);
-
-  return ret;
+  return 1;
 }

data/third_party/boringssl-with-bazel/crypto/bn/sqrt.cc

@@ -0,0 +1,93 @@
+// Copyright 2000-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>
+
+#include <openssl/err.h>
+
+
+int BN_sqrt(BIGNUM *out_sqrt, const BIGNUM *in, BN_CTX *ctx) {
+  BIGNUM *estimate, *tmp, *delta, *last_delta, *tmp2;
+  int ok = 0, last_delta_valid = 0;
+
+  if (in->neg) {
+    OPENSSL_PUT_ERROR(BN, BN_R_NEGATIVE_NUMBER);
+    return 0;
+  }
+  if (BN_is_zero(in)) {
+    BN_zero(out_sqrt);
+    return 1;
+  }
+
+  bssl::BN_CTXScope scope(ctx);
+  if (out_sqrt == in) {
+    estimate = BN_CTX_get(ctx);
+  } else {
+    estimate = out_sqrt;
+  }
+  tmp = BN_CTX_get(ctx);
+  last_delta = BN_CTX_get(ctx);
+  delta = BN_CTX_get(ctx);
+  if (estimate == nullptr || tmp == nullptr || last_delta == nullptr ||
+      delta == nullptr) {
+    goto err;
+  }
+
+  // We estimate that the square root of an n-bit number is 2^{n/2}.
+  if (!BN_lshift(estimate, BN_value_one(), BN_num_bits(in)/2)) {
+    goto err;
+  }
+
+  // This is Newton's method for finding a root of the equation `estimate`^2 -
+  // `in` = 0.
+  for (;;) {
+    // `estimate` = 1/2 * (`estimate` + `in`/`estimate`)
+    if (!BN_div(tmp, nullptr, in, estimate, ctx) ||
+        !BN_add(tmp, tmp, estimate) || !BN_rshift1(estimate, tmp) ||
+        // `tmp` = `estimate`^2
+        !BN_sqr(tmp, estimate, ctx) ||
+        // `delta` = `in` - `tmp`
+        !BN_sub(delta, in, tmp)) {
+      OPENSSL_PUT_ERROR(BN, ERR_R_BN_LIB);
+      goto err;
+    }
+
+    delta->neg = 0;
+    // The difference between `in` and `estimate` squared is required to always
+    // decrease. This ensures that the loop always terminates, but I don't have
+    // a proof that it always finds the square root for a given square.
+    if (last_delta_valid && BN_cmp(delta, last_delta) >= 0) {
+      break;
+    }
+
+    last_delta_valid = 1;
+
+    tmp2 = last_delta;
+    last_delta = delta;
+    delta = tmp2;
+  }
+
+  if (BN_cmp(tmp, in) != 0) {
+    OPENSSL_PUT_ERROR(BN, BN_R_NOT_A_SQUARE);
+    goto err;
+  }
+
+  ok = 1;
+
+err:
+  if (ok && out_sqrt == in && !BN_copy(out_sqrt, estimate)) {
+    ok = 0;
+  }
+  return ok;
+}

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

@@ -20,18 +20,19 @@
 #include <openssl/mem.h>
 
 #include "../internal.h"
+#include "../mem_internal.h"
 
 
-BUF_MEM *BUF_MEM_new(void) {
-  return reinterpret_cast<BUF_MEM *>(OPENSSL_zalloc(sizeof(BUF_MEM)));
-}
+using namespace bssl;
+
+BUF_MEM *BUF_MEM_new() { return New<BUF_MEM>(); }
 
 void BUF_MEM_free(BUF_MEM *buf) {
   if (buf == nullptr) {
     return;
   }
   OPENSSL_free(buf->data);
-  OPENSSL_free(buf);
+  Delete(buf);
 }
 
 int BUF_MEM_reserve(BUF_MEM *buf, size_t cap) {
@@ -53,7 +54,7 @@ int BUF_MEM_reserve(BUF_MEM *buf, size_t cap) {
 
   char *new_buf =
       reinterpret_cast<char *>(OPENSSL_realloc(buf->data, alloc_size));
-  if (new_buf == NULL) {
+  if (new_buf == nullptr) {
     return 0;
   }
 

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

@@ -25,24 +25,25 @@
 #include "../internal.h"
 
 
-int CBB_finish_i2d(CBB *cbb, uint8_t **outp) {
+using namespace bssl;
+
+int bssl::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) {
+  if (outp != nullptr) {
+    if (*outp == nullptr) {
       *outp = der;
-      der = NULL;
+      der = nullptr;
     } else {
       OPENSSL_memcpy(*outp, der, der_len);
       *outp += der_len;