@fails-components/webtransport 0.0.1 → 0.0.2

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

@@ -71,242 +71,225 @@
   (ASN1_STRFLGS_ESC_2253 | ASN1_STRFLGS_ESC_QUOTE | ASN1_STRFLGS_ESC_CTRL | \
    ASN1_STRFLGS_ESC_MSB)
 
-static int maybe_write(BIO *out, const void *buf, int len)
-{
-    /* If |out| is NULL, ignore the output but report the length. */
-    return out == NULL || BIO_write(out, buf, len) == len;
+static int maybe_write(BIO *out, const void *buf, int len) {
+  // If |out| is NULL, ignore the output but report the length.
+  return out == NULL || BIO_write(out, buf, len) == len;
 }
 
-static int is_control_character(unsigned char c)
-{
-    return c < 32 || c == 127;
-}
+static int is_control_character(unsigned char c) { return c < 32 || c == 127; }
 
 static int do_esc_char(uint32_t c, unsigned long flags, char *do_quotes,
-                       BIO *out, int is_first, int is_last)
-{
-    /* |c| is a |uint32_t| because, depending on |ASN1_STRFLGS_UTF8_CONVERT|,
-     * we may be escaping bytes or Unicode codepoints. */
-    char buf[16];  /* Large enough for "\\W01234567". */
-    unsigned char u8 = (unsigned char)c;
-    if (c > 0xffff) {
-        BIO_snprintf(buf, sizeof(buf), "\\W%08" PRIX32, c);
-    } else if (c > 0xff) {
-        BIO_snprintf(buf, sizeof(buf), "\\U%04" PRIX32, c);
-    } else if ((flags & ASN1_STRFLGS_ESC_MSB) && c > 0x7f) {
-        BIO_snprintf(buf, sizeof(buf), "\\%02X", c);
-    } else if ((flags & ASN1_STRFLGS_ESC_CTRL) && is_control_character(c)) {
-        BIO_snprintf(buf, sizeof(buf), "\\%02X", c);
-    } else if (flags & ASN1_STRFLGS_ESC_2253) {
-        /* See RFC 2253, sections 2.4 and 4. */
-        if (c == '\\' || c == '"') {
-            /* Quotes and backslashes are always escaped, quoted or not. */
-            BIO_snprintf(buf, sizeof(buf), "\\%c", (int)c);
-        } else if (c == ',' || c == '+' || c == '<' || c == '>' || c == ';' ||
-                   (is_first && (c == ' ' || c == '#')) ||
-                   (is_last && (c == ' '))) {
-            if (flags & ASN1_STRFLGS_ESC_QUOTE) {
-                /* No need to escape, just tell the caller to quote. */
-                if (do_quotes != NULL) {
-                    *do_quotes = 1;
-                }
-                return maybe_write(out, &u8, 1) ? 1 : -1;
-            }
-            BIO_snprintf(buf, sizeof(buf), "\\%c", (int)c);
-        } else {
-            return maybe_write(out, &u8, 1) ? 1 : -1;
+                       BIO *out, int is_first, int is_last) {
+  // |c| is a |uint32_t| because, depending on |ASN1_STRFLGS_UTF8_CONVERT|,
+  // we may be escaping bytes or Unicode codepoints.
+  char buf[16];  // Large enough for "\\W01234567".
+  unsigned char u8 = (unsigned char)c;
+  if (c > 0xffff) {
+    BIO_snprintf(buf, sizeof(buf), "\\W%08" PRIX32, c);
+  } else if (c > 0xff) {
+    BIO_snprintf(buf, sizeof(buf), "\\U%04" PRIX32, c);
+  } else if ((flags & ASN1_STRFLGS_ESC_MSB) && c > 0x7f) {
+    BIO_snprintf(buf, sizeof(buf), "\\%02X", c);
+  } else if ((flags & ASN1_STRFLGS_ESC_CTRL) && is_control_character(c)) {
+    BIO_snprintf(buf, sizeof(buf), "\\%02X", c);
+  } else if (flags & ASN1_STRFLGS_ESC_2253) {
+    // See RFC 2253, sections 2.4 and 4.
+    if (c == '\\' || c == '"') {
+      // Quotes and backslashes are always escaped, quoted or not.
+      BIO_snprintf(buf, sizeof(buf), "\\%c", (int)c);
+    } else if (c == ',' || c == '+' || c == '<' || c == '>' || c == ';' ||
+               (is_first && (c == ' ' || c == '#')) ||
+               (is_last && (c == ' '))) {
+      if (flags & ASN1_STRFLGS_ESC_QUOTE) {
+        // No need to escape, just tell the caller to quote.
+        if (do_quotes != NULL) {
+          *do_quotes = 1;
         }
-    } else if ((flags & ESC_FLAGS) && c == '\\') {
-        /* If any escape flags are set, also escape backslashes. */
-        BIO_snprintf(buf, sizeof(buf), "\\%c", (int)c);
-    } else {
         return maybe_write(out, &u8, 1) ? 1 : -1;
+      }
+      BIO_snprintf(buf, sizeof(buf), "\\%c", (int)c);
+    } else {
+      return maybe_write(out, &u8, 1) ? 1 : -1;
     }
+  } else if ((flags & ESC_FLAGS) && c == '\\') {
+    // If any escape flags are set, also escape backslashes.
+    BIO_snprintf(buf, sizeof(buf), "\\%c", (int)c);
+  } else {
+    return maybe_write(out, &u8, 1) ? 1 : -1;
+  }
 
-    int len = strlen(buf);
-    return maybe_write(out, buf, len) ? len : -1;
+  int len = strlen(buf);
+  return maybe_write(out, buf, len) ? len : -1;
 }
 
-/*
- * This function sends each character in a buffer to do_esc_char(). It
- * interprets the content formats and converts to or from UTF8 as
- * appropriate.
- */
+// This function sends each character in a buffer to do_esc_char(). It
+// interprets the content formats and converts to or from UTF8 as
+// appropriate.
 
 static int do_buf(const unsigned char *buf, int buflen, int encoding,
-                  int utf8_convert, unsigned long flags, char *quotes, BIO *out)
-{
-    /* Reject invalid UCS-4 and UCS-2 lengths without parsing. */
-    switch (encoding) {
+                  int utf8_convert, unsigned long flags, char *quotes,
+                  BIO *out) {
+  // Reject invalid UCS-4 and UCS-2 lengths without parsing.
+  switch (encoding) {
     case MBSTRING_UNIV:
-        if (buflen & 3) {
-            OPENSSL_PUT_ERROR(ASN1, ASN1_R_INVALID_UNIVERSALSTRING);
-            return -1;
-        }
-        break;
+      if (buflen & 3) {
+        OPENSSL_PUT_ERROR(ASN1, ASN1_R_INVALID_UNIVERSALSTRING);
+        return -1;
+      }
+      break;
     case MBSTRING_BMP:
-        if (buflen & 1) {
-            OPENSSL_PUT_ERROR(ASN1, ASN1_R_INVALID_BMPSTRING);
-            return -1;
-        }
+      if (buflen & 1) {
+        OPENSSL_PUT_ERROR(ASN1, ASN1_R_INVALID_BMPSTRING);
+        return -1;
+      }
+      break;
+  }
+
+  const unsigned char *p = buf;
+  const unsigned char *q = buf + buflen;
+  int outlen = 0;
+  while (p != q) {
+    const int is_first = p == buf;
+    // TODO(davidben): Replace this with |cbs_get_ucs2_be|, etc., to check
+    // for invalid codepoints. Before doing that, enforce it in the parser,
+    // https://crbug.com/boringssl/427, so these error cases are not
+    // reachable from parsed objects.
+    uint32_t c;
+    switch (encoding) {
+      case MBSTRING_UNIV:
+        c = ((uint32_t)*p++) << 24;
+        c |= ((uint32_t)*p++) << 16;
+        c |= ((uint32_t)*p++) << 8;
+        c |= *p++;
         break;
-    }
 
-    const unsigned char *p = buf;
-    const unsigned char *q = buf + buflen;
-    int outlen = 0;
-    while (p != q) {
-        const int is_first = p == buf;
-        /* TODO(davidben): Replace this with |cbs_get_ucs2_be|, etc., to check
-         * for invalid codepoints. Before doing that, enforce it in the parser,
-         * https://crbug.com/boringssl/427, so these error cases are not
-         * reachable from parsed objects. */
-        uint32_t c;
-        switch (encoding) {
-        case MBSTRING_UNIV:
-            c = ((uint32_t)*p++) << 24;
-            c |= ((uint32_t)*p++) << 16;
-            c |= ((uint32_t)*p++) << 8;
-            c |= *p++;
-            break;
-
-        case MBSTRING_BMP:
-            c = ((uint32_t)*p++) << 8;
-            c |= *p++;
-            break;
-
-        case MBSTRING_ASC:
-            c = *p++;
-            break;
-
-        case MBSTRING_UTF8: {
-            int consumed = UTF8_getc(p, buflen, &c);
-            if (consumed < 0)
-                return -1;      /* Invalid UTF8String */
-            buflen -= consumed;
-            p += consumed;
-            break;
-        }
+      case MBSTRING_BMP:
+        c = ((uint32_t)*p++) << 8;
+        c |= *p++;
+        break;
 
-        default:
-            assert(0);
-            return -1;
-        }
-        const int is_last = p == q;
-        if (utf8_convert) {
-            unsigned char utfbuf[6];
-            int utflen;
-            utflen = UTF8_putc(utfbuf, sizeof utfbuf, c);
-            for (int i = 0; i < utflen; i++) {
-                /*
-                 * We don't need to worry about setting orflags correctly
-                 * because if utflen==1 its value will be correct anyway
-                 * otherwise each character will be > 0x7f and so the
-                 * character will never be escaped on first and last.
-                 */
-                int len = do_esc_char(utfbuf[i], flags, quotes, out, is_first,
-                                      is_last);
-                if (len < 0) {
-                    return -1;
-                }
-                outlen += len;
-            }
-        } else {
-            int len = do_esc_char(c, flags, quotes, out, is_first, is_last);
-            if (len < 0) {
-                return -1;
-            }
-            outlen += len;
+      case MBSTRING_ASC:
+        c = *p++;
+        break;
+
+      case MBSTRING_UTF8: {
+        int consumed = UTF8_getc(p, buflen, &c);
+        if (consumed < 0) {
+          return -1;  // Invalid UTF8String
         }
-    }
-    return outlen;
-}
+        buflen -= consumed;
+        p += consumed;
+        break;
+      }
 
-/* This function hex dumps a buffer of characters */
-
-static int do_hex_dump(BIO *out, unsigned char *buf, int buflen)
-{
-    static const char hexdig[] = "0123456789ABCDEF";
-    unsigned char *p, *q;
-    char hextmp[2];
-    if (out) {
-        p = buf;
-        q = buf + buflen;
-        while (p != q) {
-            hextmp[0] = hexdig[*p >> 4];
-            hextmp[1] = hexdig[*p & 0xf];
-            if (!maybe_write(out, hextmp, 2))
-                return -1;
-            p++;
+      default:
+        assert(0);
+        return -1;
+    }
+    const int is_last = p == q;
+    if (utf8_convert) {
+      unsigned char utfbuf[6];
+      int utflen;
+      utflen = UTF8_putc(utfbuf, sizeof utfbuf, c);
+      for (int i = 0; i < utflen; i++) {
+        int len = do_esc_char(utfbuf[i], flags, quotes, out, is_first && i == 0,
+                              is_last && i == utflen - 1);
+        if (len < 0) {
+          return -1;
         }
+        outlen += len;
+      }
+    } else {
+      int len = do_esc_char(c, flags, quotes, out, is_first, is_last);
+      if (len < 0) {
+        return -1;
+      }
+      outlen += len;
     }
-    return buflen << 1;
+  }
+  return outlen;
 }
 
-/*
- * "dump" a string. This is done when the type is unknown, or the flags
- * request it. We can either dump the content octets or the entire DER
- * encoding. This uses the RFC 2253 #01234 format.
- */
+// This function hex dumps a buffer of characters
 
-static int do_dump(unsigned long flags, BIO *out, const ASN1_STRING *str)
-{
-    if (!maybe_write(out, "#", 1)) {
+static int do_hex_dump(BIO *out, unsigned char *buf, int buflen) {
+  static const char hexdig[] = "0123456789ABCDEF";
+  unsigned char *p, *q;
+  char hextmp[2];
+  if (out) {
+    p = buf;
+    q = buf + buflen;
+    while (p != q) {
+      hextmp[0] = hexdig[*p >> 4];
+      hextmp[1] = hexdig[*p & 0xf];
+      if (!maybe_write(out, hextmp, 2)) {
         return -1;
+      }
+      p++;
     }
+  }
+  return buflen << 1;
+}
 
-    /* If we don't dump DER encoding just dump content octets */
-    if (!(flags & ASN1_STRFLGS_DUMP_DER)) {
-        int outlen = do_hex_dump(out, str->data, str->length);
-        if (outlen < 0) {
-            return -1;
-        }
-        return outlen + 1;
-    }
+// "dump" a string. This is done when the type is unknown, or the flags
+// request it. We can either dump the content octets or the entire DER
+// encoding. This uses the RFC 2253 #01234 format.
 
-    /*
-     * Placing the ASN1_STRING in a temporary ASN1_TYPE allows the DER encoding
-     * to readily obtained.
-     */
-    ASN1_TYPE t;
-    t.type = str->type;
-    /* Negative INTEGER and ENUMERATED values are the only case where
-     * |ASN1_STRING| and |ASN1_TYPE| types do not match.
-     *
-     * TODO(davidben): There are also some type fields which, in |ASN1_TYPE|, do
-     * not correspond to |ASN1_STRING|. It is unclear whether those are allowed
-     * in |ASN1_STRING| at all, or what the space of allowed types is.
-     * |ASN1_item_ex_d2i| will never produce such a value so, for now, we say
-     * this is an invalid input. But this corner of the library in general
-     * should be more robust. */
-    if (t.type == V_ASN1_NEG_INTEGER) {
-      t.type = V_ASN1_INTEGER;
-    } else if (t.type == V_ASN1_NEG_ENUMERATED) {
-      t.type = V_ASN1_ENUMERATED;
-    }
-    t.value.asn1_string = (ASN1_STRING *)str;
-    unsigned char *der_buf = NULL;
-    int der_len = i2d_ASN1_TYPE(&t, &der_buf);
-    if (der_len < 0) {
-        return -1;
-    }
-    int outlen = do_hex_dump(out, der_buf, der_len);
-    OPENSSL_free(der_buf);
+static int do_dump(unsigned long flags, BIO *out, const ASN1_STRING *str) {
+  if (!maybe_write(out, "#", 1)) {
+    return -1;
+  }
+
+  // If we don't dump DER encoding just dump content octets
+  if (!(flags & ASN1_STRFLGS_DUMP_DER)) {
+    int outlen = do_hex_dump(out, str->data, str->length);
     if (outlen < 0) {
-        return -1;
+      return -1;
     }
     return outlen + 1;
+  }
+
+  // Placing the ASN1_STRING in a temporary ASN1_TYPE allows the DER encoding
+  // to readily obtained.
+  ASN1_TYPE t;
+  t.type = str->type;
+  // Negative INTEGER and ENUMERATED values are the only case where
+  // |ASN1_STRING| and |ASN1_TYPE| types do not match.
+  //
+  // TODO(davidben): There are also some type fields which, in |ASN1_TYPE|, do
+  // not correspond to |ASN1_STRING|. It is unclear whether those are allowed
+  // in |ASN1_STRING| at all, or what the space of allowed types is.
+  // |ASN1_item_ex_d2i| will never produce such a value so, for now, we say
+  // this is an invalid input. But this corner of the library in general
+  // should be more robust.
+  if (t.type == V_ASN1_NEG_INTEGER) {
+    t.type = V_ASN1_INTEGER;
+  } else if (t.type == V_ASN1_NEG_ENUMERATED) {
+    t.type = V_ASN1_ENUMERATED;
+  }
+  t.value.asn1_string = (ASN1_STRING *)str;
+  unsigned char *der_buf = NULL;
+  int der_len = i2d_ASN1_TYPE(&t, &der_buf);
+  if (der_len < 0) {
+    return -1;
+  }
+  int outlen = do_hex_dump(out, der_buf, der_len);
+  OPENSSL_free(der_buf);
+  if (outlen < 0) {
+    return -1;
+  }
+  return outlen + 1;
 }
 
-/* string_type_to_encoding returns the |MBSTRING_*| constant for the encoding
- * used by the |ASN1_STRING| type |type|, or -1 if |tag| is not a string
- * type. */
+// string_type_to_encoding returns the |MBSTRING_*| constant for the encoding
+// used by the |ASN1_STRING| type |type|, or -1 if |tag| is not a string
+// type.
 static int string_type_to_encoding(int type) {
-    /* This function is sometimes passed ASN.1 universal types and sometimes
-     * passed |ASN1_STRING| type values */
-    switch (type) {
+  // This function is sometimes passed ASN.1 universal types and sometimes
+  // passed |ASN1_STRING| type values
+  switch (type) {
     case V_ASN1_UTF8STRING:
-        return MBSTRING_UTF8;
+      return MBSTRING_UTF8;
     case V_ASN1_NUMERICSTRING:
     case V_ASN1_PRINTABLESTRING:
     case V_ASN1_T61STRING:
@@ -314,235 +297,241 @@ static int string_type_to_encoding(int type) {
     case V_ASN1_UTCTIME:
     case V_ASN1_GENERALIZEDTIME:
     case V_ASN1_ISO64STRING:
-        /* |MBSTRING_ASC| refers to Latin-1, not ASCII. */
-        return MBSTRING_ASC;
+      // |MBSTRING_ASC| refers to Latin-1, not ASCII.
+      return MBSTRING_ASC;
     case V_ASN1_UNIVERSALSTRING:
-        return MBSTRING_UNIV;
+      return MBSTRING_UNIV;
     case V_ASN1_BMPSTRING:
-        return MBSTRING_BMP;
-    }
-    return -1;
+      return MBSTRING_BMP;
+  }
+  return -1;
 }
 
-/*
- * This is the main function, print out an ASN1_STRING taking note of various
- * escape and display options. Returns number of characters written or -1 if
- * an error occurred.
- */
-
-int ASN1_STRING_print_ex(BIO *out, const ASN1_STRING *str, unsigned long flags)
-{
-    int type = str->type;
-    int outlen = 0;
-    if (flags & ASN1_STRFLGS_SHOW_TYPE) {
-        const char *tagname = ASN1_tag2str(type);
-        outlen += strlen(tagname);
-        if (!maybe_write(out, tagname, outlen) || !maybe_write(out, ":", 1))
-            return -1;
-        outlen++;
-    }
-
-    /* Decide what to do with |str|, either dump the contents or display it. */
-    int encoding;
-    if (flags & ASN1_STRFLGS_DUMP_ALL) {
-        /* Dump everything. */
-        encoding = -1;
-    } else if (flags & ASN1_STRFLGS_IGNORE_TYPE) {
-        /* Ignore the string type and interpret the contents as Latin-1. */
-        encoding = MBSTRING_ASC;
-    } else {
-        encoding = string_type_to_encoding(type);
-        if (encoding == -1 && (flags & ASN1_STRFLGS_DUMP_UNKNOWN) == 0) {
-            encoding = MBSTRING_ASC;
-        }
-    }
-
-    if (encoding == -1) {
-        int len = do_dump(flags, out, str);
-        if (len < 0)
-            return -1;
-        outlen += len;
-        return outlen;
+// This is the main function, print out an ASN1_STRING taking note of various
+// escape and display options. Returns number of characters written or -1 if
+// an error occurred.
+
+int ASN1_STRING_print_ex(BIO *out, const ASN1_STRING *str,
+                         unsigned long flags) {
+  int type = str->type;
+  int outlen = 0;
+  if (flags & ASN1_STRFLGS_SHOW_TYPE) {
+    const char *tagname = ASN1_tag2str(type);
+    outlen += strlen(tagname);
+    if (!maybe_write(out, tagname, outlen) || !maybe_write(out, ":", 1)) {
+      return -1;
     }
+    outlen++;
+  }
 
-    int utf8_convert = 0;
-    if (flags & ASN1_STRFLGS_UTF8_CONVERT) {
-        /* If the string is UTF-8, skip decoding and just interpret it as 1 byte
-         * per character to avoid converting twice.
-         *
-         * TODO(davidben): This is not quite a valid optimization if the input
-         * was invalid UTF-8. */
-        if (encoding == MBSTRING_UTF8) {
-            encoding = MBSTRING_ASC;
-        } else {
-            utf8_convert = 1;
-        }
+  // Decide what to do with |str|, either dump the contents or display it.
+  int encoding;
+  if (flags & ASN1_STRFLGS_DUMP_ALL) {
+    // Dump everything.
+    encoding = -1;
+  } else if (flags & ASN1_STRFLGS_IGNORE_TYPE) {
+    // Ignore the string type and interpret the contents as Latin-1.
+    encoding = MBSTRING_ASC;
+  } else {
+    encoding = string_type_to_encoding(type);
+    if (encoding == -1 && (flags & ASN1_STRFLGS_DUMP_UNKNOWN) == 0) {
+      encoding = MBSTRING_ASC;
     }
+  }
 
-    /* Measure the length. */
-    char quotes = 0;
-    int len = do_buf(str->data, str->length, encoding, utf8_convert, flags,
-                     &quotes, NULL);
+  if (encoding == -1) {
+    int len = do_dump(flags, out, str);
     if (len < 0) {
-        return -1;
+      return -1;
     }
     outlen += len;
-    if (quotes) {
-        outlen += 2;
-    }
-    if (!out) {
-        return outlen;
-    }
+    return outlen;
+  }
 
-    /* Encode the value. */
-    if ((quotes && !maybe_write(out, "\"", 1)) ||
-        do_buf(str->data, str->length, encoding, utf8_convert, flags, NULL,
-               out) < 0 ||
-        (quotes && !maybe_write(out, "\"", 1))) {
-        return -1;
+  int utf8_convert = 0;
+  if (flags & ASN1_STRFLGS_UTF8_CONVERT) {
+    // If the string is UTF-8, skip decoding and just interpret it as 1 byte
+    // per character to avoid converting twice.
+    //
+    // TODO(davidben): This is not quite a valid optimization if the input
+    // was invalid UTF-8.
+    if (encoding == MBSTRING_UTF8) {
+      encoding = MBSTRING_ASC;
+    } else {
+      utf8_convert = 1;
     }
+  }
+
+  // Measure the length.
+  char quotes = 0;
+  int len = do_buf(str->data, str->length, encoding, utf8_convert, flags,
+                   &quotes, NULL);
+  if (len < 0) {
+    return -1;
+  }
+  outlen += len;
+  if (quotes) {
+    outlen += 2;
+  }
+  if (!out) {
     return outlen;
+  }
+
+  // Encode the value.
+  if ((quotes && !maybe_write(out, "\"", 1)) ||
+      do_buf(str->data, str->length, encoding, utf8_convert, flags, NULL, out) <
+          0 ||
+      (quotes && !maybe_write(out, "\"", 1))) {
+    return -1;
+  }
+  return outlen;
 }
 
 int ASN1_STRING_print_ex_fp(FILE *fp, const ASN1_STRING *str,
-                            unsigned long flags)
-{
-    BIO *bio = NULL;
-    if (fp != NULL) {
-        /* If |fp| is NULL, this function returns the number of bytes without
-         * writing. */
-        bio = BIO_new_fp(fp, BIO_NOCLOSE);
-        if (bio == NULL) {
-            return -1;
-        }
+                            unsigned long flags) {
+  BIO *bio = NULL;
+  if (fp != NULL) {
+    // If |fp| is NULL, this function returns the number of bytes without
+    // writing.
+    bio = BIO_new_fp(fp, BIO_NOCLOSE);
+    if (bio == NULL) {
+      return -1;
     }
-    int ret = ASN1_STRING_print_ex(bio, str, flags);
-    BIO_free(bio);
-    return ret;
+  }
+  int ret = ASN1_STRING_print_ex(bio, str, flags);
+  BIO_free(bio);
+  return ret;
 }
 
-int ASN1_STRING_to_UTF8(unsigned char **out, const ASN1_STRING *in)
-{
-    if (!in)
-        return -1;
-    int mbflag = string_type_to_encoding(in->type);
-    if (mbflag == -1) {
-        OPENSSL_PUT_ERROR(ASN1, ASN1_R_UNKNOWN_TAG);
-        return -1;
-    }
-    ASN1_STRING stmp, *str = &stmp;
-    stmp.data = NULL;
-    stmp.length = 0;
-    stmp.flags = 0;
-    int ret = ASN1_mbstring_copy(&str, in->data, in->length, mbflag,
-                                 B_ASN1_UTF8STRING);
-    if (ret < 0)
-        return ret;
-    *out = stmp.data;
-    return stmp.length;
+int ASN1_STRING_to_UTF8(unsigned char **out, const ASN1_STRING *in) {
+  if (!in) {
+    return -1;
+  }
+  int mbflag = string_type_to_encoding(in->type);
+  if (mbflag == -1) {
+    OPENSSL_PUT_ERROR(ASN1, ASN1_R_UNKNOWN_TAG);
+    return -1;
+  }
+  ASN1_STRING stmp, *str = &stmp;
+  stmp.data = NULL;
+  stmp.length = 0;
+  stmp.flags = 0;
+  int ret =
+      ASN1_mbstring_copy(&str, in->data, in->length, mbflag, B_ASN1_UTF8STRING);
+  if (ret < 0) {
+    return ret;
+  }
+  *out = stmp.data;
+  return stmp.length;
 }
 
-int ASN1_STRING_print(BIO *bp, const ASN1_STRING *v)
-{
-    int i, n;
-    char buf[80];
-    const char *p;
-
-    if (v == NULL)
-        return (0);
-    n = 0;
-    p = (const char *)v->data;
-    for (i = 0; i < v->length; i++) {
-        if ((p[i] > '~') || ((p[i] < ' ') &&
-                             (p[i] != '\n') && (p[i] != '\r')))
-            buf[n] = '.';
-        else
-            buf[n] = p[i];
-        n++;
-        if (n >= 80) {
-            if (BIO_write(bp, buf, n) <= 0)
-                return (0);
-            n = 0;
-        }
+int ASN1_STRING_print(BIO *bp, const ASN1_STRING *v) {
+  int i, n;
+  char buf[80];
+  const char *p;
+
+  if (v == NULL) {
+    return 0;
+  }
+  n = 0;
+  p = (const char *)v->data;
+  for (i = 0; i < v->length; i++) {
+    if ((p[i] > '~') || ((p[i] < ' ') && (p[i] != '\n') && (p[i] != '\r'))) {
+      buf[n] = '.';
+    } else {
+      buf[n] = p[i];
     }
-    if (n > 0)
-        if (BIO_write(bp, buf, n) <= 0)
-            return (0);
-    return (1);
+    n++;
+    if (n >= 80) {
+      if (BIO_write(bp, buf, n) <= 0) {
+        return 0;
+      }
+      n = 0;
+    }
+  }
+  if (n > 0) {
+    if (BIO_write(bp, buf, n) <= 0) {
+      return 0;
+    }
+  }
+  return 1;
 }
 
-int ASN1_TIME_print(BIO *bp, const ASN1_TIME *tm)
-{
-    if (tm->type == V_ASN1_UTCTIME)
-        return ASN1_UTCTIME_print(bp, tm);
-    if (tm->type == V_ASN1_GENERALIZEDTIME)
-        return ASN1_GENERALIZEDTIME_print(bp, tm);
-    BIO_write(bp, "Bad time value", 14);
-    return (0);
+int ASN1_TIME_print(BIO *bp, const ASN1_TIME *tm) {
+  if (tm->type == V_ASN1_UTCTIME) {
+    return ASN1_UTCTIME_print(bp, tm);
+  }
+  if (tm->type == V_ASN1_GENERALIZEDTIME) {
+    return ASN1_GENERALIZEDTIME_print(bp, tm);
+  }
+  BIO_write(bp, "Bad time value", 14);
+  return 0;
 }
 
-static const char *const mon[12] = {
-    "Jan", "Feb", "Mar", "Apr", "May", "Jun",
-    "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"
-};
-
-int ASN1_GENERALIZEDTIME_print(BIO *bp, const ASN1_GENERALIZEDTIME *tm)
-{
-    char *v;
-    int gmt = 0;
-    int i;
-    int y = 0, M = 0, d = 0, h = 0, m = 0, s = 0;
-    char *f = NULL;
-    int f_len = 0;
-
-    i = tm->length;
-    v = (char *)tm->data;
-
-    if (i < 12)
-        goto err;
-    if (v[i - 1] == 'Z')
-        gmt = 1;
-    for (i = 0; i < 12; i++)
-        if ((v[i] > '9') || (v[i] < '0'))
-            goto err;
-    y = (v[0] - '0') * 1000 + (v[1] - '0') * 100 + (v[2] - '0') * 10 + (v[3] -
-                                                                        '0');
-    M = (v[4] - '0') * 10 + (v[5] - '0');
-    if ((M > 12) || (M < 1))
-        goto err;
-    d = (v[6] - '0') * 10 + (v[7] - '0');
-    h = (v[8] - '0') * 10 + (v[9] - '0');
-    m = (v[10] - '0') * 10 + (v[11] - '0');
-    if (tm->length >= 14 &&
-        (v[12] >= '0') && (v[12] <= '9') &&
-        (v[13] >= '0') && (v[13] <= '9')) {
-        s = (v[12] - '0') * 10 + (v[13] - '0');
-        /* Check for fractions of seconds. */
-        if (tm->length >= 15 && v[14] == '.') {
-            int l = tm->length;
-            f = &v[14];         /* The decimal point. */
-            f_len = 1;
-            while (14 + f_len < l && f[f_len] >= '0' && f[f_len] <= '9')
-                ++f_len;
-        }
+static const char *const mon[12] = {"Jan", "Feb", "Mar", "Apr", "May", "Jun",
+                                    "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"};
+
+int ASN1_GENERALIZEDTIME_print(BIO *bp, const ASN1_GENERALIZEDTIME *tm) {
+  char *v;
+  int gmt = 0;
+  int i;
+  int y = 0, M = 0, d = 0, h = 0, m = 0, s = 0;
+  char *f = NULL;
+  int f_len = 0;
+
+  i = tm->length;
+  v = (char *)tm->data;
+
+  if (i < 12) {
+    goto err;
+  }
+  if (v[i - 1] == 'Z') {
+    gmt = 1;
+  }
+  for (i = 0; i < 12; i++) {
+    if ((v[i] > '9') || (v[i] < '0')) {
+      goto err;
+    }
+  }
+  y = (v[0] - '0') * 1000 + (v[1] - '0') * 100 + (v[2] - '0') * 10 +
+      (v[3] - '0');
+  M = (v[4] - '0') * 10 + (v[5] - '0');
+  if ((M > 12) || (M < 1)) {
+    goto err;
+  }
+  d = (v[6] - '0') * 10 + (v[7] - '0');
+  h = (v[8] - '0') * 10 + (v[9] - '0');
+  m = (v[10] - '0') * 10 + (v[11] - '0');
+  if (tm->length >= 14 && (v[12] >= '0') && (v[12] <= '9') && (v[13] >= '0') &&
+      (v[13] <= '9')) {
+    s = (v[12] - '0') * 10 + (v[13] - '0');
+    // Check for fractions of seconds.
+    if (tm->length >= 15 && v[14] == '.') {
+      int l = tm->length;
+      f = &v[14];  // The decimal point.
+      f_len = 1;
+      while (14 + f_len < l && f[f_len] >= '0' && f[f_len] <= '9') {
+        ++f_len;
+      }
     }
+  }
 
-    if (BIO_printf(bp, "%s %2d %02d:%02d:%02d%.*s %d%s",
-                   mon[M - 1], d, h, m, s, f_len, f, y,
-                   (gmt) ? " GMT" : "") <= 0)
-        return (0);
-    else
-        return (1);
- err:
-    BIO_write(bp, "Bad time value", 14);
-    return (0);
+  if (BIO_printf(bp, "%s %2d %02d:%02d:%02d%.*s %d%s", mon[M - 1], d, h, m, s,
+                 f_len, f, y, (gmt) ? " GMT" : "") <= 0) {
+    return 0;
+  } else {
+    return 1;
+  }
+err:
+  BIO_write(bp, "Bad time value", 14);
+  return 0;
 }
 
 // consume_two_digits is a helper function for ASN1_UTCTIME_print. If |*v|,
 // assumed to be |*len| bytes long, has two leading digits, updates |*out| with
 // their value, updates |v| and |len|, and returns one. Otherwise, returns
 // zero.
-static int consume_two_digits(int* out, const char **v, int *len) {
+static int consume_two_digits(int *out, const char **v, int *len) {
   if (*len < 2 || !isdigit((unsigned char)((*v)[0])) ||
       !isdigit((unsigned char)((*v)[1]))) {
     return 0;
@@ -572,10 +561,8 @@ int ASN1_UTCTIME_print(BIO *bp, const ASN1_UTCTIME *tm) {
   int Y = 0, M = 0, D = 0, h = 0, m = 0, s = 0;
 
   // YYMMDDhhmm are required to be present.
-  if (!consume_two_digits(&Y, &v, &len) ||
-      !consume_two_digits(&M, &v, &len) ||
-      !consume_two_digits(&D, &v, &len) ||
-      !consume_two_digits(&h, &v, &len) ||
+  if (!consume_two_digits(&Y, &v, &len) || !consume_two_digits(&M, &v, &len) ||
+      !consume_two_digits(&D, &v, &len) || !consume_two_digits(&h, &v, &len) ||
       !consume_two_digits(&m, &v, &len)) {
     goto err;
   }