grpc 1.53.0 → 1.54.2

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

@@ -66,219 +66,219 @@
 #include "internal.h"
 
 
-int ASN1_BIT_STRING_set(ASN1_BIT_STRING *x, const unsigned char *d, int len)
-{
-    return ASN1_STRING_set(x, d, len);
+int ASN1_BIT_STRING_set(ASN1_BIT_STRING *x, const unsigned char *d,
+                        ossl_ssize_t len) {
+  return ASN1_STRING_set(x, d, len);
 }
 
 int asn1_bit_string_length(const ASN1_BIT_STRING *str,
                            uint8_t *out_padding_bits) {
-    int len = str->length;
-    if (str->flags & ASN1_STRING_FLAG_BITS_LEFT) {
-        // If the string is already empty, it cannot have padding bits.
-        *out_padding_bits = len == 0 ? 0 : str->flags & 0x07;
-        return len;
-    }
+  int len = str->length;
+  if (str->flags & ASN1_STRING_FLAG_BITS_LEFT) {
+    // If the string is already empty, it cannot have padding bits.
+    *out_padding_bits = len == 0 ? 0 : str->flags & 0x07;
+    return len;
+  }
 
-    // TODO(https://crbug.com/boringssl/447): If we move this logic to
-    // |ASN1_BIT_STRING_set_bit|, can we remove this representation?
-    while (len > 0 && str->data[len - 1] == 0) {
-        len--;
-    }
-    uint8_t padding_bits = 0;
-    if (len > 0) {
-        uint8_t last = str->data[len - 1];
-        assert(last != 0);
-        for (; padding_bits < 7; padding_bits++) {
-            if (last & (1 << padding_bits)) {
-                break;
-            }
-        }
+  // TODO(https://crbug.com/boringssl/447): If we move this logic to
+  // |ASN1_BIT_STRING_set_bit|, can we remove this representation?
+  while (len > 0 && str->data[len - 1] == 0) {
+    len--;
+  }
+  uint8_t padding_bits = 0;
+  if (len > 0) {
+    uint8_t last = str->data[len - 1];
+    assert(last != 0);
+    for (; padding_bits < 7; padding_bits++) {
+      if (last & (1 << padding_bits)) {
+        break;
+      }
     }
-    *out_padding_bits = padding_bits;
-    return len;
+  }
+  *out_padding_bits = padding_bits;
+  return len;
 }
 
 int ASN1_BIT_STRING_num_bytes(const ASN1_BIT_STRING *str, size_t *out) {
-    uint8_t padding_bits;
-    int len = asn1_bit_string_length(str, &padding_bits);
-    if (padding_bits != 0) {
-        return 0;
-    }
-    *out = len;
-    return 1;
+  uint8_t padding_bits;
+  int len = asn1_bit_string_length(str, &padding_bits);
+  if (padding_bits != 0) {
+    return 0;
+  }
+  *out = len;
+  return 1;
 }
 
-int i2c_ASN1_BIT_STRING(const ASN1_BIT_STRING *a, unsigned char **pp)
-{
-    if (a == NULL) {
-        return 0;
-    }
+int i2c_ASN1_BIT_STRING(const ASN1_BIT_STRING *a, unsigned char **pp) {
+  if (a == NULL) {
+    return 0;
+  }
 
-    uint8_t bits;
-    int len = asn1_bit_string_length(a, &bits);
-    int ret = 1 + len;
-    if (pp == NULL) {
-        return ret;
-    }
+  uint8_t bits;
+  int len = asn1_bit_string_length(a, &bits);
+  if (len > INT_MAX - 1) {
+    OPENSSL_PUT_ERROR(ASN1, ERR_R_OVERFLOW);
+    return 0;
+  }
+  int ret = 1 + len;
+  if (pp == NULL) {
+    return ret;
+  }
 
-    uint8_t *p = *pp;
-    *(p++) = bits;
-    OPENSSL_memcpy(p, a->data, len);
-    if (len > 0) {
-        p[len - 1] &= (0xff << bits);
-    }
-    p += len;
-    *pp = p;
-    return (ret);
+  uint8_t *p = *pp;
+  *(p++) = bits;
+  OPENSSL_memcpy(p, a->data, len);
+  if (len > 0) {
+    p[len - 1] &= (0xff << bits);
+  }
+  p += len;
+  *pp = p;
+  return ret;
 }
 
 ASN1_BIT_STRING *c2i_ASN1_BIT_STRING(ASN1_BIT_STRING **a,
-                                     const unsigned char **pp, long len)
-{
-    ASN1_BIT_STRING *ret = NULL;
-    const unsigned char *p;
-    unsigned char *s;
-    int padding;
+                                     const unsigned char **pp, long len) {
+  ASN1_BIT_STRING *ret = NULL;
+  const unsigned char *p;
+  unsigned char *s;
+  int padding;
 
-    if (len < 1) {
-        OPENSSL_PUT_ERROR(ASN1, ASN1_R_STRING_TOO_SHORT);
-        goto err;
-    }
+  if (len < 1) {
+    OPENSSL_PUT_ERROR(ASN1, ASN1_R_STRING_TOO_SHORT);
+    goto err;
+  }
 
-    if (len > INT_MAX) {
-      OPENSSL_PUT_ERROR(ASN1, ASN1_R_STRING_TOO_LONG);
-      goto err;
-    }
+  if (len > INT_MAX) {
+    OPENSSL_PUT_ERROR(ASN1, ASN1_R_STRING_TOO_LONG);
+    goto err;
+  }
 
-    if ((a == NULL) || ((*a) == NULL)) {
-        if ((ret = ASN1_BIT_STRING_new()) == NULL)
-            return (NULL);
-    } else
-        ret = (*a);
-
-    p = *pp;
-    padding = *(p++);
-    len--;
-    if (padding > 7) {
-        OPENSSL_PUT_ERROR(ASN1, ASN1_R_INVALID_BIT_STRING_BITS_LEFT);
-        goto err;
+  if ((a == NULL) || ((*a) == NULL)) {
+    if ((ret = ASN1_BIT_STRING_new()) == NULL) {
+      return NULL;
     }
+  } else {
+    ret = (*a);
+  }
 
-    /* Unused bits in a BIT STRING must be zero. */
-    uint8_t padding_mask = (1 << padding) - 1;
-    if (padding != 0 &&
-        (len < 1 || (p[len - 1] & padding_mask) != 0)) {
-        OPENSSL_PUT_ERROR(ASN1, ASN1_R_INVALID_BIT_STRING_PADDING);
-        goto err;
-    }
+  p = *pp;
+  padding = *(p++);
+  len--;
+  if (padding > 7) {
+    OPENSSL_PUT_ERROR(ASN1, ASN1_R_INVALID_BIT_STRING_BITS_LEFT);
+    goto err;
+  }
 
-    /*
-     * We do this to preserve the settings.  If we modify the settings, via
-     * the _set_bit function, we will recalculate on output
-     */
-    ret->flags &= ~(ASN1_STRING_FLAG_BITS_LEFT | 0x07); /* clear */
-    ret->flags |= (ASN1_STRING_FLAG_BITS_LEFT | padding); /* set */
+  // Unused bits in a BIT STRING must be zero.
+  uint8_t padding_mask = (1 << padding) - 1;
+  if (padding != 0 && (len < 1 || (p[len - 1] & padding_mask) != 0)) {
+    OPENSSL_PUT_ERROR(ASN1, ASN1_R_INVALID_BIT_STRING_PADDING);
+    goto err;
+  }
 
-    if (len > 0) {
-        s = OPENSSL_memdup(p, len);
-        if (s == NULL) {
-            OPENSSL_PUT_ERROR(ASN1, ERR_R_MALLOC_FAILURE);
-            goto err;
-        }
-        p += len;
-    } else {
-        s = NULL;
+  // We do this to preserve the settings.  If we modify the settings, via
+  // the _set_bit function, we will recalculate on output
+  ret->flags &= ~(ASN1_STRING_FLAG_BITS_LEFT | 0x07);    // clear
+  ret->flags |= (ASN1_STRING_FLAG_BITS_LEFT | padding);  // set
+
+  if (len > 0) {
+    s = OPENSSL_memdup(p, len);
+    if (s == NULL) {
+      goto err;
     }
+    p += len;
+  } else {
+    s = NULL;
+  }
 
-    ret->length = (int)len;
-    OPENSSL_free(ret->data);
-    ret->data = s;
-    ret->type = V_ASN1_BIT_STRING;
-    if (a != NULL)
-        (*a) = ret;
-    *pp = p;
-    return (ret);
- err:
-    if ((ret != NULL) && ((a == NULL) || (*a != ret)))
-        ASN1_BIT_STRING_free(ret);
-    return (NULL);
+  ret->length = (int)len;
+  OPENSSL_free(ret->data);
+  ret->data = s;
+  ret->type = V_ASN1_BIT_STRING;
+  if (a != NULL) {
+    (*a) = ret;
+  }
+  *pp = p;
+  return ret;
+err:
+  if ((ret != NULL) && ((a == NULL) || (*a != ret))) {
+    ASN1_BIT_STRING_free(ret);
+  }
+  return NULL;
 }
 
-/*
- * These next 2 functions from Goetz Babin-Ebell <babinebell@trustcenter.de>
- */
-int ASN1_BIT_STRING_set_bit(ASN1_BIT_STRING *a, int n, int value)
-{
-    int w, v, iv;
-    unsigned char *c;
+// These next 2 functions from Goetz Babin-Ebell <babinebell@trustcenter.de>
+int ASN1_BIT_STRING_set_bit(ASN1_BIT_STRING *a, int n, int value) {
+  int w, v, iv;
+  unsigned char *c;
 
-    w = n / 8;
-    v = 1 << (7 - (n & 0x07));
-    iv = ~v;
-    if (!value)
-        v = 0;
+  w = n / 8;
+  v = 1 << (7 - (n & 0x07));
+  iv = ~v;
+  if (!value) {
+    v = 0;
+  }
 
-    if (a == NULL)
-        return 0;
+  if (a == NULL) {
+    return 0;
+  }
 
-    a->flags &= ~(ASN1_STRING_FLAG_BITS_LEFT | 0x07); /* clear, set on write */
+  a->flags &= ~(ASN1_STRING_FLAG_BITS_LEFT | 0x07);  // clear, set on write
 
-    if ((a->length < (w + 1)) || (a->data == NULL)) {
-        if (!value)
-            return (1);         /* Don't need to set */
-        if (a->data == NULL)
-            c = (unsigned char *)OPENSSL_malloc(w + 1);
-        else
-            c = (unsigned char *)OPENSSL_realloc(a->data, w + 1);
-        if (c == NULL) {
-            OPENSSL_PUT_ERROR(ASN1, ERR_R_MALLOC_FAILURE);
-            return 0;
-        }
-        if (w + 1 - a->length > 0)
-            OPENSSL_memset(c + a->length, 0, w + 1 - a->length);
-        a->data = c;
-        a->length = w + 1;
+  if ((a->length < (w + 1)) || (a->data == NULL)) {
+    if (!value) {
+      return 1;  // Don't need to set
     }
-    a->data[w] = ((a->data[w]) & iv) | v;
-    while ((a->length > 0) && (a->data[a->length - 1] == 0))
-        a->length--;
-    return (1);
+    if (a->data == NULL) {
+      c = (unsigned char *)OPENSSL_malloc(w + 1);
+    } else {
+      c = (unsigned char *)OPENSSL_realloc(a->data, w + 1);
+    }
+    if (c == NULL) {
+      return 0;
+    }
+    if (w + 1 - a->length > 0) {
+      OPENSSL_memset(c + a->length, 0, w + 1 - a->length);
+    }
+    a->data = c;
+    a->length = w + 1;
+  }
+  a->data[w] = ((a->data[w]) & iv) | v;
+  while ((a->length > 0) && (a->data[a->length - 1] == 0)) {
+    a->length--;
+  }
+  return 1;
 }
 
-int ASN1_BIT_STRING_get_bit(const ASN1_BIT_STRING *a, int n)
-{
-    int w, v;
+int ASN1_BIT_STRING_get_bit(const ASN1_BIT_STRING *a, int n) {
+  int w, v;
 
-    w = n / 8;
-    v = 1 << (7 - (n & 0x07));
-    if ((a == NULL) || (a->length < (w + 1)) || (a->data == NULL))
-        return (0);
-    return ((a->data[w] & v) != 0);
+  w = n / 8;
+  v = 1 << (7 - (n & 0x07));
+  if ((a == NULL) || (a->length < (w + 1)) || (a->data == NULL)) {
+    return 0;
+  }
+  return ((a->data[w] & v) != 0);
 }
 
-/*
- * Checks if the given bit string contains only bits specified by
- * the flags vector. Returns 0 if there is at least one bit set in 'a'
- * which is not specified in 'flags', 1 otherwise.
- * 'len' is the length of 'flags'.
- */
-int ASN1_BIT_STRING_check(const ASN1_BIT_STRING *a,
-                          const unsigned char *flags, int flags_len)
-{
-    int i, ok;
-    /* Check if there is one bit set at all. */
-    if (!a || !a->data)
-        return 1;
+// Checks if the given bit string contains only bits specified by
+// the flags vector. Returns 0 if there is at least one bit set in 'a'
+// which is not specified in 'flags', 1 otherwise.
+// 'len' is the length of 'flags'.
+int ASN1_BIT_STRING_check(const ASN1_BIT_STRING *a, const unsigned char *flags,
+                          int flags_len) {
+  int i, ok;
+  // Check if there is one bit set at all.
+  if (!a || !a->data) {
+    return 1;
+  }
 
-    /*
-     * Check each byte of the internal representation of the bit string.
-     */
-    ok = 1;
-    for (i = 0; i < a->length && ok; ++i) {
-        unsigned char mask = i < flags_len ? ~flags[i] : 0xff;
-        /* We are done if there is an unneeded bit set. */
-        ok = (a->data[i] & mask) == 0;
-    }
-    return ok;
+  // Check each byte of the internal representation of the bit string.
+  ok = 1;
+  for (i = 0; i < a->length && ok; ++i) {
+    unsigned char mask = i < flags_len ? ~flags[i] : 0xff;
+    // We are done if there is an unneeded bit set.
+    ok = (a->data[i] & mask) == 0;
+  }
+  return ok;
 }

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

@@ -56,67 +56,40 @@
 
 #include <openssl/asn1.h>
 
+#include <openssl/bytestring.h>
 #include <openssl/err.h>
-#include <openssl/mem.h>
 
-int i2d_ASN1_BOOLEAN(ASN1_BOOLEAN a, unsigned char **pp)
-{
-    int r;
-    unsigned char *p, *allocated = NULL;
+#include "../bytestring/internal.h"
 
-    r = ASN1_object_size(0, 1, V_ASN1_BOOLEAN);
-    if (pp == NULL)
-        return (r);
 
-    if (*pp == NULL) {
-        if ((p = allocated = OPENSSL_malloc(r)) == NULL) {
-            OPENSSL_PUT_ERROR(ASN1, ERR_R_MALLOC_FAILURE);
-            return -1;
-        }
-    } else {
-        p = *pp;
-    }
-
-    ASN1_put_object(&p, 0, 1, V_ASN1_BOOLEAN, V_ASN1_UNIVERSAL);
-    *p = a ? 0xff : 0x00;
-
-    /*
-     * If a new buffer was allocated, just return it back.
-     * If not, return the incremented buffer pointer.
-     */
-    *pp = allocated != NULL ? allocated : p + 1;
-    return r;
+int i2d_ASN1_BOOLEAN(ASN1_BOOLEAN a, unsigned char **outp) {
+  CBB cbb;
+  if (!CBB_init(&cbb, 3) ||  //
+      !CBB_add_asn1_bool(&cbb, a != ASN1_BOOLEAN_FALSE)) {
+    CBB_cleanup(&cbb);
+    return -1;
+  }
+  return CBB_finish_i2d(&cbb, outp);
 }
 
-ASN1_BOOLEAN d2i_ASN1_BOOLEAN(ASN1_BOOLEAN *a, const unsigned char **pp,
-                              long length) {
-    const unsigned char *p = *pp;
-    long len;
-    int inf, tag, xclass;
-    inf = ASN1_get_object(&p, &len, &tag, &xclass, length);
-    if (inf & 0x80) {
-        OPENSSL_PUT_ERROR(ASN1, ASN1_R_BAD_OBJECT_HEADER);
-        return -1;
-    }
-
-    if (inf & V_ASN1_CONSTRUCTED) {
-        OPENSSL_PUT_ERROR(ASN1, ASN1_R_TYPE_NOT_PRIMITIVE);
-        return -1;
-    }
+ASN1_BOOLEAN d2i_ASN1_BOOLEAN(ASN1_BOOLEAN *out, const unsigned char **inp,
+                              long len) {
+  if (len < 0) {
+    return ASN1_BOOLEAN_NONE;
+  }
 
-    if (tag != V_ASN1_BOOLEAN || xclass != V_ASN1_UNIVERSAL) {
-      OPENSSL_PUT_ERROR(ASN1, ASN1_R_EXPECTING_A_BOOLEAN);
-      return -1;
-    }
+  CBS cbs;
+  CBS_init(&cbs, *inp, (size_t)len);
+  int val;
+  if (!CBS_get_asn1_bool(&cbs, &val)) {
+    OPENSSL_PUT_ERROR(ASN1, ASN1_R_DECODE_ERROR);
+    return ASN1_BOOLEAN_NONE;
+  }
 
-    if (len != 1) {
-        OPENSSL_PUT_ERROR(ASN1, ASN1_R_BOOLEAN_IS_WRONG_LENGTH);
-        return -1;
-    }
-    ASN1_BOOLEAN ret = (ASN1_BOOLEAN)*(p++);
-    if (a != NULL) {
-        (*a) = ret;
-    }
-    *pp = p;
-    return ret;
+  ASN1_BOOLEAN ret = val ? ASN1_BOOLEAN_TRUE : ASN1_BOOLEAN_FALSE;
+  if (out != NULL) {
+    *out = ret;
+  }
+  *inp = CBS_data(&cbs);
+  return ret;
 }

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

@@ -63,29 +63,27 @@
 #include <openssl/mem.h>
 
 
-void *ASN1_item_d2i_bio(const ASN1_ITEM *it, BIO *in, void *x)
-{
-    uint8_t *data;
-    size_t len;
-    // Historically, this function did not impose a limit in OpenSSL and is used
-    // to read CRLs, so we leave this without an external bound.
-    if (!BIO_read_asn1(in, &data, &len, INT_MAX)) {
-        return NULL;
-    }
-    const uint8_t *ptr = data;
-    void *ret = ASN1_item_d2i(x, &ptr, len, it);
-    OPENSSL_free(data);
-    return ret;
+void *ASN1_item_d2i_bio(const ASN1_ITEM *it, BIO *in, void *x) {
+  uint8_t *data;
+  size_t len;
+  // Historically, this function did not impose a limit in OpenSSL and is used
+  // to read CRLs, so we leave this without an external bound.
+  if (!BIO_read_asn1(in, &data, &len, INT_MAX)) {
+    return NULL;
+  }
+  const uint8_t *ptr = data;
+  void *ret = ASN1_item_d2i(x, &ptr, len, it);
+  OPENSSL_free(data);
+  return ret;
 }
 
-void *ASN1_item_d2i_fp(const ASN1_ITEM *it, FILE *in, void *x)
-{
-    BIO *b = BIO_new_fp(in, BIO_NOCLOSE);
-    if (b == NULL) {
-        OPENSSL_PUT_ERROR(ASN1, ERR_R_BUF_LIB);
-        return NULL;
-    }
-    void *ret = ASN1_item_d2i_bio(it, b, x);
-    BIO_free(b);
-    return ret;
+void *ASN1_item_d2i_fp(const ASN1_ITEM *it, FILE *in, void *x) {
+  BIO *b = BIO_new_fp(in, BIO_NOCLOSE);
+  if (b == NULL) {
+    OPENSSL_PUT_ERROR(ASN1, ERR_R_BUF_LIB);
+    return NULL;
+  }
+  void *ret = ASN1_item_d2i_bio(it, b, x);
+  BIO_free(b);
+  return ret;
 }

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

@@ -59,29 +59,26 @@
 #include <openssl/err.h>
 #include <openssl/mem.h>
 
-/*
- * ASN1_ITEM version of dup: this follows the model above except we don't
- * need to allocate the buffer. At some point this could be rewritten to
- * directly dup the underlying structure instead of doing and encode and
- * decode.
- */
-void *ASN1_item_dup(const ASN1_ITEM *it, void *x)
-{
-    unsigned char *b = NULL;
-    const unsigned char *p;
-    long i;
-    void *ret;
+// ASN1_ITEM version of dup: this follows the model above except we don't
+// need to allocate the buffer. At some point this could be rewritten to
+// directly dup the underlying structure instead of doing and encode and
+// decode.
+void *ASN1_item_dup(const ASN1_ITEM *it, void *x) {
+  unsigned char *b = NULL;
+  const unsigned char *p;
+  long i;
+  void *ret;
 
-    if (x == NULL)
-        return (NULL);
+  if (x == NULL) {
+    return NULL;
+  }
 
-    i = ASN1_item_i2d(x, &b, it);
-    if (b == NULL) {
-        OPENSSL_PUT_ERROR(ASN1, ERR_R_MALLOC_FAILURE);
-        return (NULL);
-    }
-    p = b;
-    ret = ASN1_item_d2i(NULL, &p, i, it);
-    OPENSSL_free(b);
-    return (ret);
+  i = ASN1_item_i2d(x, &b, it);
+  if (b == NULL) {
+    return NULL;
+  }
+  p = b;
+  ret = ASN1_item_d2i(NULL, &p, i, it);
+  OPENSSL_free(b);
+  return ret;
 }