a_mbstr.c revision 296465 
1/* a_mbstr.c */
2/*
3 * Written by Dr Stephen N Henson (steve@openssl.org) for the OpenSSL project
4 * 1999.
5 */
6/* ====================================================================
7 * Copyright (c) 1999 The OpenSSL Project.  All rights reserved.
8 *
9 * Redistribution and use in source and binary forms, with or without
10 * modification, are permitted provided that the following conditions
11 * are met:
12 *
13 * 1. Redistributions of source code must retain the above copyright
14 *    notice, this list of conditions and the following disclaimer.
15 *
16 * 2. Redistributions in binary form must reproduce the above copyright
17 *    notice, this list of conditions and the following disclaimer in
18 *    the documentation and/or other materials provided with the
19 *    distribution.
20 *
21 * 3. All advertising materials mentioning features or use of this
22 *    software must display the following acknowledgment:
23 *    "This product includes software developed by the OpenSSL Project
24 *    for use in the OpenSSL Toolkit. (http://www.OpenSSL.org/)"
25 *
26 * 4. The names "OpenSSL Toolkit" and "OpenSSL Project" must not be used to
27 *    endorse or promote products derived from this software without
28 *    prior written permission. For written permission, please contact
29 *    licensing@OpenSSL.org.
30 *
31 * 5. Products derived from this software may not be called "OpenSSL"
32 *    nor may "OpenSSL" appear in their names without prior written
33 *    permission of the OpenSSL Project.
34 *
35 * 6. Redistributions of any form whatsoever must retain the following
36 *    acknowledgment:
37 *    "This product includes software developed by the OpenSSL Project
38 *    for use in the OpenSSL Toolkit (http://www.OpenSSL.org/)"
39 *
40 * THIS SOFTWARE IS PROVIDED BY THE OpenSSL PROJECT ``AS IS'' AND ANY
41 * EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
42 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
43 * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE OpenSSL PROJECT OR
44 * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
45 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
46 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
47 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
48 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
49 * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
50 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
51 * OF THE POSSIBILITY OF SUCH DAMAGE.
52 * ====================================================================
53 *
54 * This product includes cryptographic software written by Eric Young
55 * (eay@cryptsoft.com).  This product includes software written by Tim
56 * Hudson (tjh@cryptsoft.com).
57 *
58 */
59
60#include <stdio.h>
61#include <ctype.h>
62#include "cryptlib.h"
63#include <openssl/asn1.h>
64
65static int traverse_string(const unsigned char *p, int len, int inform,
66                           int (*rfunc) (unsigned long value, void *in),
67                           void *arg);
68static int in_utf8(unsigned long value, void *arg);
69static int out_utf8(unsigned long value, void *arg);
70static int type_str(unsigned long value, void *arg);
71static int cpy_asc(unsigned long value, void *arg);
72static int cpy_bmp(unsigned long value, void *arg);
73static int cpy_univ(unsigned long value, void *arg);
74static int cpy_utf8(unsigned long value, void *arg);
75static int is_printable(unsigned long value);
76
77/*
78 * These functions take a string in UTF8, ASCII or multibyte form and a mask
79 * of permissible ASN1 string types. It then works out the minimal type
80 * (using the order Printable < IA5 < T61 < BMP < Universal < UTF8) and
81 * creates a string of the correct type with the supplied data. Yes this is
82 * horrible: it has to be :-( The 'ncopy' form checks minimum and maximum
83 * size limits too.
84 */
85
86int ASN1_mbstring_copy(ASN1_STRING **out, const unsigned char *in, int len,
87                       int inform, unsigned long mask)
88{
89    return ASN1_mbstring_ncopy(out, in, len, inform, mask, 0, 0);
90}
91
92int ASN1_mbstring_ncopy(ASN1_STRING **out, const unsigned char *in, int len,
93                        int inform, unsigned long mask,
94                        long minsize, long maxsize)
95{
96    int str_type;
97    int ret;
98    char free_out;
99    int outform, outlen = 0;
100    ASN1_STRING *dest;
101    unsigned char *p;
102    int nchar;
103    char strbuf[32];
104    int (*cpyfunc) (unsigned long, void *) = NULL;
105    if (len == -1)
106        len = strlen((const char *)in);
107    if (!mask)
108        mask = DIRSTRING_TYPE;
109
110    /* First do a string check and work out the number of characters */
111    switch (inform) {
112
113    case MBSTRING_BMP:
114        if (len & 1) {
115            ASN1err(ASN1_F_ASN1_MBSTRING_NCOPY,
116                    ASN1_R_INVALID_BMPSTRING_LENGTH);
117            return -1;
118        }
119        nchar = len >> 1;
120        break;
121
122    case MBSTRING_UNIV:
123        if (len & 3) {
124            ASN1err(ASN1_F_ASN1_MBSTRING_NCOPY,
125                    ASN1_R_INVALID_UNIVERSALSTRING_LENGTH);
126            return -1;
127        }
128        nchar = len >> 2;
129        break;
130
131    case MBSTRING_UTF8:
132        nchar = 0;
133        /* This counts the characters and does utf8 syntax checking */
134        ret = traverse_string(in, len, MBSTRING_UTF8, in_utf8, &nchar);
135        if (ret < 0) {
136            ASN1err(ASN1_F_ASN1_MBSTRING_NCOPY, ASN1_R_INVALID_UTF8STRING);
137            return -1;
138        }
139        break;
140
141    case MBSTRING_ASC:
142        nchar = len;
143        break;
144
145    default:
146        ASN1err(ASN1_F_ASN1_MBSTRING_NCOPY, ASN1_R_UNKNOWN_FORMAT);
147        return -1;
148    }
149
150    if ((minsize > 0) && (nchar < minsize)) {
151        ASN1err(ASN1_F_ASN1_MBSTRING_NCOPY, ASN1_R_STRING_TOO_SHORT);
152        BIO_snprintf(strbuf, sizeof strbuf, "%ld", minsize);
153        ERR_add_error_data(2, "minsize=", strbuf);
154        return -1;
155    }
156
157    if ((maxsize > 0) && (nchar > maxsize)) {
158        ASN1err(ASN1_F_ASN1_MBSTRING_NCOPY, ASN1_R_STRING_TOO_LONG);
159        BIO_snprintf(strbuf, sizeof strbuf, "%ld", maxsize);
160        ERR_add_error_data(2, "maxsize=", strbuf);
161        return -1;
162    }
163
164    /* Now work out minimal type (if any) */
165    if (traverse_string(in, len, inform, type_str, &mask) < 0) {
166        ASN1err(ASN1_F_ASN1_MBSTRING_NCOPY, ASN1_R_ILLEGAL_CHARACTERS);
167        return -1;
168    }
169
170    /* Now work out output format and string type */
171    outform = MBSTRING_ASC;
172    if (mask & B_ASN1_PRINTABLESTRING)
173        str_type = V_ASN1_PRINTABLESTRING;
174    else if (mask & B_ASN1_IA5STRING)
175        str_type = V_ASN1_IA5STRING;
176    else if (mask & B_ASN1_T61STRING)
177        str_type = V_ASN1_T61STRING;
178    else if (mask & B_ASN1_BMPSTRING) {
179        str_type = V_ASN1_BMPSTRING;
180        outform = MBSTRING_BMP;
181    } else if (mask & B_ASN1_UNIVERSALSTRING) {
182        str_type = V_ASN1_UNIVERSALSTRING;
183        outform = MBSTRING_UNIV;
184    } else {
185        str_type = V_ASN1_UTF8STRING;
186        outform = MBSTRING_UTF8;
187    }
188    if (!out)
189        return str_type;
190    if (*out) {
191        free_out = 0;
192        dest = *out;
193        if (dest->data) {
194            dest->length = 0;
195            OPENSSL_free(dest->data);
196            dest->data = NULL;
197        }
198        dest->type = str_type;
199    } else {
200        free_out = 1;
201        dest = ASN1_STRING_type_new(str_type);
202        if (!dest) {
203            ASN1err(ASN1_F_ASN1_MBSTRING_NCOPY, ERR_R_MALLOC_FAILURE);
204            return -1;
205        }
206        *out = dest;
207    }
208    /* If both the same type just copy across */
209    if (inform == outform) {
210        if (!ASN1_STRING_set(dest, in, len)) {
211            ASN1err(ASN1_F_ASN1_MBSTRING_NCOPY, ERR_R_MALLOC_FAILURE);
212            return -1;
213        }
214        return str_type;
215    }
216
217    /* Work out how much space the destination will need */
218    switch (outform) {
219    case MBSTRING_ASC:
220        outlen = nchar;
221        cpyfunc = cpy_asc;
222        break;
223
224    case MBSTRING_BMP:
225        outlen = nchar << 1;
226        cpyfunc = cpy_bmp;
227        break;
228
229    case MBSTRING_UNIV:
230        outlen = nchar << 2;
231        cpyfunc = cpy_univ;
232        break;
233
234    case MBSTRING_UTF8:
235        outlen = 0;
236        traverse_string(in, len, inform, out_utf8, &outlen);
237        cpyfunc = cpy_utf8;
238        break;
239    }
240    if (!(p = OPENSSL_malloc(outlen + 1))) {
241        if (free_out)
242            ASN1_STRING_free(dest);
243        ASN1err(ASN1_F_ASN1_MBSTRING_NCOPY, ERR_R_MALLOC_FAILURE);
244        return -1;
245    }
246    dest->length = outlen;
247    dest->data = p;
248    p[outlen] = 0;
249    traverse_string(in, len, inform, cpyfunc, &p);
250    return str_type;
251}
252
253/*
254 * This function traverses a string and passes the value of each character to
255 * an optional function along with a void * argument.
256 */
257
258static int traverse_string(const unsigned char *p, int len, int inform,
259                           int (*rfunc) (unsigned long value, void *in),
260                           void *arg)
261{
262    unsigned long value;
263    int ret;
264    while (len) {
265        if (inform == MBSTRING_ASC) {
266            value = *p++;
267            len--;
268        } else if (inform == MBSTRING_BMP) {
269            value = *p++ << 8;
270            value |= *p++;
271            len -= 2;
272        } else if (inform == MBSTRING_UNIV) {
273            value = ((unsigned long)*p++) << 24;
274            value |= ((unsigned long)*p++) << 16;
275            value |= *p++ << 8;
276            value |= *p++;
277            len -= 4;
278        } else {
279            ret = UTF8_getc(p, len, &value);
280            if (ret < 0)
281                return -1;
282            len -= ret;
283            p += ret;
284        }
285        if (rfunc) {
286            ret = rfunc(value, arg);
287            if (ret <= 0)
288                return ret;
289        }
290    }
291    return 1;
292}
293
294/* Various utility functions for traverse_string */
295
296/* Just count number of characters */
297
298static int in_utf8(unsigned long value, void *arg)
299{
300    int *nchar;
301    nchar = arg;
302    (*nchar)++;
303    return 1;
304}
305
306/* Determine size of output as a UTF8 String */
307
308static int out_utf8(unsigned long value, void *arg)
309{
310    int *outlen;
311    outlen = arg;
312    *outlen += UTF8_putc(NULL, -1, value);
313    return 1;
314}
315
316/*
317 * Determine the "type" of a string: check each character against a supplied
318 * "mask".
319 */
320
321static int type_str(unsigned long value, void *arg)
322{
323    unsigned long types;
324    types = *((unsigned long *)arg);
325    if ((types & B_ASN1_PRINTABLESTRING) && !is_printable(value))
326        types &= ~B_ASN1_PRINTABLESTRING;
327    if ((types & B_ASN1_IA5STRING) && (value > 127))
328        types &= ~B_ASN1_IA5STRING;
329    if ((types & B_ASN1_T61STRING) && (value > 0xff))
330        types &= ~B_ASN1_T61STRING;
331    if ((types & B_ASN1_BMPSTRING) && (value > 0xffff))
332        types &= ~B_ASN1_BMPSTRING;
333    if (!types)
334        return -1;
335    *((unsigned long *)arg) = types;
336    return 1;
337}
338
339/* Copy one byte per character ASCII like strings */
340
341static int cpy_asc(unsigned long value, void *arg)
342{
343    unsigned char **p, *q;
344    p = arg;
345    q = *p;
346    *q = (unsigned char)value;
347    (*p)++;
348    return 1;
349}
350
351/* Copy two byte per character BMPStrings */
352
353static int cpy_bmp(unsigned long value, void *arg)
354{
355    unsigned char **p, *q;
356    p = arg;
357    q = *p;
358    *q++ = (unsigned char)((value >> 8) & 0xff);
359    *q = (unsigned char)(value & 0xff);
360    *p += 2;
361    return 1;
362}
363
364/* Copy four byte per character UniversalStrings */
365
366static int cpy_univ(unsigned long value, void *arg)
367{
368    unsigned char **p, *q;
369    p = arg;
370    q = *p;
371    *q++ = (unsigned char)((value >> 24) & 0xff);
372    *q++ = (unsigned char)((value >> 16) & 0xff);
373    *q++ = (unsigned char)((value >> 8) & 0xff);
374    *q = (unsigned char)(value & 0xff);
375    *p += 4;
376    return 1;
377}
378
379/* Copy to a UTF8String */
380
381static int cpy_utf8(unsigned long value, void *arg)
382{
383    unsigned char **p;
384    int ret;
385    p = arg;
386    /* We already know there is enough room so pass 0xff as the length */
387    ret = UTF8_putc(*p, 0xff, value);
388    *p += ret;
389    return 1;
390}
391
392/* Return 1 if the character is permitted in a PrintableString */
393static int is_printable(unsigned long value)
394{
395    int ch;
396    if (value > 0x7f)
397        return 0;
398    ch = (int)value;
399    /*
400     * Note: we can't use 'isalnum' because certain accented characters may
401     * count as alphanumeric in some environments.
402     */
403#ifndef CHARSET_EBCDIC
404    if ((ch >= 'a') && (ch <= 'z'))
405        return 1;
406    if ((ch >= 'A') && (ch <= 'Z'))
407        return 1;
408    if ((ch >= '0') && (ch <= '9'))
409        return 1;
410    if ((ch == ' ') || strchr("'()+,-./:=?", ch))
411        return 1;
412#else                           /* CHARSET_EBCDIC */
413    if ((ch >= os_toascii['a']) && (ch <= os_toascii['z']))
414        return 1;
415    if ((ch >= os_toascii['A']) && (ch <= os_toascii['Z']))
416        return 1;
417    if ((ch >= os_toascii['0']) && (ch <= os_toascii['9']))
418        return 1;
419    if ((ch == os_toascii[' ']) || strchr("'()+,-./:=?", os_toebcdic[ch]))
420        return 1;
421#endif                          /* CHARSET_EBCDIC */
422    return 0;
423}
424