crypto/pkcs12/p12_utl.c

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