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
16unsigned 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
45char *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 */
79unsigned 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
154static 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
181char *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
227int 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
233int 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
239PKCS12 *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
245PKCS12 *d2i_PKCS12_fp(FILE *fp, PKCS12 **p12)
246{
247    return ASN1_item_d2i_fp(ASN1_ITEM_rptr(PKCS12), fp, p12);
248}
249#endif
250