grpc 1.53.2 → 1.54.0

data/third_party/boringssl-with-bazel/src/crypto/bn_extra/convert.c

@@ -81,7 +81,6 @@ char *BN_bn2hex(const BIGNUM *bn) {
   char *buf = OPENSSL_malloc(1 /* leading '-' */ + 1 /* zero is non-empty */ +
                              width * BN_BYTES * 2 + 1 /* trailing NUL */);
   if (buf == NULL) {
-    OPENSSL_PUT_ERROR(BN, ERR_R_MALLOC_FAILURE);
     return NULL;
   }
 
@@ -133,18 +132,9 @@ static int decode_hex(BIGNUM *bn, const char *in, int in_len) {
     BN_ULONG word = 0;
     int j;
     for (j = todo; j > 0; j--) {
-      char c = in[in_len - j];
-
-      BN_ULONG hex;
-      if (c >= '0' && c <= '9') {
-        hex = c - '0';
-      } else if (c >= 'a' && c <= 'f') {
-        hex = c - 'a' + 10;
-      } else if (c >= 'A' && c <= 'F') {
-        hex = c - 'A' + 10;
-      } else {
-        hex = 0;
-        // This shouldn't happen. The caller checks |isxdigit|.
+      uint8_t hex = 0;
+      if (!OPENSSL_fromxdigit(&hex, in[in_len - j])) {
+        // This shouldn't happen. The caller checks |OPENSSL_isxdigit|.
         assert(0);
       }
       word = (word << 4) | hex;
@@ -240,7 +230,7 @@ err:
 }
 
 int BN_hex2bn(BIGNUM **outp, const char *in) {
-  return bn_x2bn(outp, in, decode_hex, isxdigit);
+  return bn_x2bn(outp, in, decode_hex, OPENSSL_isxdigit);
 }
 
 char *BN_bn2dec(const BIGNUM *a) {
@@ -250,12 +240,12 @@ char *BN_bn2dec(const BIGNUM *a) {
   CBB cbb;
   if (!CBB_init(&cbb, 16) ||
       !CBB_add_u8(&cbb, 0 /* trailing NUL */)) {
-    goto cbb_err;
+    goto err;
   }
 
   if (BN_is_zero(a)) {
     if (!CBB_add_u8(&cbb, '0')) {
-      goto cbb_err;
+      goto err;
     }
   } else {
     copy = BN_dup(a);
@@ -272,7 +262,7 @@ char *BN_bn2dec(const BIGNUM *a) {
       const int add_leading_zeros = !BN_is_zero(copy);
       for (int i = 0; i < BN_DEC_NUM && (add_leading_zeros || word != 0); i++) {
         if (!CBB_add_u8(&cbb, '0' + word % 10)) {
-          goto cbb_err;
+          goto err;
         }
         word /= 10;
       }
@@ -282,13 +272,13 @@ char *BN_bn2dec(const BIGNUM *a) {
 
   if (BN_is_negative(a) &&
       !CBB_add_u8(&cbb, '-')) {
-    goto cbb_err;
+    goto err;
   }
 
   uint8_t *data;
   size_t len;
   if (!CBB_finish(&cbb, &data, &len)) {
-    goto cbb_err;
+    goto err;
   }
 
   // Reverse the buffer.
@@ -301,8 +291,6 @@ char *BN_bn2dec(const BIGNUM *a) {
   BN_free(copy);
   return (char *)data;
 
-cbb_err:
-  OPENSSL_PUT_ERROR(BN, ERR_R_MALLOC_FAILURE);
 err:
   BN_free(copy);
   CBB_cleanup(&cbb);
@@ -310,7 +298,7 @@ err:
 }
 
 int BN_dec2bn(BIGNUM **outp, const char *in) {
-  return bn_x2bn(outp, in, decode_dec, isdigit);
+  return bn_x2bn(outp, in, decode_dec, OPENSSL_isdigit);
 }
 
 int BN_asc2bn(BIGNUM **outp, const char *in) {
@@ -436,7 +424,6 @@ BIGNUM *BN_mpi2bn(const uint8_t *in, size_t len, BIGNUM *out) {
   if (out == NULL) {
     out = BN_new();
     if (out == NULL) {
-      OPENSSL_PUT_ERROR(BN, ERR_R_MALLOC_FAILURE);
       return NULL;
     }
     out_is_alloced = 1;

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

@@ -69,7 +69,6 @@ BUF_MEM *BUF_MEM_new(void) {
 
   ret = OPENSSL_malloc(sizeof(BUF_MEM));
   if (ret == NULL) {
-    OPENSSL_PUT_ERROR(BUF, ERR_R_MALLOC_FAILURE);
     return NULL;
   }
 
@@ -93,21 +92,18 @@ int BUF_MEM_reserve(BUF_MEM *buf, size_t cap) {
 
   size_t n = cap + 3;
   if (n < cap) {
-    // overflow
-    OPENSSL_PUT_ERROR(BUF, ERR_R_MALLOC_FAILURE);
+    OPENSSL_PUT_ERROR(BUF, ERR_R_OVERFLOW);
     return 0;
   }
   n = n / 3;
   size_t alloc_size = n * 4;
   if (alloc_size / 4 != n) {
-    // overflow
-    OPENSSL_PUT_ERROR(BUF, ERR_R_MALLOC_FAILURE);
+    OPENSSL_PUT_ERROR(BUF, ERR_R_OVERFLOW);
     return 0;
   }
 
   char *new_buf = OPENSSL_realloc(buf->data, alloc_size);
   if (new_buf == NULL) {
-    OPENSSL_PUT_ERROR(BUF, ERR_R_MALLOC_FAILURE);
     return 0;
   }
 

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

@@ -26,7 +26,8 @@
 
 
 int CBB_finish_i2d(CBB *cbb, uint8_t **outp) {
-  assert(cbb->base->can_resize);
+  assert(!cbb->is_child);
+  assert(cbb->u.base.can_resize);
 
   uint8_t *der;
   size_t der_len;

data/third_party/boringssl-with-bazel/src/crypto/bytestring/ber.c

@@ -24,11 +24,11 @@
 // kMaxDepth is a just a sanity limit. The code should be such that the length
 // of the input being processes always decreases. None the less, a very large
 // input could otherwise cause the stack to overflow.
-static const unsigned kMaxDepth = 2048;
+static const uint32_t kMaxDepth = 2048;
 
 // is_string_type returns one if |tag| is a string type and zero otherwise. It
 // ignores the constructed bit.
-static int is_string_type(unsigned tag) {
+static int is_string_type(CBS_ASN1_TAG tag) {
   // While BER supports constructed BIT STRINGS, OpenSSL misparses them. To
   // avoid acting on an ambiguous input, we do not support constructed BIT
   // STRINGS. See https://github.com/openssl/openssl/issues/12810.
@@ -55,7 +55,7 @@ static int is_string_type(unsigned tag) {
 // depending on whether an indefinite length element or constructed string was
 // found. The value of |orig_in| is not changed. It returns one on success (i.e.
 // |*ber_found| was set) and zero on error.
-static int cbs_find_ber(const CBS *orig_in, int *ber_found, unsigned depth) {
+static int cbs_find_ber(const CBS *orig_in, int *ber_found, uint32_t depth) {
   CBS in;
 
   if (depth > kMaxDepth) {
@@ -67,11 +67,11 @@ static int cbs_find_ber(const CBS *orig_in, int *ber_found, unsigned depth) {
 
   while (CBS_len(&in) > 0) {
     CBS contents;
-    unsigned tag;
+    CBS_ASN1_TAG tag;
     size_t header_len;
-
+    int indefinite;
     if (!CBS_get_any_ber_asn1_element(&in, &contents, &tag, &header_len,
-                                      ber_found)) {
+                                      ber_found, &indefinite)) {
       return 0;
     }
     if (*ber_found) {
@@ -93,11 +93,14 @@ static int cbs_find_ber(const CBS *orig_in, int *ber_found, unsigned depth) {
   return 1;
 }
 
-// is_eoc returns true if |header_len| and |contents|, as returned by
-// |CBS_get_any_ber_asn1_element|, indicate an "end of contents" (EOC) value.
-static char is_eoc(size_t header_len, CBS *contents) {
-  return header_len == 2 && CBS_len(contents) == 2 &&
-         OPENSSL_memcmp(CBS_data(contents), "\x00\x00", 2) == 0;
+// cbs_get_eoc returns one if |cbs| begins with an "end of contents" (EOC) value
+// and zero otherwise. If an EOC was found, it advances |cbs| past it.
+static int cbs_get_eoc(CBS *cbs) {
+  if (CBS_len(cbs) >= 2 &&
+      CBS_data(cbs)[0] == 0 && CBS_data(cbs)[1] == 0) {
+    return CBS_skip(cbs, 2);
+  }
+  return 0;
 }
 
 // cbs_convert_ber reads BER data from |in| and writes DER data to |out|. If
@@ -107,8 +110,8 @@ static char is_eoc(size_t header_len, CBS *contents) {
 // constructed string. If |looking_for_eoc| is set then any EOC elements found
 // will cause the function to return after consuming it. It returns one on
 // success and zero on error.
-static int cbs_convert_ber(CBS *in, CBB *out, unsigned string_tag,
-                           char looking_for_eoc, unsigned depth) {
+static int cbs_convert_ber(CBS *in, CBB *out, CBS_ASN1_TAG string_tag,
+                           int looking_for_eoc, uint32_t depth) {
   assert(!(string_tag & CBS_ASN1_CONSTRUCTED));
 
   if (depth > kMaxDepth) {
@@ -116,21 +119,20 @@ static int cbs_convert_ber(CBS *in, CBB *out, unsigned string_tag,
   }
 
   while (CBS_len(in) > 0) {
+    if (looking_for_eoc && cbs_get_eoc(in)) {
+      return 1;
+    }
+
     CBS contents;
-    unsigned tag, child_string_tag = string_tag;
+    CBS_ASN1_TAG tag, child_string_tag = string_tag;
     size_t header_len;
-    int ber_found;
+    int indefinite;
     CBB *out_contents, out_contents_storage;
-
     if (!CBS_get_any_ber_asn1_element(in, &contents, &tag, &header_len,
-                                      &ber_found)) {
+                                      /*out_ber_found=*/NULL, &indefinite)) {
       return 0;
     }
 
-    if (is_eoc(header_len, &contents)) {
-      return looking_for_eoc;
-    }
-
     if (string_tag != 0) {
       // This is part of a constructed string. All elements must match
       // |string_tag| up to the constructed bit and get appended to |out|
@@ -140,7 +142,7 @@ static int cbs_convert_ber(CBS *in, CBB *out, unsigned string_tag,
       }
       out_contents = out;
     } else {
-      unsigned out_tag = tag;
+      CBS_ASN1_TAG out_tag = tag;
       if ((tag & CBS_ASN1_CONSTRUCTED) && is_string_type(tag)) {
         // If a constructed string, clear the constructed bit and inform
         // children to concatenate bodies.
@@ -153,11 +155,9 @@ static int cbs_convert_ber(CBS *in, CBB *out, unsigned string_tag,
       out_contents = &out_contents_storage;
     }
 
-    if (CBS_len(&contents) == header_len && header_len > 0 &&
-        CBS_data(&contents)[header_len - 1] == 0x80) {
-      // This is an indefinite length element.
+    if (indefinite) {
       if (!cbs_convert_ber(in, out_contents, child_string_tag,
-                           1 /* looking for eoc */, depth + 1) ||
+                           /*looking_for_eoc=*/1, depth + 1) ||
           !CBB_flush(out)) {
         return 0;
       }
@@ -171,7 +171,7 @@ static int cbs_convert_ber(CBS *in, CBB *out, unsigned string_tag,
     if (tag & CBS_ASN1_CONSTRUCTED) {
       // Recurse into children.
       if (!cbs_convert_ber(&contents, out_contents, child_string_tag,
-                           0 /* not looking for eoc */, depth + 1)) {
+                           /*looking_for_eoc=*/0, depth + 1)) {
         return 0;
       }
     } else {
@@ -221,7 +221,8 @@ int CBS_asn1_ber_to_der(CBS *in, CBS *out, uint8_t **out_storage) {
 }
 
 int CBS_get_asn1_implicit_string(CBS *in, CBS *out, uint8_t **out_storage,
-                                 unsigned outer_tag, unsigned inner_tag) {
+                                 CBS_ASN1_TAG outer_tag,
+                                 CBS_ASN1_TAG inner_tag) {
   assert(!(outer_tag & CBS_ASN1_CONSTRUCTED));
   assert(!(inner_tag & CBS_ASN1_CONSTRUCTED));
   assert(is_string_type(inner_tag));