@fails-components/webtransport 0.0.1 → 0.0.2

package/third_party/boringssl/src/crypto/asn1/asn1_lib.c

@@ -67,19 +67,17 @@
 #include "internal.h"
 
 
-/* Cross-module errors from crypto/x509/i2d_pr.c. */
+// Cross-module errors from crypto/x509/i2d_pr.c.
 OPENSSL_DECLARE_ERROR_REASON(ASN1, UNSUPPORTED_PUBLIC_KEY_TYPE)
 
-/* Cross-module errors from crypto/x509/algorithm.c. */
+// Cross-module errors from crypto/x509/algorithm.c.
 OPENSSL_DECLARE_ERROR_REASON(ASN1, CONTEXT_NOT_INITIALISED)
 OPENSSL_DECLARE_ERROR_REASON(ASN1, DIGEST_AND_KEY_TYPE_NOT_SUPPORTED)
 OPENSSL_DECLARE_ERROR_REASON(ASN1, UNKNOWN_MESSAGE_DIGEST_ALGORITHM)
 OPENSSL_DECLARE_ERROR_REASON(ASN1, UNKNOWN_SIGNATURE_ALGORITHM)
 OPENSSL_DECLARE_ERROR_REASON(ASN1, WRONG_PUBLIC_KEY_TYPE)
-/*
- * Cross-module errors from crypto/x509/asn1_gen.c. TODO(davidben): Remove
- * these once asn1_gen.c is gone.
- */
+// Cross-module errors from crypto/x509/asn1_gen.c. TODO(davidben): Remove
+// these once asn1_gen.c is gone.
 OPENSSL_DECLARE_ERROR_REASON(ASN1, DEPTH_EXCEEDED)
 OPENSSL_DECLARE_ERROR_REASON(ASN1, ILLEGAL_BITSTRING_FORMAT)
 OPENSSL_DECLARE_ERROR_REASON(ASN1, ILLEGAL_BOOLEAN)
