]>
Commit | Line | Data |
---|---|---|
031e5cce | 1 | /* a_mbstr.c */ |
d3819813 | 2 | /* |
031e5cce SM |
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). | |
3e575651 SL |
57 | * |
58 | */ | |
59 | ||
60 | #include <stdio.h> | |
61 | #include <ctype.h> | |
031e5cce | 62 | #include "cryptlib.h" |
3e575651 SL |
63 | #include <openssl/asn1.h> |
64 | ||
65 | static int traverse_string(const unsigned char *p, int len, int inform, | |
d3819813 MTL |
66 | int (*rfunc) (unsigned long value, void *in), |
67 | void *arg); | |
3e575651 SL |
68 | static int in_utf8(unsigned long value, void *arg); |
69 | static int out_utf8(unsigned long value, void *arg); | |
70 | static int type_str(unsigned long value, void *arg); | |
71 | static int cpy_asc(unsigned long value, void *arg); | |
72 | static int cpy_bmp(unsigned long value, void *arg); | |
73 | static int cpy_univ(unsigned long value, void *arg); | |
74 | static int cpy_utf8(unsigned long value, void *arg); | |
75 | static int is_printable(unsigned long value); | |
76 | ||
d3819813 MTL |
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 | |
031e5cce SM |
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 | |
d3819813 MTL |
82 | * horrible: it has to be :-( The 'ncopy' form checks minimum and maximum |
83 | * size limits too. | |
3e575651 SL |
84 | */ |
85 | ||
86 | int ASN1_mbstring_copy(ASN1_STRING **out, const unsigned char *in, int len, | |
d3819813 | 87 | int inform, unsigned long mask) |
3e575651 | 88 | { |
d3819813 | 89 | return ASN1_mbstring_ncopy(out, in, len, inform, mask, 0, 0); |
3e575651 SL |
90 | } |
91 | ||
92 | int ASN1_mbstring_ncopy(ASN1_STRING **out, const unsigned char *in, int len, | |
d3819813 MTL |
93 | int inform, unsigned long mask, |
94 | long minsize, long maxsize) | |
3e575651 | 95 | { |
d3819813 MTL |
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; | |
031e5cce | 172 | if (mask & B_ASN1_PRINTABLESTRING) |
d3819813 MTL |
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; | |
031e5cce SM |
193 | if (dest->data) { |
194 | dest->length = 0; | |
195 | OPENSSL_free(dest->data); | |
196 | dest->data = NULL; | |
197 | } | |
d3819813 MTL |
198 | dest->type = str_type; |
199 | } else { | |
200 | free_out = 1; | |
201 | dest = ASN1_STRING_type_new(str_type); | |
031e5cce | 202 | if (!dest) { |
d3819813 MTL |
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 | } | |
031e5cce | 240 | if (!(p = OPENSSL_malloc(outlen + 1))) { |
d3819813 MTL |
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; | |
3e575651 SL |
251 | } |
252 | ||
d3819813 MTL |
253 | /* |
254 | * This function traverses a string and passes the value of each character to | |
255 | * an optional function along with a void * argument. | |
3e575651 SL |
256 | */ |
257 | ||
258 | static int traverse_string(const unsigned char *p, int len, int inform, | |
d3819813 MTL |
259 | int (*rfunc) (unsigned long value, void *in), |
260 | void *arg) | |
3e575651 | 261 | { |
d3819813 MTL |
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; | |
3e575651 SL |
292 | } |
293 | ||
294 | /* Various utility functions for traverse_string */ | |
295 | ||
296 | /* Just count number of characters */ | |
297 | ||
298 | static int in_utf8(unsigned long value, void *arg) | |
299 | { | |
d3819813 MTL |
300 | int *nchar; |
301 | nchar = arg; | |
302 | (*nchar)++; | |
303 | return 1; | |
3e575651 SL |
304 | } |
305 | ||
306 | /* Determine size of output as a UTF8 String */ | |
307 | ||
308 | static int out_utf8(unsigned long value, void *arg) | |
309 | { | |
d3819813 MTL |
310 | int *outlen; |
311 | outlen = arg; | |
312 | *outlen += UTF8_putc(NULL, -1, value); | |
313 | return 1; | |
3e575651 SL |
314 | } |
315 | ||
d3819813 MTL |
316 | /* |
317 | * Determine the "type" of a string: check each character against a supplied | |
318 | * "mask". | |
3e575651 SL |
319 | */ |
320 | ||
321 | static int type_str(unsigned long value, void *arg) | |
322 | { | |
d3819813 MTL |
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; | |
3e575651 SL |
337 | } |
338 | ||
339 | /* Copy one byte per character ASCII like strings */ | |
340 | ||
341 | static int cpy_asc(unsigned long value, void *arg) | |
342 | { | |
d3819813 MTL |
343 | unsigned char **p, *q; |
344 | p = arg; | |
345 | q = *p; | |
346 | *q = (unsigned char)value; | |
347 | (*p)++; | |
348 | return 1; | |
3e575651 SL |
349 | } |
350 | ||
351 | /* Copy two byte per character BMPStrings */ | |
352 | ||
353 | static int cpy_bmp(unsigned long value, void *arg) | |
354 | { | |
d3819813 MTL |
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; | |
3e575651 SL |
362 | } |
363 | ||
364 | /* Copy four byte per character UniversalStrings */ | |
365 | ||
366 | static int cpy_univ(unsigned long value, void *arg) | |
367 | { | |
d3819813 MTL |
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; | |
3e575651 SL |
377 | } |
378 | ||
379 | /* Copy to a UTF8String */ | |
380 | ||
381 | static int cpy_utf8(unsigned long value, void *arg) | |
382 | { | |
d3819813 MTL |
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; | |
3e575651 SL |
390 | } |
391 | ||
392 | /* Return 1 if the character is permitted in a PrintableString */ | |
393 | static int is_printable(unsigned long value) | |
394 | { | |
d3819813 MTL |
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 | */ | |
3e575651 | 403 | #ifndef CHARSET_EBCDIC |
d3819813 MTL |
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; | |
3e575651 | 423 | } |