crypto/pkcs12/p12_utl.c

   1 /*
   2  * Copyright 1999-2021 The OpenSSL Project Authors. All Rights Reserved.
   3  *
   4  * Licensed under the Apache License 2.0 (the "License").  You may not use
   5  * this file except in compliance with the License.  You can obtain a copy
   6  * in the file LICENSE in the source distribution or at
   7  * https://www.openssl.org/source/license.html
   8  */
   9
  10 #include <stdio.h>
  11 #include "internal/cryptlib.h"
  12 #include <openssl/pkcs12.h>
  13
  14 /* Cheap and nasty Unicode stuff */
  15
  16 unsigned char *OPENSSL_asc2uni(const char *asc, int asclen,
  17                                unsigned char **uni, int *unilen)
  18 {
  19     int ulen, i;
  20     unsigned char *unitmp;
  21
  22     if (asclen == -1)
  23         asclen = strlen(asc);
  24     if (asclen < 0)
  25         return NULL;
  26     ulen = asclen * 2 + 2;
  27     if ((unitmp = OPENSSL_malloc(ulen)) == NULL) {
  28         ERR_raise(ERR_LIB_PKCS12, ERR_R_MALLOC_FAILURE);
  29         return NULL;
  30     }
  31     for (i = 0; i < ulen - 2; i += 2) {
  32         unitmp[i] = 0;
  33         unitmp[i + 1] = asc[i >> 1];
  34     }
  35     /* Make result double null terminated */
  36     unitmp[ulen - 2] = 0;
  37     unitmp[ulen - 1] = 0;
  38     if (unilen)
  39         *unilen = ulen;
  40     if (uni)
  41         *uni = unitmp;
  42     return unitmp;
  43 }
  44
  45 char *OPENSSL_uni2asc(const unsigned char *uni, int unilen)
  46 {
  47     int asclen, i;
  48     char *asctmp;
  49
  50     /* string must contain an even number of bytes */
  51     if (unilen & 1)
  52         return NULL;
  53     if (unilen < 0)
  54         return NULL;
  55     asclen = unilen / 2;
  56     /* If no terminating zero allow for one */
  57     if (!unilen || uni[unilen - 1])
  58         asclen++;
  59     uni++;
  60     if ((asctmp = OPENSSL_malloc(asclen)) == NULL) {
  61         ERR_raise(ERR_LIB_PKCS12, ERR_R_MALLOC_FAILURE);
  62         return NULL;
  63     }
  64     for (i = 0; i < unilen; i += 2)
  65         asctmp[i >> 1] = uni[i];
  66     asctmp[asclen - 1] = 0;
  67     return asctmp;
  68 }
  69
  70 /*
  71  * OPENSSL_{utf82uni|uni2utf8} perform conversion between UTF-8 and
  72  * PKCS#12 BMPString format, which is specified as big-endian UTF-16.
  73  * One should keep in mind that even though BMPString is passed as
  74  * unsigned char *, it's not the kind of string you can exercise e.g.
  75  * strlen on. Caller also has to keep in mind that its length is
  76  * expressed not in number of UTF-16 characters, but in number of
  77  * bytes the string occupies, and treat it, the length, accordingly.
  78  */
  79 unsigned char *OPENSSL_utf82uni(const char *asc, int asclen,
  80                                 unsigned char **uni, int *unilen)
  81 {
  82     int ulen, i, j;
  83     unsigned char *unitmp, *ret;
  84     unsigned long utf32chr = 0;
  85
  86     if (asclen == -1)
  87         asclen = strlen(asc);
  88
  89     for (ulen = 0, i = 0; i < asclen; i += j) {
  90         j = UTF8_getc((const unsigned char *)asc+i, asclen-i, &utf32chr);
  91
  92         /*
  93          * Following condition is somewhat opportunistic is sense that
  94          * decoding failure is used as *indirect* indication that input
  95          * string might in fact be extended ASCII/ANSI/ISO-8859-X. The
  96          * fallback is taken in hope that it would allow to process
  97          * files created with previous OpenSSL version, which used the
  98          * naive OPENSSL_asc2uni all along. It might be worth noting
  99          * that probability of false positive depends on language. In
 100          * cases covered by ISO Latin 1 probability is very low, because
 101          * any printable non-ASCII alphabet letter followed by another
 102          * or any ASCII character will trigger failure and fallback.
 103          * In other cases situation can be intensified by the fact that
 104          * English letters are not part of alternative keyboard layout,
 105          * but even then there should be plenty of pairs that trigger
 106          * decoding failure...
 107          */
 108         if (j < 0)
 109             return OPENSSL_asc2uni(asc, asclen, uni, unilen);
 110
 111         if (utf32chr > 0x10FFFF)        /* UTF-16 cap */
 112             return NULL;
 113
 114         if (utf32chr >= 0x10000)        /* pair of UTF-16 characters */
 115             ulen += 2*2;
 116         else                            /* or just one */
 117             ulen += 2;
 118     }
 119
 120     ulen += 2;  /* for trailing UTF16 zero */
 121
 122     if ((ret = OPENSSL_malloc(ulen)) == NULL) {
 123         ERR_raise(ERR_LIB_PKCS12, ERR_R_MALLOC_FAILURE);
 124         return NULL;
 125     }
 126     /* re-run the loop writing down UTF-16 characters in big-endian order */
 127     for (unitmp = ret, i = 0; i < asclen; i += j) {
 128         j = UTF8_getc((const unsigned char *)asc+i, asclen-i, &utf32chr);
 129         if (utf32chr >= 0x10000) {      /* pair if UTF-16 characters */
 130             unsigned int hi, lo;
 131
 132             utf32chr -= 0x10000;
 133             hi = 0xD800 + (utf32chr>>10);
 134             lo = 0xDC00 + (utf32chr&0x3ff);
 135             *unitmp++ = (unsigned char)(hi>>8);
 136             *unitmp++ = (unsigned char)(hi);
 137             *unitmp++ = (unsigned char)(lo>>8);
 138             *unitmp++ = (unsigned char)(lo);
 139         } else {                        /* or just one */
 140             *unitmp++ = (unsigned char)(utf32chr>>8);
 141             *unitmp++ = (unsigned char)(utf32chr);
 142         }
 143     }
 144     /* Make result double null terminated */
 145     *unitmp++ = 0;
 146     *unitmp++ = 0;
 147     if (unilen)
 148         *unilen = ulen;
 149     if (uni)
 150         *uni = ret;
 151     return ret;
 152 }
 153
 154 static int bmp_to_utf8(char *str, const unsigned char *utf16, int len)
 155 {
 156     unsigned long utf32chr;
 157
 158     if (len == 0) return 0;
 159
 160     if (len < 2) return -1;
 161
 162     /* pull UTF-16 character in big-endian order */
 163     utf32chr = (utf16[0]<<8) | utf16[1];
 164
 165     if (utf32chr >= 0xD800 && utf32chr < 0xE000) {   /* two chars */
 166         unsigned int lo;
 167
 168         if (len < 4) return -1;
 169
 170         utf32chr -= 0xD800;
 171         utf32chr <<= 10;
 172         lo = (utf16[2]<<8) | utf16[3];
 173         if (lo < 0xDC00 || lo >= 0xE000) return -1;
 174         utf32chr |= lo-0xDC00;
 175         utf32chr += 0x10000;
 176     }
 177
 178     return UTF8_putc((unsigned char *)str, len > 4 ? 4 : len, utf32chr);
 179 }
 180
 181 char *OPENSSL_uni2utf8(const unsigned char *uni, int unilen)
 182 {
 183     int asclen, i, j;
 184     char *asctmp;
 185
 186     /* string must contain an even number of bytes */
 187     if (unilen & 1)
 188         return NULL;
 189
 190     for (asclen = 0, i = 0; i < unilen; ) {
 191         j = bmp_to_utf8(NULL, uni+i, unilen-i);
 192         /*
 193          * falling back to OPENSSL_uni2asc makes lesser sense [than
 194          * falling back to OPENSSL_asc2uni in OPENSSL_utf82uni above],
 195          * it's done rather to maintain symmetry...
 196          */
 197         if (j < 0) return OPENSSL_uni2asc(uni, unilen);
 198         if (j == 4) i += 4;
 199         else        i += 2;
 200         asclen += j;
 201     }
 202
 203     /* If no terminating zero allow for one */
 204     if (!unilen || (uni[unilen-2]||uni[unilen - 1]))
 205         asclen++;
 206
 207     if ((asctmp = OPENSSL_malloc(asclen)) == NULL) {
 208         ERR_raise(ERR_LIB_PKCS12, ERR_R_MALLOC_FAILURE);
 209         return NULL;
 210     }
 211
 212     /* re-run the loop emitting UTF-8 string */
 213     for (asclen = 0, i = 0; i < unilen; ) {
 214         j = bmp_to_utf8(asctmp+asclen, uni+i, unilen-i);
 215         if (j == 4) i += 4;
 216         else        i += 2;
 217         asclen += j;
 218     }
 219
 220     /* If no terminating zero write one */
 221     if (!unilen || (uni[unilen-2]||uni[unilen - 1]))
 222         asctmp[asclen] = '\0';
 223
 224     return asctmp;
 225 }
 226
 227 int i2d_PKCS12_bio(BIO *bp, const PKCS12 *p12)
 228 {
 229     return ASN1_item_i2d_bio(ASN1_ITEM_rptr(PKCS12), bp, p12);
 230 }
 231
 232 #ifndef OPENSSL_NO_STDIO
 233 int i2d_PKCS12_fp(FILE *fp, const PKCS12 *p12)
 234 {
 235     return ASN1_item_i2d_fp(ASN1_ITEM_rptr(PKCS12), fp, p12);
 236 }
 237 #endif
 238
 239 PKCS12 *d2i_PKCS12_bio(BIO *bp, PKCS12 **p12)
 240 {
 241     return ASN1_item_d2i_bio(ASN1_ITEM_rptr(PKCS12), bp, p12);
 242 }
 243
 244 #ifndef OPENSSL_NO_STDIO
 245 PKCS12 *d2i_PKCS12_fp(FILE *fp, PKCS12 **p12)
 246 {
 247     return ASN1_item_d2i_fp(ASN1_ITEM_rptr(PKCS12), fp, p12);
 248 }
 249 #endif