@@ -107,299 +105,286 @@ OPENSSL_DECLARE_ERROR_REASON(ASN1, UNSUPPORTED_TYPE)
 static void asn1_put_length(unsigned char **pp, int length);
 
 int ASN1_get_object(const unsigned char **inp, long *out_len, int *out_tag,
-                    int *out_class, long in_len)
-{
-    if (in_len < 0) {
-        OPENSSL_PUT_ERROR(ASN1, ASN1_R_HEADER_TOO_LONG);
-        return 0x80;
-    }
-
-    /* TODO(https://crbug.com/boringssl/354): This should use |CBS_get_asn1| to
-     * reject non-minimal lengths, which are only allowed in BER. However,
-     * Android sometimes needs allow a non-minimal length in certificate
-     * signature fields (see b/18228011). Make this only apply to that field,
-     * while requiring DER elsewhere. Better yet, it should be limited to an
-     * preprocessing step in that part of Android. */
-    unsigned tag;
-    size_t header_len;
-    int indefinite;
-    CBS cbs, body;
-    CBS_init(&cbs, *inp, (size_t)in_len);
-    if (!CBS_get_any_ber_asn1_element(&cbs, &body, &tag, &header_len,
-        /*out_ber_found=*/NULL, &indefinite) ||
-        indefinite ||
-        !CBS_skip(&body, header_len) ||
-        /* Bound the length to comfortably fit in an int. Lengths in this
-         * module often switch between int and long without overflow checks. */
-        CBS_len(&body) > INT_MAX / 2) {
-        OPENSSL_PUT_ERROR(ASN1, ASN1_R_HEADER_TOO_LONG);
-        return 0x80;
-    }
-
-    /* Convert between tag representations. */
-    int tag_class = (tag & CBS_ASN1_CLASS_MASK) >> CBS_ASN1_TAG_SHIFT;
-    int constructed = (tag & CBS_ASN1_CONSTRUCTED) >> CBS_ASN1_TAG_SHIFT;
-    int tag_number = tag & CBS_ASN1_TAG_NUMBER_MASK;
-
-    /* To avoid ambiguity with V_ASN1_NEG, impose a limit on universal tags. */
-    if (tag_class == V_ASN1_UNIVERSAL && tag_number > V_ASN1_MAX_UNIVERSAL) {
-        OPENSSL_PUT_ERROR(ASN1, ASN1_R_HEADER_TOO_LONG);
-        return 0x80;
-    }
-
-    *inp = CBS_data(&body);
-    *out_len = CBS_len(&body);
-    *out_tag = tag_number;
-    *out_class = tag_class;
-    return constructed;
+                    int *out_class, long in_len) {
+  if (in_len < 0) {
+    OPENSSL_PUT_ERROR(ASN1, ASN1_R_HEADER_TOO_LONG);
+    return 0x80;
+  }
+
+  // TODO(https://crbug.com/boringssl/354): This should use |CBS_get_asn1| to
+  // reject non-minimal lengths, which are only allowed in BER. However,
+  // Android sometimes needs allow a non-minimal length in certificate
+  // signature fields (see b/18228011). Make this only apply to that field,
+  // while requiring DER elsewhere. Better yet, it should be limited to an
+  // preprocessing step in that part of Android.
+  unsigned tag;
+  size_t header_len;
+  int indefinite;
+  CBS cbs, body;
+  CBS_init(&cbs, *inp, (size_t)in_len);
+  if (!CBS_get_any_ber_asn1_element(&cbs, &body, &tag, &header_len,
+                                    /*out_ber_found=*/NULL, &indefinite) ||
+      indefinite || !CBS_skip(&body, header_len) ||
+      // Bound the length to comfortably fit in an int. Lengths in this
+      // module often switch between int and long without overflow checks.
+      CBS_len(&body) > INT_MAX / 2) {
+    OPENSSL_PUT_ERROR(ASN1, ASN1_R_HEADER_TOO_LONG);
+    return 0x80;
+  }
+
+  // Convert between tag representations.
+  int tag_class = (tag & CBS_ASN1_CLASS_MASK) >> CBS_ASN1_TAG_SHIFT;
+  int constructed = (tag & CBS_ASN1_CONSTRUCTED) >> CBS_ASN1_TAG_SHIFT;
+  int tag_number = tag & CBS_ASN1_TAG_NUMBER_MASK;
+
+  // To avoid ambiguity with V_ASN1_NEG, impose a limit on universal tags.
+  if (tag_class == V_ASN1_UNIVERSAL && tag_number > V_ASN1_MAX_UNIVERSAL) {
+    OPENSSL_PUT_ERROR(ASN1, ASN1_R_HEADER_TOO_LONG);
+    return 0x80;
+  }
+
+  *inp = CBS_data(&body);
+  *out_len = CBS_len(&body);
+  *out_tag = tag_number;
+  *out_class = tag_class;
+  return constructed;
 }
 
