/* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com) * All rights reserved. * * This package is an SSL implementation written * by Eric Young (eay@cryptsoft.com). * The implementation was written so as to conform with Netscapes SSL. * * This library is free for commercial and non-commercial use as long as * the following conditions are aheared to. The following conditions * apply to all code found in this distribution, be it the RC4, RSA, * lhash, DES, etc., code; not just the SSL code. The SSL documentation * included with this distribution is covered by the same copyright terms * except that the holder is Tim Hudson (tjh@cryptsoft.com). * * Copyright remains Eric Young's, and as such any Copyright notices in * the code are not to be removed. * If this package is used in a product, Eric Young should be given attribution * as the author of the parts of the library used. * This can be in the form of a textual message at program startup or * in documentation (online or textual) provided with the package. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * 1. Redistributions of source code must retain the copyright * notice, this list of conditions and the following disclaimer. * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * 3. All advertising materials mentioning features or use of this software * must display the following acknowledgement: * "This product includes cryptographic software written by * Eric Young (eay@cryptsoft.com)" * The word 'cryptographic' can be left out if the rouines from the library * being used are not cryptographic related :-). * 4. If you include any Windows specific code (or a derivative thereof) from * the apps directory (application code) you must include an acknowledgement: * "This product includes software written by Tim Hudson (tjh@cryptsoft.com)" * * THIS SOFTWARE IS PROVIDED BY ERIC YOUNG ``AS IS'' AND * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF * SUCH DAMAGE. * * The licence and distribution terms for any publically available version or * derivative of this code cannot be changed. i.e. this code cannot simply be * copied and put under another distribution licence * [including the GNU Public Licence.] */ #include #include #include #include #include #include #include "charmap.h" #include "internal.h" // These flags must be distinct from |ESC_FLAGS| and fit in a byte. // Character is a valid PrintableString character #define CHARTYPE_PRINTABLESTRING 0x10 // Character needs escaping if it is the first character #define CHARTYPE_FIRST_ESC_2253 0x20 // Character needs escaping if it is the last character #define CHARTYPE_LAST_ESC_2253 0x40 #define CHARTYPE_BS_ESC (ASN1_STRFLGS_ESC_2253 | CHARTYPE_FIRST_ESC_2253 | CHARTYPE_LAST_ESC_2253) #define ESC_FLAGS (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; } /* * This function handles display of strings, one character at a time. It is * passed an unsigned long for each character because it could come from 2 or * even 4 byte forms. */ #define HEX_SIZE(type) (sizeof(type)*2) static int do_esc_char(uint32_t c, unsigned char flags, char *do_quotes, BIO *out) { unsigned char chflgs, chtmp; char tmphex[HEX_SIZE(uint32_t) + 3]; if (c > 0xffff) { BIO_snprintf(tmphex, sizeof tmphex, "\\W%08" PRIX32, c); if (!maybe_write(out, tmphex, 10)) return -1; return 10; } if (c > 0xff) { BIO_snprintf(tmphex, sizeof tmphex, "\\U%04" PRIX32, c); if (!maybe_write(out, tmphex, 6)) return -1; return 6; } chtmp = (unsigned char)c; if (chtmp > 0x7f) chflgs = flags & ASN1_STRFLGS_ESC_MSB; else chflgs = char_type[chtmp] & flags; if (chflgs & CHARTYPE_BS_ESC) { /* If we don't escape with quotes, signal we need quotes */ if (chflgs & ASN1_STRFLGS_ESC_QUOTE) { if (do_quotes) *do_quotes = 1; if (!maybe_write(out, &chtmp, 1)) return -1; return 1; } if (!maybe_write(out, "\\", 1)) return -1; if (!maybe_write(out, &chtmp, 1)) return -1; return 2; } if (chflgs & (ASN1_STRFLGS_ESC_CTRL | ASN1_STRFLGS_ESC_MSB)) { BIO_snprintf(tmphex, 11, "\\%02X", chtmp); if (!maybe_write(out, tmphex, 3)) return -1; return 3; } /* * If we get this far and do any escaping at all must escape the escape * character itself: backslash. */ if (chtmp == '\\' && flags & ESC_FLAGS) { if (!maybe_write(out, "\\\\", 2)) return -1; return 2; } if (!maybe_write(out, &chtmp, 1)) return -1; return 1; } #define BUF_TYPE_WIDTH_MASK 0x7 #define BUF_TYPE_CONVUTF8 0x8 /* * 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(unsigned char *buf, int buflen, int type, unsigned char flags, char *quotes, BIO *out) { int i, outlen, len, charwidth; unsigned char orflags, *p, *q; uint32_t c; p = buf; q = buf + buflen; outlen = 0; charwidth = type & BUF_TYPE_WIDTH_MASK; switch (charwidth) { case 4: if (buflen & 3) { OPENSSL_PUT_ERROR(ASN1, ASN1_R_INVALID_UNIVERSALSTRING); return -1; } break; case 2: if (buflen & 1) { OPENSSL_PUT_ERROR(ASN1, ASN1_R_INVALID_BMPSTRING); return -1; } break; default: break; } while (p != q) { if (p == buf && flags & ASN1_STRFLGS_ESC_2253) orflags = CHARTYPE_FIRST_ESC_2253; else orflags = 0; /* TODO(davidben): Replace this with |cbs_get_ucs2_be|, etc., to check * for invalid codepoints. */ switch (charwidth) { case 4: c = ((uint32_t)*p++) << 24; c |= ((uint32_t)*p++) << 16; c |= ((uint32_t)*p++) << 8; c |= *p++; break; case 2: c = ((uint32_t)*p++) << 8; c |= *p++; break; case 1: c = *p++; break; case 0: i = UTF8_getc(p, buflen, &c); if (i < 0) return -1; /* Invalid UTF8String */ buflen -= i; p += i; break; default: return -1; /* invalid width */ } if (p == q && flags & ASN1_STRFLGS_ESC_2253) orflags = CHARTYPE_LAST_ESC_2253; if (type & BUF_TYPE_CONVUTF8) { unsigned char utfbuf[6]; int utflen; utflen = UTF8_putc(utfbuf, sizeof utfbuf, c); for (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. */ len = do_esc_char(utfbuf[i], (unsigned char)(flags | orflags), quotes, out); if (len < 0) return -1; outlen += len; } } else { len = do_esc_char(c, (unsigned char)(flags | orflags), quotes, out); if (len < 0) return -1; outlen += len; } } return outlen; } /* 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++; } } return buflen << 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. */ static int do_dump(unsigned long lflags, 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 (!(lflags & ASN1_STRFLGS_DUMP_DER)) { int outlen = do_hex_dump(out, str->data, str->length); if (outlen < 0) { 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; } /* * Lookup table to convert tags to character widths, 0 = UTF8 encoded, -1 is * used for non string types otherwise it is the number of bytes per * character */ static const signed char tag2nbyte[] = { -1, -1, -1, -1, -1, /* 0-4 */ -1, -1, -1, -1, -1, /* 5-9 */ -1, -1, 0, -1, /* 10-13 */ -1, -1, -1, -1, /* 15-17 */ 1, 1, 1, /* 18-20 */ -1, 1, 1, 1, /* 21-24 */ -1, 1, -1, /* 25-27 */ 4, -1, 2 /* 28-30 */ }; /* * 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 lflags) { int outlen, len; int type; char quotes; unsigned char flags; quotes = 0; /* Keep a copy of escape flags */ flags = (unsigned char)(lflags & ESC_FLAGS); type = str->type; outlen = 0; if (lflags & ASN1_STRFLGS_SHOW_TYPE) { const char *tagname; 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 type, either dump content or display it */ /* Dump everything */ if (lflags & ASN1_STRFLGS_DUMP_ALL) type = -1; /* Ignore the string type */ else if (lflags & ASN1_STRFLGS_IGNORE_TYPE) type = 1; else { /* Else determine width based on type */ if ((type > 0) && (type < 31)) type = tag2nbyte[type]; else type = -1; if ((type == -1) && !(lflags & ASN1_STRFLGS_DUMP_UNKNOWN)) type = 1; } if (type == -1) { len = do_dump(lflags, out, str); if (len < 0) return -1; outlen += len; return outlen; } if (lflags & ASN1_STRFLGS_UTF8_CONVERT) { /* * Note: if string is UTF8 and we want to convert to UTF8 then we * just interpret it as 1 byte per character to avoid converting * twice. */ if (!type) type = 1; else type |= BUF_TYPE_CONVUTF8; } len = do_buf(str->data, str->length, type, flags, "es, NULL); if (len < 0) return -1; outlen += len; if (quotes) outlen += 2; if (!out) return outlen; if (quotes && !maybe_write(out, "\"", 1)) return -1; if (do_buf(str->data, str->length, type, flags, NULL, out) < 0) return -1; if (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; } } 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) { ASN1_STRING stmp, *str = &stmp; int mbflag, type, ret; if (!in) return -1; type = in->type; if ((type < 0) || (type > 30)) return -1; mbflag = tag2nbyte[type]; if (mbflag == -1) return -1; mbflag |= MBSTRING_FLAG; stmp.data = NULL; stmp.length = 0; stmp.flags = 0; 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; } } 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); } 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); } // 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) { if (*len < 2|| !isdigit((*v)[0]) || !isdigit((*v)[1])) { return 0; } *out = ((*v)[0] - '0') * 10 + ((*v)[1] - '0'); *len -= 2; *v += 2; return 1; } // consume_zulu_timezone is a helper function for ASN1_UTCTIME_print. If |*v|, // assumed to be |*len| bytes long, starts with "Z" then it updates |*v| and // |*len| and returns one. Otherwise returns zero. static int consume_zulu_timezone(const char **v, int *len) { if (*len == 0 || (*v)[0] != 'Z') { return 0; } *len -= 1; *v += 1; return 1; } int ASN1_UTCTIME_print(BIO *bp, const ASN1_UTCTIME *tm) { const char *v = (const char *)tm->data; int len = tm->length; 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) || !consume_two_digits(&m, &v, &len)) { goto err; } // https://tools.ietf.org/html/rfc5280, section 4.1.2.5.1, requires seconds // to be present, but historically this code has forgiven its absence. consume_two_digits(&s, &v, &len); // https://tools.ietf.org/html/rfc5280, section 4.1.2.5.1, specifies this // interpretation of the year. if (Y < 50) { Y += 2000; } else { Y += 1900; } if (M > 12 || M == 0) { goto err; } if (D > 31 || D == 0) { goto err; } if (h > 23 || m > 59 || s > 60) { goto err; } // https://tools.ietf.org/html/rfc5280, section 4.1.2.5.1, requires the "Z" // to be present, but historically this code has forgiven its absence. const int is_gmt = consume_zulu_timezone(&v, &len); // https://tools.ietf.org/html/rfc5280, section 4.1.2.5.1, does not permit // the specification of timezones using the +hhmm / -hhmm syntax, which is // the only other thing that might legitimately be found at the end. if (len) { goto err; } return BIO_printf(bp, "%s %2d %02d:%02d:%02d %d%s", mon[M - 1], D, h, m, s, Y, is_gmt ? " GMT" : "") > 0; err: BIO_write(bp, "Bad time value", 14); return 0; }