grpc 1.32.0 → 1.36.0

data/third_party/boringssl-with-bazel/src/crypto/asn1/tasn_typ.c

@@ -117,8 +117,6 @@ IMPLEMENT_ASN1_TYPE_ex(ASN1_FBOOLEAN, ASN1_BOOLEAN, 0)
 
 /* Special, OCTET STRING with indefinite length constructed support */
 
-IMPLEMENT_ASN1_TYPE_ex(ASN1_OCTET_STRING_NDEF, ASN1_OCTET_STRING, ASN1_TFLG_NDEF)
-
 ASN1_ITEM_TEMPLATE(ASN1_SEQUENCE_ANY) =
         ASN1_EX_TEMPLATE_TYPE(ASN1_TFLG_SEQUENCE_OF, 0, ASN1_SEQUENCE_ANY, ASN1_ANY)
 ASN1_ITEM_TEMPLATE_END(ASN1_SEQUENCE_ANY)

data/third_party/boringssl-with-bazel/src/crypto/asn1/tasn_utl.c

@@ -66,6 +66,7 @@
 #include <openssl/thread.h>
 
 #include "../internal.h"
+#include "asn1_locl.h"
 
 
 /* Utility functions for manipulating fields and offsets */
@@ -91,8 +92,7 @@ int asn1_set_choice_selector(ASN1_VALUE **pval, int value,
 
 static CRYPTO_refcount_t *asn1_get_references(ASN1_VALUE **pval,
                                               const ASN1_ITEM *it) {
-  if (it->itype != ASN1_ITYPE_SEQUENCE &&
-      it->itype != ASN1_ITYPE_NDEF_SEQUENCE) {
+  if (it->itype != ASN1_ITYPE_SEQUENCE) {
     return NULL;
   }
   const ASN1_AUX *aux = it->funcs;

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

@@ -262,6 +262,8 @@ int BIO_should_io_special(const BIO *bio) {
 
 int BIO_get_retry_reason(const BIO *bio) { return bio->retry_reason; }
 
+void BIO_set_retry_reason(BIO *bio, int reason) { bio->retry_reason = reason; }
+
 void BIO_clear_flags(BIO *bio, int flags) {
   bio->flags &= ~flags;
 }

data/third_party/boringssl-with-bazel/src/crypto/bio/socket_helper.c

@@ -55,7 +55,11 @@ int bio_ip_and_port_to_socket_and_addr(int *out_sock,
   ret = getaddrinfo(hostname, port_str, &hint, &result);
   if (ret != 0) {
     OPENSSL_PUT_ERROR(SYS, 0);
+#if defined(OPENSSL_WINDOWS)
+    ERR_add_error_data(1, gai_strerrorA(ret));
+#else
     ERR_add_error_data(1, gai_strerror(ret));
+#endif
     return 0;
   }
 

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

@@ -0,0 +1,158 @@
+/* Copyright (c) 2021, 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/blake2.h>
+
+#include <openssl/type_check.h>
+
+#include "../internal.h"
+
+// https://tools.ietf.org/html/rfc7693#section-2.6
+static const uint64_t kIV[8] = {
+    UINT64_C(0x6a09e667f3bcc908), UINT64_C(0xbb67ae8584caa73b),
+    UINT64_C(0x3c6ef372fe94f82b), UINT64_C(0xa54ff53a5f1d36f1),
+    UINT64_C(0x510e527fade682d1), UINT64_C(0x9b05688c2b3e6c1f),
+    UINT64_C(0x1f83d9abfb41bd6b), UINT64_C(0x5be0cd19137e2179),
+};
+
+// https://tools.ietf.org/html/rfc7693#section-2.7
+static const uint8_t kSigma[10 * 16] = {
+    // clang-format off
+    0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15,
+    14, 10, 4, 8, 9, 15, 13, 6, 1, 12, 0, 2, 11, 7, 5, 3,
+    11, 8, 12, 0, 5, 2, 15, 13, 10, 14, 3, 6, 7, 1, 9, 4,
+    7, 9, 3, 1, 13, 12, 11, 14, 2, 6, 5, 10, 4, 0, 15, 8,
+    9, 0, 5, 7, 2, 4, 10, 15, 14, 1, 11, 12, 6, 8, 3, 13,
+    2, 12, 6, 10, 0, 11, 8, 3, 4, 13, 7, 5, 15, 14, 1, 9,
+    12, 5, 1, 15, 14, 13, 4, 10, 0, 7, 6, 3, 9, 2, 8, 11,
+    13, 11, 7, 14, 12, 1, 3, 9, 5, 0, 15, 4, 8, 6, 2, 10,
+    6, 15, 14, 9, 11, 3, 0, 8, 12, 2, 13, 7, 1, 4, 10, 5,
+    10, 2, 8, 4, 7, 6, 1, 5, 15, 11, 9, 14, 3, 12, 13, 0,
+    // clang-format on
+};
+
+#define RIGHT_ROTATE(v, n) (((v) >> (n)) | ((v) << (64 - (n))))
+
+// https://tools.ietf.org/html/rfc7693#section-3.1
+static void blake2b_mix(uint64_t v[16], int a, int b, int c, int d, uint64_t x,
+                        uint64_t y) {
+  v[a] = v[a] + v[b] + x;
+  v[d] = RIGHT_ROTATE(v[d] ^ v[a], 32);
+  v[c] = v[c] + v[d];
+  v[b] = RIGHT_ROTATE(v[b] ^ v[c], 24);
+  v[a] = v[a] + v[b] + y;
+  v[d] = RIGHT_ROTATE(v[d] ^ v[a], 16);
+  v[c] = v[c] + v[d];
+  v[b] = RIGHT_ROTATE(v[b] ^ v[c], 63);
+}
+
+static void blake2b_transform(
+    BLAKE2B_CTX *b2b,
+    const uint64_t block_words[BLAKE2B_CBLOCK / sizeof(uint64_t)],
+    size_t num_bytes, int is_final_block) {
+  // https://tools.ietf.org/html/rfc7693#section-3.2
+  uint64_t v[16];
+  OPENSSL_STATIC_ASSERT(sizeof(v) == sizeof(b2b->h) + sizeof(kIV), "");
+  OPENSSL_memcpy(v, b2b->h, sizeof(b2b->h));
+  OPENSSL_memcpy(&v[8], kIV, sizeof(kIV));
+
+  b2b->t_low += num_bytes;
+  if (b2b->t_low < num_bytes) {
+    b2b->t_high++;
+  }
+  v[12] ^= b2b->t_low;
+  v[13] ^= b2b->t_high;
+
+  if (is_final_block) {
+    v[14] = ~v[14];
+  }
+
+  for (int round = 0; round < 12; round++) {
+    const uint8_t *const s = &kSigma[16 * (round % 10)];
+    blake2b_mix(v, 0, 4, 8, 12, block_words[s[0]], block_words[s[1]]);
+    blake2b_mix(v, 1, 5, 9, 13, block_words[s[2]], block_words[s[3]]);
+    blake2b_mix(v, 2, 6, 10, 14, block_words[s[4]], block_words[s[5]]);
+    blake2b_mix(v, 3, 7, 11, 15, block_words[s[6]], block_words[s[7]]);
+    blake2b_mix(v, 0, 5, 10, 15, block_words[s[8]], block_words[s[9]]);
+    blake2b_mix(v, 1, 6, 11, 12, block_words[s[10]], block_words[s[11]]);
+    blake2b_mix(v, 2, 7, 8, 13, block_words[s[12]], block_words[s[13]]);
+    blake2b_mix(v, 3, 4, 9, 14, block_words[s[14]], block_words[s[15]]);
+  }
+
+  for (size_t i = 0; i < OPENSSL_ARRAY_SIZE(b2b->h); i++) {
+    b2b->h[i] ^= v[i];
+    b2b->h[i] ^= v[i + 8];
+  }
+}
+
+void BLAKE2B256_Init(BLAKE2B_CTX *b2b) {
+  OPENSSL_memset(b2b, 0, sizeof(BLAKE2B_CTX));
+
+  OPENSSL_STATIC_ASSERT(sizeof(kIV) == sizeof(b2b->h), "");
+  OPENSSL_memcpy(&b2b->h, kIV, sizeof(kIV));
+
+  // https://tools.ietf.org/html/rfc7693#section-2.5
+  b2b->h[0] ^= 0x01010000 | BLAKE2B256_DIGEST_LENGTH;
+}
+
+void BLAKE2B256_Update(BLAKE2B_CTX *b2b, const void *in_data, size_t len) {
+  const uint8_t *data = (const uint8_t *)in_data;
+
+  size_t todo = sizeof(b2b->block.bytes) - b2b->block_used;
+  if (todo > len) {
+    todo = len;
+  }
+  OPENSSL_memcpy(&b2b->block.bytes[b2b->block_used], data, todo);
+  b2b->block_used += todo;
+  data += todo;
+  len -= todo;
+
+  if (!len) {
+    return;
+  }
+
+  // More input remains therefore we must have filled |b2b->block|.
+  assert(b2b->block_used == BLAKE2B_CBLOCK);
+  blake2b_transform(b2b, b2b->block.words, BLAKE2B_CBLOCK,
+                    /*is_final_block=*/0);
+  b2b->block_used = 0;
+
+  while (len > BLAKE2B_CBLOCK) {
+    uint64_t block_words[BLAKE2B_CBLOCK / sizeof(uint64_t)];
+    OPENSSL_memcpy(block_words, data, sizeof(block_words));
+    blake2b_transform(b2b, block_words, BLAKE2B_CBLOCK, /*is_final_block=*/0);
+    data += BLAKE2B_CBLOCK;
+    len -= BLAKE2B_CBLOCK;
+  }
+
+  OPENSSL_memcpy(b2b->block.bytes, data, len);
+  b2b->block_used = len;
+}
+
+void BLAKE2B256_Final(uint8_t out[BLAKE2B256_DIGEST_LENGTH], BLAKE2B_CTX *b2b) {
+  OPENSSL_memset(&b2b->block.bytes[b2b->block_used], 0,
+                 sizeof(b2b->block.bytes) - b2b->block_used);
+  blake2b_transform(b2b, b2b->block.words, b2b->block_used,
+                    /*is_final_block=*/1);
+  OPENSSL_STATIC_ASSERT(BLAKE2B256_DIGEST_LENGTH <= sizeof(b2b->h), "");
+  memcpy(out, b2b->h, BLAKE2B256_DIGEST_LENGTH);
+}
+
+void BLAKE2B256(const uint8_t *data, size_t len,
+                uint8_t out[BLAKE2B256_DIGEST_LENGTH]) {
+  BLAKE2B_CTX ctx;
+  BLAKE2B256_Init(&ctx);
+  BLAKE2B256_Update(&ctx, data, len);
+  BLAKE2B256_Final(out, &ctx);
+}

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

@@ -20,25 +20,18 @@
 
 int BN_parse_asn1_unsigned(CBS *cbs, BIGNUM *ret) {
   CBS child;
+  int is_negative;
   if (!CBS_get_asn1(cbs, &child, CBS_ASN1_INTEGER) ||
-      CBS_len(&child) == 0) {
+      !CBS_is_valid_asn1_integer(&child, &is_negative)) {
     OPENSSL_PUT_ERROR(BN, BN_R_BAD_ENCODING);
     return 0;
   }
 
-  if (CBS_data(&child)[0] & 0x80) {
+  if (is_negative) {
     OPENSSL_PUT_ERROR(BN, BN_R_NEGATIVE_NUMBER);
     return 0;
   }
 
-  // INTEGERs must be minimal.
-  if (CBS_data(&child)[0] == 0x00 &&
-      CBS_len(&child) > 1 &&
-      !(CBS_data(&child)[1] & 0x80)) {
-    OPENSSL_PUT_ERROR(BN, BN_R_BAD_ENCODING);
-    return 0;
-  }
-
   return BN_bin2bn(CBS_data(&child), CBS_len(&child), ret) != NULL;
 }
 

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

@@ -53,7 +53,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, char *ber_found, unsigned depth) {
+static int cbs_find_ber(const CBS *orig_in, int *ber_found, unsigned depth) {
   CBS in;
 
   if (depth > kMaxDepth) {
@@ -68,14 +68,11 @@ static int cbs_find_ber(const CBS *orig_in, char *ber_found, unsigned depth) {
     unsigned tag;
     size_t header_len;
 
-    if (!CBS_get_any_ber_asn1_element(&in, &contents, &tag, &header_len)) {
+    if (!CBS_get_any_ber_asn1_element(&in, &contents, &tag, &header_len,
+                                      ber_found)) {
       return 0;
     }
-    if (CBS_len(&contents) == header_len &&
-        header_len > 0 &&
-        CBS_data(&contents)[header_len-1] == 0x80) {
-      // Found an indefinite-length element.
-      *ber_found = 1;
+    if (*ber_found) {
       return 1;
     }
     if (tag & CBS_ASN1_CONSTRUCTED) {
@@ -120,9 +117,11 @@ static int cbs_convert_ber(CBS *in, CBB *out, unsigned string_tag,
     CBS contents;
     unsigned tag, child_string_tag = string_tag;
     size_t header_len;
+    int ber_found;
     CBB *out_contents, out_contents_storage;
 
-    if (!CBS_get_any_ber_asn1_element(in, &contents, &tag, &header_len)) {
+    if (!CBS_get_any_ber_asn1_element(in, &contents, &tag, &header_len,
+                                      &ber_found)) {
       return 0;
     }
 
@@ -194,7 +193,7 @@ int CBS_asn1_ber_to_der(CBS *in, CBS *out, uint8_t **out_storage) {
 
   // First, do a quick walk to find any indefinite-length elements. Most of the
   // time we hope that there aren't any and thus we can quickly return.
-  char conversion_needed;
+  int conversion_needed;
   if (!cbs_find_ber(in, &conversion_needed, 0)) {
     return 0;
   }

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

@@ -254,8 +254,7 @@ static int parse_asn1_tag(CBS *cbs, unsigned *out) {
   //
   // If the number portion is 31 (0x1f, the largest value that fits in the
   // allotted bits), then the tag is more than one byte long and the
-  // continuation bytes contain the tag number. This parser only supports tag
-  // numbers less than 31 (and thus single-byte tags).
+  // continuation bytes contain the tag number.
   unsigned tag = ((unsigned)tag_byte & 0xe0) << CBS_ASN1_TAG_SHIFT;
   unsigned tag_number = tag_byte & 0x1f;
   if (tag_number == 0x1f) {
@@ -263,7 +262,7 @@ static int parse_asn1_tag(CBS *cbs, unsigned *out) {
     if (!parse_base128_integer(cbs, &v) ||
         // Check the tag number is within our supported bounds.
         v > CBS_ASN1_TAG_NUMBER_MASK ||
-        // Small tag numbers should have used low tag number form.
+        // Small tag numbers should have used low tag number form, even in BER.
         v < 0x1f) {
       return 0;
     }
@@ -277,13 +276,17 @@ static int parse_asn1_tag(CBS *cbs, unsigned *out) {
 }
 
 static int cbs_get_any_asn1_element(CBS *cbs, CBS *out, unsigned *out_tag,
-                                    size_t *out_header_len, int ber_ok) {
+                                    size_t *out_header_len, int *out_ber_found,
+                                    int ber_ok) {
   CBS header = *cbs;
   CBS throwaway;
 
   if (out == NULL) {
     out = &throwaway;
   }
+  if (ber_ok) {
+    *out_ber_found = 0;
+  }
 
   unsigned tag;
   if (!parse_asn1_tag(&header, &tag)) {
@@ -321,27 +324,38 @@ static int cbs_get_any_asn1_element(CBS *cbs, CBS *out, unsigned *out_tag,
       if (out_header_len != NULL) {
         *out_header_len = header_len;
       }
+      *out_ber_found = 1;
       return CBS_get_bytes(cbs, out, header_len);
     }
 
     // ITU-T X.690 clause 8.1.3.5.c specifies that the value 0xff shall not be
     // used as the first byte of the length. If this parser encounters that
-    // value, num_bytes will be parsed as 127, which will fail the check below.
+    // value, num_bytes will be parsed as 127, which will fail this check.
     if (num_bytes == 0 || num_bytes > 4) {
       return 0;
     }
     if (!cbs_get_u(&header, &len64, num_bytes)) {
       return 0;
     }
-    // ITU-T X.690 section 10.1 (DER length forms) requires encoding the length
-    // with the minimum number of octets.
+    // ITU-T X.690 section 10.1 (DER length forms) requires encoding the
+    // length with the minimum number of octets. BER could, technically, have
+    // 125 superfluous zero bytes. We do not attempt to handle that and still
+    // require that the length fit in a |uint32_t| for BER.
     if (len64 < 128) {
       // Length should have used short-form encoding.
-      return 0;
+      if (ber_ok) {
+        *out_ber_found = 1;
+      } else {
+        return 0;
+      }
     }
-    if ((len64 >> ((num_bytes-1)*8)) == 0) {
+    if ((len64 >> ((num_bytes - 1) * 8)) == 0) {
       // Length should have been at least one byte shorter.
-      return 0;
+      if (ber_ok) {
+        *out_ber_found = 1;
+      } else {
+        return 0;
+      }
     }
     len = len64;
     if (len + header_len + num_bytes < len) {
@@ -374,13 +388,15 @@ int CBS_get_any_asn1(CBS *cbs, CBS *out, unsigned *out_tag) {
 int CBS_get_any_asn1_element(CBS *cbs, CBS *out, unsigned *out_tag,
                                     size_t *out_header_len) {
   return cbs_get_any_asn1_element(cbs, out, out_tag, out_header_len,
-                                  0 /* DER only */);
+                                  NULL, 0 /* DER only */);
 }
 
 int CBS_get_any_ber_asn1_element(CBS *cbs, CBS *out, unsigned *out_tag,
-                                 size_t *out_header_len) {
-  return cbs_get_any_asn1_element(cbs, out, out_tag, out_header_len,
-                                  1 /* BER allowed */);
+                                 size_t *out_header_len, int *out_ber_found) {
+  int ber_found_temp;
+  return cbs_get_any_asn1_element(
+      cbs, out, out_tag, out_header_len,
+      out_ber_found ? out_ber_found : &ber_found_temp, 1 /* BER allowed */);
 }
 
 static int cbs_get_asn1(CBS *cbs, CBS *out, unsigned tag_value,
@@ -426,29 +442,14 @@ int CBS_peek_asn1_tag(const CBS *cbs, unsigned tag_value) {
 
 int CBS_get_asn1_uint64(CBS *cbs, uint64_t *out) {
   CBS bytes;
-  if (!CBS_get_asn1(cbs, &bytes, CBS_ASN1_INTEGER)) {
+  if (!CBS_get_asn1(cbs, &bytes, CBS_ASN1_INTEGER) ||
+      !CBS_is_unsigned_asn1_integer(&bytes)) {
     return 0;
   }
 
   *out = 0;
   const uint8_t *data = CBS_data(&bytes);
   size_t len = CBS_len(&bytes);
-
-  if (len == 0) {
-    // An INTEGER is encoded with at least one octet.
-    return 0;
-  }
-
-  if ((data[0] & 0x80) != 0) {
-    // Negative number.
-    return 0;
-  }
-
-  if (data[0] == 0 && len > 1 && (data[1] & 0x80) == 0) {
-    // Extra leading zeros.
-    return 0;
-  }
-
   for (size_t i = 0; i < len; i++) {
     if ((*out >> 56) != 0) {
       // Too large to represent as a uint64_t.
@@ -462,31 +463,21 @@ int CBS_get_asn1_uint64(CBS *cbs, uint64_t *out) {
 }
 
 int CBS_get_asn1_int64(CBS *cbs, int64_t *out) {
+  int is_negative;
   CBS bytes;
-  if (!CBS_get_asn1(cbs, &bytes, CBS_ASN1_INTEGER)) {
+  if (!CBS_get_asn1(cbs, &bytes, CBS_ASN1_INTEGER) ||
+      !CBS_is_valid_asn1_integer(&bytes, &is_negative)) {
     return 0;
   }
   const uint8_t *data = CBS_data(&bytes);
   const size_t len = CBS_len(&bytes);
-
-  if (len == 0 || len > sizeof(int64_t)) {
-    // An INTEGER is encoded with at least one octet.
+  if (len > sizeof(int64_t)) {
     return 0;
   }
-  if (len > 1) {
-    if (data[0] == 0 && (data[1] & 0x80) == 0) {
-      return 0;  // Extra leading zeros.
-    }
-    if (data[0] == 0xff && (data[1] & 0x80) != 0) {
-      return 0;  // Extra leading 0xff.
-    }
-  }
-
   union {
     int64_t i;
     uint8_t bytes[sizeof(int64_t)];
   } u;
-  const int is_negative = (data[0] & 0x80);
   memset(u.bytes, is_negative ? 0xff : 0, sizeof(u.bytes));  // Sign-extend.
   for (size_t i = 0; i < len; i++) {
     u.bytes[i] = data[len - i - 1];
@@ -635,6 +626,30 @@ int CBS_asn1_bitstring_has_bit(const CBS *cbs, unsigned bit) {
          (CBS_data(cbs)[byte_num] & (1 << bit_num)) != 0;
 }
 
+int CBS_is_valid_asn1_integer(const CBS *cbs, int *out_is_negative) {
+  CBS copy = *cbs;
+  uint8_t first_byte, second_byte;
+  if (!CBS_get_u8(&copy, &first_byte)) {
+    return 0;  // INTEGERs may not be empty.
+  }
+  if (out_is_negative != NULL) {
+    *out_is_negative = (first_byte & 0x80) != 0;
+  }
+  if (!CBS_get_u8(&copy, &second_byte)) {
+    return 1;  // One byte INTEGERs are always minimal.
+  }
+  if ((first_byte == 0x00 && (second_byte & 0x80) == 0) ||
+      (first_byte == 0xff && (second_byte & 0x80) != 0)) {
+    return 0;  // The value is minimal iff the first 9 bits are not all equal.
+  }
+  return 1;
+}
+
+int CBS_is_unsigned_asn1_integer(const CBS *cbs) {
+  int is_negative;
+  return CBS_is_valid_asn1_integer(cbs, &is_negative) && !is_negative;
+}
+
 static int add_decimal(CBB *out, uint64_t v) {
   char buf[DECIMAL_SIZE(uint64_t) + 1];
   BIO_snprintf(buf, sizeof(buf), "%" PRIu64, v);