-/*
- * class 0 is constructed constructed == 2 for indefinite length constructed
- */
+// class 0 is constructed constructed == 2 for indefinite length constructed
 void ASN1_put_object(unsigned char **pp, int constructed, int length, int tag,
-                     int xclass)
-{
-    unsigned char *p = *pp;
-    int i, ttag;
-
-    i = (constructed) ? V_ASN1_CONSTRUCTED : 0;
-    i |= (xclass & V_ASN1_PRIVATE);
-    if (tag < 31)
-        *(p++) = i | (tag & V_ASN1_PRIMITIVE_TAG);
-    else {
-        *(p++) = i | V_ASN1_PRIMITIVE_TAG;
-        for (i = 0, ttag = tag; ttag > 0; i++)
-            ttag >>= 7;
-        ttag = i;
-        while (i-- > 0) {
-            p[i] = tag & 0x7f;
-            if (i != (ttag - 1))
-                p[i] |= 0x80;
-            tag >>= 7;
-        }
-        p += ttag;
+                     int xclass) {
+  unsigned char *p = *pp;
+  int i, ttag;
+
+  i = (constructed) ? V_ASN1_CONSTRUCTED : 0;
+  i |= (xclass & V_ASN1_PRIVATE);
+  if (tag < 31) {
+    *(p++) = i | (tag & V_ASN1_PRIMITIVE_TAG);
+  } else {
+    *(p++) = i | V_ASN1_PRIMITIVE_TAG;
+    for (i = 0, ttag = tag; ttag > 0; i++) {
+      ttag >>= 7;
+    }
+    ttag = i;
+    while (i-- > 0) {
+      p[i] = tag & 0x7f;
+      if (i != (ttag - 1)) {
+        p[i] |= 0x80;
+      }
+      tag >>= 7;
     }
-    if (constructed == 2)
-        *(p++) = 0x80;
-    else
-        asn1_put_length(&p, length);
-    *pp = p;
+    p += ttag;
+  }
+  if (constructed == 2) {
+    *(p++) = 0x80;
+  } else {
+    asn1_put_length(&p, length);
+  }
+  *pp = p;
 }
 
-int ASN1_put_eoc(unsigned char **pp)
-{
-    /* This function is no longer used in the library, but some external code
-     * uses it. */
-    unsigned char *p = *pp;
-    *p++ = 0;
-    *p++ = 0;
-    *pp = p;
-    return 2;
+int ASN1_put_eoc(unsigned char **pp) {
+  // This function is no longer used in the library, but some external code
+  // uses it.
+  unsigned char *p = *pp;
+  *p++ = 0;
+  *p++ = 0;
+  *pp = p;
+  return 2;
 }
 
-static void asn1_put_length(unsigned char **pp, int length)
-{
-    unsigned char *p = *pp;
-    int i, l;
-    if (length <= 127)
-        *(p++) = (unsigned char)length;
-    else {
-        l = length;
-        for (i = 0; l > 0; i++)
-            l >>= 8;
-        *(p++) = i | 0x80;
-        l = i;
-        while (i-- > 0) {
-            p[i] = length & 0xff;
-            length >>= 8;
-        }
-        p += l;
+static void asn1_put_length(unsigned char **pp, int length) {
+  unsigned char *p = *pp;
+  int i, l;
+  if (length <= 127) {
+    *(p++) = (unsigned char)length;
+  } else {
+    l = length;
+    for (i = 0; l > 0; i++) {
+      l >>= 8;
     }
-    *pp = p;
+    *(p++) = i | 0x80;
+    l = i;
+    while (i-- > 0) {
+      p[i] = length & 0xff;
+      length >>= 8;
+    }
+    p += l;
+  }
+  *pp = p;
 }
 
-int ASN1_object_size(int constructed, int length, int tag)
-{
-    int ret = 1;
-    if (length < 0)
-        return -1;
-    if (tag >= 31) {
-        while (tag > 0) {
-            tag >>= 7;
-            ret++;
-        }
+int ASN1_object_size(int constructed, int length, int tag) {
+  int ret = 1;
+  if (length < 0) {
+    return -1;
+  }
+  if (tag >= 31) {
+    while (tag > 0) {
+      tag >>= 7;
+      ret++;
     }
-    if (constructed == 2) {
-        ret += 3;
-    } else {
+  }
+  if (constructed == 2) {
+    ret += 3;
+  } else {
+    ret++;
+    if (length > 127) {
+      int tmplen = length;
+      while (tmplen > 0) {
+        tmplen >>= 8;
         ret++;
-        if (length > 127) {
-            int tmplen = length;
-            while (tmplen > 0) {
-                tmplen >>= 8;
-                ret++;
-            }
-        }
+      }
     }
-    if (ret >= INT_MAX - length)
-        return -1;
-    return ret + length;
+  }
+  if (ret >= INT_MAX - length) {
+    return -1;
+  }
+  return ret + length;
 }
 
-int ASN1_STRING_copy(ASN1_STRING *dst, const ASN1_STRING *str)
-{
-    if (str == NULL)
-        return 0;
-    if (!ASN1_STRING_set(dst, str->data, str->length))
-        return 0;
-    dst->type = str->type;
-    dst->flags = str->flags;
-    return 1;
+int ASN1_STRING_copy(ASN1_STRING *dst, const ASN1_STRING *str) {
+  if (str == NULL) {
+    return 0;
+  }
+  if (!ASN1_STRING_set(dst, str->data, str->length)) {
+    return 0;
+  }
+  dst->type = str->type;
+  dst->flags = str->flags;
+  return 1;
 }
 
-ASN1_STRING *ASN1_STRING_dup(const ASN1_STRING *str)
-{
-    ASN1_STRING *ret;
-    if (!str)
-        return NULL;
-    ret = ASN1_STRING_new();
-    if (!ret)
-        return NULL;
-    if (!ASN1_STRING_copy(ret, str)) {
-        ASN1_STRING_free(ret);
-        return NULL;
-    }
-    return ret;
+ASN1_STRING *ASN1_STRING_dup(const ASN1_STRING *str) {
+  ASN1_STRING *ret;
+  if (!str) {
+    return NULL;
+  }
+  ret = ASN1_STRING_new();
+  if (!ret) {
+    return NULL;
+  }
+  if (!ASN1_STRING_copy(ret, str)) {
+    ASN1_STRING_free(ret);
+    return NULL;
+  }
+  return ret;
 }
 
-int ASN1_STRING_set(ASN1_STRING *str, const void *_data, int len)
-{
-    unsigned char *c;
-    const char *data = _data;
+int ASN1_STRING_set(ASN1_STRING *str, const void *_data, int len) {
+  unsigned char *c;
+  const char *data = _data;
 
-    if (len < 0) {
-        if (data == NULL)
-            return (0);
-        else
-            len = strlen(data);
+  if (len < 0) {
+    if (data == NULL) {
+      return 0;
+    } else {
+      len = strlen(data);
     }
-    if ((str->length <= len) || (str->data == NULL)) {
-        c = str->data;
-        if (c == NULL)
-            str->data = OPENSSL_malloc(len + 1);
-        else
-            str->data = OPENSSL_realloc(c, len + 1);
-
-        if (str->data == NULL) {
-            OPENSSL_PUT_ERROR(ASN1, ERR_R_MALLOC_FAILURE);
-            str->data = c;
-            return (0);
-        }
+  }
+  if ((str->length <= len) || (str->data == NULL)) {
+    c = str->data;
+    if (c == NULL) {
+      str->data = OPENSSL_malloc(len + 1);
+    } else {
+      str->data = OPENSSL_realloc(c, len + 1);
     }
-    str->length = len;
-    if (data != NULL) {
-        OPENSSL_memcpy(str->data, data, len);
-        /* an allowance for strings :-) */
-        str->data[len] = '\0';
+
+    if (str->data == NULL) {
+      OPENSSL_PUT_ERROR(ASN1, ERR_R_MALLOC_FAILURE);
+      str->data = c;
+      return 0;
     }
-    return (1);
+  }
+  str->length = len;
+  if (data != NULL) {
+    OPENSSL_memcpy(str->data, data, len);
+    // an allowance for strings :-)
+    str->data[len] = '\0';
+  }
+  return 1;
 }
 
-void ASN1_STRING_set0(ASN1_STRING *str, void *data, int len)
-{
-    OPENSSL_free(str->data);
-    str->data = data;
-    str->length = len;
+void ASN1_STRING_set0(ASN1_STRING *str, void *data, int len) {
+  OPENSSL_free(str->data);
+  str->data = data;
+  str->length = len;
 }
 
-ASN1_STRING *ASN1_STRING_new(void)
-{
-    return (ASN1_STRING_type_new(V_ASN1_OCTET_STRING));
+ASN1_STRING *ASN1_STRING_new(void) {
+  return (ASN1_STRING_type_new(V_ASN1_OCTET_STRING));
 }
 
-ASN1_STRING *ASN1_STRING_type_new(int type)
-{
-    ASN1_STRING *ret;
-
-    ret = (ASN1_STRING *)OPENSSL_malloc(sizeof(ASN1_STRING));
-    if (ret == NULL) {
-        OPENSSL_PUT_ERROR(ASN1, ERR_R_MALLOC_FAILURE);
-        return (NULL);
-    }
-    ret->length = 0;
-    ret->type = type;
-    ret->data = NULL;
-    ret->flags = 0;
-    return (ret);
+ASN1_STRING *ASN1_STRING_type_new(int type) {
+  ASN1_STRING *ret;
+
+  ret = (ASN1_STRING *)OPENSSL_malloc(sizeof(ASN1_STRING));
+  if (ret == NULL) {
+    OPENSSL_PUT_ERROR(ASN1, ERR_R_MALLOC_FAILURE);
+    return NULL;
+  }
+  ret->length = 0;
+  ret->type = type;
+  ret->data = NULL;
+  ret->flags = 0;
+  return ret;
 }
 
-void ASN1_STRING_free(ASN1_STRING *str)
-{
-    if (str == NULL)
-        return;
-    OPENSSL_free(str->data);
-    OPENSSL_free(str);
+void ASN1_STRING_free(ASN1_STRING *str) {
+  if (str == NULL) {
+    return;
+  }
+  OPENSSL_free(str->data);
+  OPENSSL_free(str);
 }
 
-int ASN1_STRING_cmp(const ASN1_STRING *a, const ASN1_STRING *b)
-{
-    /* Capture padding bits and implicit truncation in BIT STRINGs. */
-    int a_length = a->length, b_length = b->length;
-    uint8_t a_padding = 0, b_padding = 0;
-    if (a->type == V_ASN1_BIT_STRING) {
-        a_length = asn1_bit_string_length(a, &a_padding);
-    }
-    if (b->type == V_ASN1_BIT_STRING) {
-        b_length = asn1_bit_string_length(b, &b_padding);
-    }
-
-    if (a_length < b_length) {
-        return -1;
-    }
-    if (a_length > b_length) {
-        return 1;
-    }
-    /* In a BIT STRING, the number of bits is 8 * length - padding. Invert this
-     * comparison so we compare by lengths. */
-    if (a_padding > b_padding) {
-        return -1;
-    }
-    if (a_padding < b_padding) {
-        return 1;
-    }
+int ASN1_STRING_cmp(const ASN1_STRING *a, const ASN1_STRING *b) {
+  // Capture padding bits and implicit truncation in BIT STRINGs.
+  int a_length = a->length, b_length = b->length;
+  uint8_t a_padding = 0, b_padding = 0;
+  if (a->type == V_ASN1_BIT_STRING) {
+    a_length = asn1_bit_string_length(a, &a_padding);
+  }
+  if (b->type == V_ASN1_BIT_STRING) {
+    b_length = asn1_bit_string_length(b, &b_padding);
+  }
+
+  if (a_length < b_length) {
+    return -1;
+  }
+  if (a_length > b_length) {
+    return 1;
+  }
+  // In a BIT STRING, the number of bits is 8 * length - padding. Invert this
+  // comparison so we compare by lengths.
+  if (a_padding > b_padding) {
+    return -1;
+  }
+  if (a_padding < b_padding) {
+    return 1;
+  }
 
-    int ret = OPENSSL_memcmp(a->data, b->data, a_length);
-    if (ret != 0) {
-        return ret;
-    }
+  int ret = OPENSSL_memcmp(a->data, b->data, a_length);
+  if (ret != 0) {
+    return ret;
+  }
 
-    /* Comparing the type first is more natural, but this matches OpenSSL. */
-    if (a->type < b->type) {
-        return -1;
-    }
-    if (a->type > b->type) {
-        return 1;
-    }
-    return 0;
+  // Comparing the type first is more natural, but this matches OpenSSL.
+  if (a->type < b->type) {
+    return -1;
+  }
+  if (a->type > b->type) {
+    return 1;
+  }
+  return 0;
 }
 
-int ASN1_STRING_length(const ASN1_STRING *str)
-{
-    return str->length;
-}
+int ASN1_STRING_length(const ASN1_STRING *str) { return str->length; }
 
-int ASN1_STRING_type(const ASN1_STRING *str)
-{
-    return str->type;
-}
+int ASN1_STRING_type(const ASN1_STRING *str) { return str->type; }
 
-unsigned char *ASN1_STRING_data(ASN1_STRING *str)
-{
-    return str->data;
-}
+unsigned char *ASN1_STRING_data(ASN1_STRING *str) { return str->data; }
 
-const unsigned char *ASN1_STRING_get0_data(const ASN1_STRING *str)
-{
-    return str->data;
+const unsigned char *ASN1_STRING_get0_data(const ASN1_STRING *str) {
+  return str->data;
 }

package/third_party/boringssl/src/crypto/asn1/asn1_par.c

@@ -57,46 +57,47 @@
 #include <openssl/asn1.h>
 
 
-const char *ASN1_tag2str(int tag)
-{
-    static const char *const tag2str[] = {
-        "EOC",
-        "BOOLEAN",
-        "INTEGER",
-        "BIT STRING",
-        "OCTET STRING",
-        "NULL",
-        "OBJECT",
-        "OBJECT DESCRIPTOR",
-        "EXTERNAL",
-        "REAL",
-        "ENUMERATED",
-        "<ASN1 11>",
-        "UTF8STRING",
-        "<ASN1 13>",
-        "<ASN1 14>",
-        "<ASN1 15>",
-        "SEQUENCE",
-        "SET",
-        "NUMERICSTRING",
-        "PRINTABLESTRING",
-        "T61STRING",
-        "VIDEOTEXSTRING",
-        "IA5STRING",
-        "UTCTIME",
-        "GENERALIZEDTIME",
-        "GRAPHICSTRING",
-        "VISIBLESTRING",
-        "GENERALSTRING",
-        "UNIVERSALSTRING",
-        "<ASN1 29>",
-        "BMPSTRING",
-    };
+const char *ASN1_tag2str(int tag) {
+  static const char *const tag2str[] = {
+      "EOC",
+      "BOOLEAN",
+      "INTEGER",
+      "BIT STRING",
+      "OCTET STRING",
+      "NULL",
+      "OBJECT",
+      "OBJECT DESCRIPTOR",
+      "EXTERNAL",
+      "REAL",
+      "ENUMERATED",
+      "<ASN1 11>",
+      "UTF8STRING",
+      "<ASN1 13>",
+      "<ASN1 14>",
+      "<ASN1 15>",
+      "SEQUENCE",
+      "SET",
+      "NUMERICSTRING",
+      "PRINTABLESTRING",
+      "T61STRING",
+      "VIDEOTEXSTRING",
+      "IA5STRING",
+      "UTCTIME",
+      "GENERALIZEDTIME",
+      "GRAPHICSTRING",
+      "VISIBLESTRING",
+      "GENERALSTRING",
+      "UNIVERSALSTRING",
+      "<ASN1 29>",
+      "BMPSTRING",
+  };
 
-    if ((tag == V_ASN1_NEG_INTEGER) || (tag == V_ASN1_NEG_ENUMERATED))
-        tag &= ~V_ASN1_NEG;
+  if ((tag == V_ASN1_NEG_INTEGER) || (tag == V_ASN1_NEG_ENUMERATED)) {
+    tag &= ~V_ASN1_NEG;
+  }
 
-    if (tag < 0 || tag > 30)
-        return "(unknown)";
-    return tag2str[tag];
+  if (tag < 0 || tag > 30) {
+    return "(unknown)";
+  }
+  return tag2str[tag];
 }