Branch data Line data Source code
1 : : /* v3_utl.c */
2 : : /* Written by Dr Stephen N Henson (steve@openssl.org) for the OpenSSL
3 : : * project.
4 : : */
5 : : /* ====================================================================
6 : : * Copyright (c) 1999-2003 The OpenSSL Project. All rights reserved.
7 : : *
8 : : * Redistribution and use in source and binary forms, with or without
9 : : * modification, are permitted provided that the following conditions
10 : : * are met:
11 : : *
12 : : * 1. Redistributions of source code must retain the above copyright
13 : : * notice, this list of conditions and the following disclaimer.
14 : : *
15 : : * 2. Redistributions in binary form must reproduce the above copyright
16 : : * notice, this list of conditions and the following disclaimer in
17 : : * the documentation and/or other materials provided with the
18 : : * distribution.
19 : : *
20 : : * 3. All advertising materials mentioning features or use of this
21 : : * software must display the following acknowledgment:
22 : : * "This product includes software developed by the OpenSSL Project
23 : : * for use in the OpenSSL Toolkit. (http://www.OpenSSL.org/)"
24 : : *
25 : : * 4. The names "OpenSSL Toolkit" and "OpenSSL Project" must not be used to
26 : : * endorse or promote products derived from this software without
27 : : * prior written permission. For written permission, please contact
28 : : * licensing@OpenSSL.org.
29 : : *
30 : : * 5. Products derived from this software may not be called "OpenSSL"
31 : : * nor may "OpenSSL" appear in their names without prior written
32 : : * permission of the OpenSSL Project.
33 : : *
34 : : * 6. Redistributions of any form whatsoever must retain the following
35 : : * acknowledgment:
36 : : * "This product includes software developed by the OpenSSL Project
37 : : * for use in the OpenSSL Toolkit (http://www.OpenSSL.org/)"
38 : : *
39 : : * THIS SOFTWARE IS PROVIDED BY THE OpenSSL PROJECT ``AS IS'' AND ANY
40 : : * EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
41 : : * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
42 : : * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE OpenSSL PROJECT OR
43 : : * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
44 : : * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
45 : : * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
46 : : * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
47 : : * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
48 : : * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
49 : : * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
50 : : * OF THE POSSIBILITY OF SUCH DAMAGE.
51 : : * ====================================================================
52 : : *
53 : : * This product includes cryptographic software written by Eric Young
54 : : * (eay@cryptsoft.com). This product includes software written by Tim
55 : : * Hudson (tjh@cryptsoft.com).
56 : : *
57 : : */
58 : : /* X509 v3 extension utilities */
59 : :
60 : :
61 : : #include <stdio.h>
62 : : #include <ctype.h>
63 : : #include "cryptlib.h"
64 : : #include <openssl/conf.h>
65 : : #include <openssl/x509v3.h>
66 : : #include <openssl/bn.h>
67 : :
68 : : static char *strip_spaces(char *name);
69 : : static int sk_strcmp(const char * const *a, const char * const *b);
70 : : static STACK_OF(OPENSSL_STRING) *get_email(X509_NAME *name, GENERAL_NAMES *gens);
71 : : static void str_free(OPENSSL_STRING str);
72 : : static int append_ia5(STACK_OF(OPENSSL_STRING) **sk, ASN1_IA5STRING *email);
73 : :
74 : : static int ipv4_from_asc(unsigned char *v4, const char *in);
75 : : static int ipv6_from_asc(unsigned char *v6, const char *in);
76 : : static int ipv6_cb(const char *elem, int len, void *usr);
77 : : static int ipv6_hex(unsigned char *out, const char *in, int inlen);
78 : :
79 : : /* Add a CONF_VALUE name value pair to stack */
80 : :
81 : 350 : int X509V3_add_value(const char *name, const char *value,
82 : : STACK_OF(CONF_VALUE) **extlist)
83 : : {
84 : 350 : CONF_VALUE *vtmp = NULL;
85 : 350 : char *tname = NULL, *tvalue = NULL;
86 [ + - ][ + - ]: 350 : if(name && !(tname = BUF_strdup(name))) goto err;
87 [ + + ][ + - ]: 350 : if(value && !(tvalue = BUF_strdup(value))) goto err;
88 [ + - ]: 350 : if(!(vtmp = (CONF_VALUE *)OPENSSL_malloc(sizeof(CONF_VALUE)))) goto err;
89 [ + + ][ + - ]: 350 : if(!*extlist && !(*extlist = sk_CONF_VALUE_new_null())) goto err;
90 : 350 : vtmp->section = NULL;
91 : 350 : vtmp->name = tname;
92 : 350 : vtmp->value = tvalue;
93 [ - + ]: 350 : if(!sk_CONF_VALUE_push(*extlist, vtmp)) goto err;
94 : : return 1;
95 : : err:
96 : 0 : X509V3err(X509V3_F_X509V3_ADD_VALUE,ERR_R_MALLOC_FAILURE);
97 [ # # ]: 0 : if(vtmp) OPENSSL_free(vtmp);
98 [ # # ]: 0 : if(tname) OPENSSL_free(tname);
99 [ # # ]: 0 : if(tvalue) OPENSSL_free(tvalue);
100 : : return 0;
101 : : }
102 : :
103 : 0 : int X509V3_add_value_uchar(const char *name, const unsigned char *value,
104 : : STACK_OF(CONF_VALUE) **extlist)
105 : : {
106 : 0 : return X509V3_add_value(name,(const char *)value,extlist);
107 : : }
108 : :
109 : : /* Free function for STACK_OF(CONF_VALUE) */
110 : :
111 : 350 : void X509V3_conf_free(CONF_VALUE *conf)
112 : : {
113 [ + - ]: 350 : if(!conf) return;
114 [ + - ]: 350 : if(conf->name) OPENSSL_free(conf->name);
115 [ + + ]: 350 : if(conf->value) OPENSSL_free(conf->value);
116 [ - + ]: 350 : if(conf->section) OPENSSL_free(conf->section);
117 : 350 : OPENSSL_free(conf);
118 : : }
119 : :
120 : 39 : int X509V3_add_value_bool(const char *name, int asn1_bool,
121 : : STACK_OF(CONF_VALUE) **extlist)
122 : : {
123 [ + + ]: 39 : if(asn1_bool) return X509V3_add_value(name, "TRUE", extlist);
124 : 36 : return X509V3_add_value(name, "FALSE", extlist);
125 : : }
126 : :
127 : 0 : int X509V3_add_value_bool_nf(char *name, int asn1_bool,
128 : : STACK_OF(CONF_VALUE) **extlist)
129 : : {
130 [ # # ]: 0 : if(asn1_bool) return X509V3_add_value(name, "TRUE", extlist);
131 : : return 1;
132 : : }
133 : :
134 : :
135 : 0 : char *i2s_ASN1_ENUMERATED(X509V3_EXT_METHOD *method, ASN1_ENUMERATED *a)
136 : : {
137 : 0 : BIGNUM *bntmp = NULL;
138 : 0 : char *strtmp = NULL;
139 [ # # ]: 0 : if(!a) return NULL;
140 [ # # ][ # # ]: 0 : if(!(bntmp = ASN1_ENUMERATED_to_BN(a, NULL)) ||
141 : : !(strtmp = BN_bn2dec(bntmp)) )
142 : 0 : X509V3err(X509V3_F_I2S_ASN1_ENUMERATED,ERR_R_MALLOC_FAILURE);
143 : 0 : BN_free(bntmp);
144 : 0 : return strtmp;
145 : : }
146 : :
147 : 3 : char *i2s_ASN1_INTEGER(X509V3_EXT_METHOD *method, ASN1_INTEGER *a)
148 : : {
149 : 3 : BIGNUM *bntmp = NULL;
150 : 3 : char *strtmp = NULL;
151 [ + - ]: 3 : if(!a) return NULL;
152 [ + - ][ - + ]: 3 : if(!(bntmp = ASN1_INTEGER_to_BN(a, NULL)) ||
153 : : !(strtmp = BN_bn2dec(bntmp)) )
154 : 0 : X509V3err(X509V3_F_I2S_ASN1_INTEGER,ERR_R_MALLOC_FAILURE);
155 : 3 : BN_free(bntmp);
156 : 3 : return strtmp;
157 : : }
158 : :
159 : 8 : ASN1_INTEGER *s2i_ASN1_INTEGER(X509V3_EXT_METHOD *method, char *value)
160 : : {
161 : 8 : BIGNUM *bn = NULL;
162 : : ASN1_INTEGER *aint;
163 : : int isneg, ishex;
164 : : int ret;
165 [ - + ]: 8 : if (!value) {
166 : 0 : X509V3err(X509V3_F_S2I_ASN1_INTEGER,X509V3_R_INVALID_NULL_VALUE);
167 : 0 : return 0;
168 : : }
169 : 8 : bn = BN_new();
170 [ - + ]: 8 : if (value[0] == '-') {
171 : 0 : value++;
172 : 0 : isneg = 1;
173 : : } else isneg = 0;
174 : :
175 [ + + ][ - + ]: 8 : if (value[0] == '0' && ((value[1] == 'x') || (value[1] == 'X'))) {
176 : 0 : value += 2;
177 : 0 : ishex = 1;
178 : : } else ishex = 0;
179 : :
180 [ - + ]: 8 : if (ishex) ret = BN_hex2bn(&bn, value);
181 : 8 : else ret = BN_dec2bn(&bn, value);
182 : :
183 [ + - ][ - + ]: 8 : if (!ret || value[ret]) {
184 : 0 : BN_free(bn);
185 : 0 : X509V3err(X509V3_F_S2I_ASN1_INTEGER,X509V3_R_BN_DEC2BN_ERROR);
186 : 0 : return 0;
187 : : }
188 : :
189 [ - + ][ # # ]: 8 : if (isneg && BN_is_zero(bn)) isneg = 0;
190 : :
191 : 8 : aint = BN_to_ASN1_INTEGER(bn, NULL);
192 : 8 : BN_free(bn);
193 [ - + ]: 8 : if (!aint) {
194 : 0 : X509V3err(X509V3_F_S2I_ASN1_INTEGER,X509V3_R_BN_TO_ASN1_INTEGER_ERROR);
195 : 0 : return 0;
196 : : }
197 [ - + ]: 8 : if (isneg) aint->type |= V_ASN1_NEG;
198 : 8 : return aint;
199 : : }
200 : :
201 : 39 : int X509V3_add_value_int(const char *name, ASN1_INTEGER *aint,
202 : : STACK_OF(CONF_VALUE) **extlist)
203 : : {
204 : : char *strtmp;
205 : : int ret;
206 [ + + ]: 39 : if(!aint) return 1;
207 [ + - ]: 3 : if(!(strtmp = i2s_ASN1_INTEGER(NULL, aint))) return 0;
208 : 3 : ret = X509V3_add_value(name, strtmp, extlist);
209 : 3 : OPENSSL_free(strtmp);
210 : 3 : return ret;
211 : : }
212 : :
213 : 36 : int X509V3_get_value_bool(CONF_VALUE *value, int *asn1_bool)
214 : : {
215 : : char *btmp;
216 [ + - ]: 36 : if(!(btmp = value->value)) goto err;
217 [ + - ][ + + ]: 36 : if(!strcmp(btmp, "TRUE") || !strcmp(btmp, "true")
218 [ + - ][ + - ]: 12 : || !strcmp(btmp, "Y") || !strcmp(btmp, "y")
219 [ + - ][ - + ]: 12 : || !strcmp(btmp, "YES") || !strcmp(btmp, "yes")) {
220 : 24 : *asn1_bool = 0xff;
221 : 24 : return 1;
222 [ + + ][ - + ]: 12 : } else if(!strcmp(btmp, "FALSE") || !strcmp(btmp, "false")
223 [ # # ][ # # ]: 0 : || !strcmp(btmp, "N") || !strcmp(btmp, "n")
224 [ # # ][ # # ]: 0 : || !strcmp(btmp, "NO") || !strcmp(btmp, "no")) {
225 : 12 : *asn1_bool = 0;
226 : 12 : return 1;
227 : : }
228 : : err:
229 : 0 : X509V3err(X509V3_F_X509V3_GET_VALUE_BOOL,X509V3_R_INVALID_BOOLEAN_STRING);
230 : 0 : X509V3_conf_err(value);
231 : 0 : return 0;
232 : : }
233 : :
234 : 8 : int X509V3_get_value_int(CONF_VALUE *value, ASN1_INTEGER **aint)
235 : : {
236 : : ASN1_INTEGER *itmp;
237 [ - + ]: 8 : if(!(itmp = s2i_ASN1_INTEGER(NULL, value->value))) {
238 : 0 : X509V3_conf_err(value);
239 : 0 : return 0;
240 : : }
241 : 8 : *aint = itmp;
242 : 8 : return 1;
243 : : }
244 : :
245 : : #define HDR_NAME 1
246 : : #define HDR_VALUE 2
247 : :
248 : : /*#define DEBUG*/
249 : :
250 : 111 : STACK_OF(CONF_VALUE) *X509V3_parse_list(const char *line)
251 : : {
252 : : char *p, *q, c;
253 : : char *ntmp, *vtmp;
254 : 111 : STACK_OF(CONF_VALUE) *values = NULL;
255 : : char *linebuf;
256 : : int state;
257 : : /* We are going to modify the line so copy it first */
258 : 111 : linebuf = BUF_strdup(line);
259 : 111 : state = HDR_NAME;
260 : 111 : ntmp = NULL;
261 : : /* Go through all characters */
262 [ + + ][ + - ]: 1988 : for(p = linebuf, q = linebuf; (c = *p) && (c!='\r') && (c!='\n'); p++) {
263 : :
264 [ + + - ]: 1877 : switch(state) {
265 : : case HDR_NAME:
266 [ + + ]: 1330 : if(c == ':') {
267 : 103 : state = HDR_VALUE;
268 : 103 : *p = 0;
269 : 103 : ntmp = strip_spaces(q);
270 [ - + ]: 103 : if(!ntmp) {
271 : 0 : X509V3err(X509V3_F_X509V3_PARSE_LIST, X509V3_R_INVALID_NULL_NAME);
272 : 0 : goto err;
273 : : }
274 : 103 : q = p + 1;
275 [ + + ]: 1227 : } else if(c == ',') {
276 : 34 : *p = 0;
277 : 34 : ntmp = strip_spaces(q);
278 : 34 : q = p + 1;
279 : : #if 0
280 : : printf("%s\n", ntmp);
281 : : #endif
282 [ - + ]: 34 : if(!ntmp) {
283 : 0 : X509V3err(X509V3_F_X509V3_PARSE_LIST, X509V3_R_INVALID_NULL_NAME);
284 : 0 : goto err;
285 : : }
286 : 34 : X509V3_add_value(ntmp, NULL, &values);
287 : : }
288 : : break ;
289 : :
290 : : case HDR_VALUE:
291 [ + + ]: 547 : if(c == ',') {
292 : 38 : state = HDR_NAME;
293 : 38 : *p = 0;
294 : 38 : vtmp = strip_spaces(q);
295 : : #if 0
296 : : printf("%s\n", ntmp);
297 : : #endif
298 [ - + ]: 38 : if(!vtmp) {
299 : 0 : X509V3err(X509V3_F_X509V3_PARSE_LIST, X509V3_R_INVALID_NULL_VALUE);
300 : 0 : goto err;
301 : : }
302 : 38 : X509V3_add_value(ntmp, vtmp, &values);
303 : 38 : ntmp = NULL;
304 : 38 : q = p + 1;
305 : : }
306 : :
307 : : }
308 : : }
309 : :
310 [ + + ]: 111 : if(state == HDR_VALUE) {
311 : 65 : vtmp = strip_spaces(q);
312 : : #if 0
313 : : printf("%s=%s\n", ntmp, vtmp);
314 : : #endif
315 [ - + ]: 65 : if(!vtmp) {
316 : 0 : X509V3err(X509V3_F_X509V3_PARSE_LIST, X509V3_R_INVALID_NULL_VALUE);
317 : 0 : goto err;
318 : : }
319 : 65 : X509V3_add_value(ntmp, vtmp, &values);
320 : : } else {
321 : 46 : ntmp = strip_spaces(q);
322 : : #if 0
323 : : printf("%s\n", ntmp);
324 : : #endif
325 [ - + ]: 46 : if(!ntmp) {
326 : 0 : X509V3err(X509V3_F_X509V3_PARSE_LIST, X509V3_R_INVALID_NULL_NAME);
327 : 0 : goto err;
328 : : }
329 : 46 : X509V3_add_value(ntmp, NULL, &values);
330 : : }
331 : 111 : OPENSSL_free(linebuf);
332 : 111 : return values;
333 : :
334 : : err:
335 : 0 : OPENSSL_free(linebuf);
336 : 0 : sk_CONF_VALUE_pop_free(values, X509V3_conf_free);
337 : 0 : return NULL;
338 : :
339 : : }
340 : :
341 : : /* Delete leading and trailing spaces from a string */
342 : 286 : static char *strip_spaces(char *name)
343 : : {
344 : : char *p, *q;
345 : : /* Skip over leading spaces */
346 : 286 : p = name;
347 [ + - ][ + + ]: 314 : while(*p && isspace((unsigned char)*p)) p++;
348 [ + - ]: 286 : if(!*p) return NULL;
349 : 286 : q = p + strlen(p) - 1;
350 [ + + ][ - + ]: 286 : while((q != p) && isspace((unsigned char)*q)) q--;
351 [ + + ]: 286 : if(p != q) q[1] = 0;
352 [ + - ]: 286 : if(!*p) return NULL;
353 : 286 : return p;
354 : : }
355 : :
356 : : /* hex string utilities */
357 : :
358 : : /* Given a buffer of length 'len' return a OPENSSL_malloc'ed string with its
359 : : * hex representation
360 : : * @@@ (Contents of buffer are always kept in ASCII, also on EBCDIC machines)
361 : : */
362 : :
363 : 114 : char *hex_to_string(const unsigned char *buffer, long len)
364 : : {
365 : : char *tmp, *q;
366 : : const unsigned char *p;
367 : : int i;
368 : : const static char hexdig[] = "0123456789ABCDEF";
369 [ + - ]: 114 : if(!buffer || !len) return NULL;
370 [ + - ]: 114 : if(!(tmp = OPENSSL_malloc(len * 3 + 1))) {
371 : 0 : X509V3err(X509V3_F_HEX_TO_STRING,ERR_R_MALLOC_FAILURE);
372 : 0 : return NULL;
373 : : }
374 : : q = tmp;
375 [ + + ]: 1962 : for(i = 0, p = buffer; i < len; i++,p++) {
376 : 1848 : *q++ = hexdig[(*p >> 4) & 0xf];
377 : 1848 : *q++ = hexdig[*p & 0xf];
378 : 1848 : *q++ = ':';
379 : : }
380 : 114 : q[-1] = 0;
381 : : #ifdef CHARSET_EBCDIC
382 : : ebcdic2ascii(tmp, tmp, q - tmp - 1);
383 : : #endif
384 : :
385 : 114 : return tmp;
386 : : }
387 : :
388 : : /* Give a string of hex digits convert to
389 : : * a buffer
390 : : */
391 : :
392 : 15 : unsigned char *string_to_hex(const char *str, long *len)
393 : : {
394 : : unsigned char *hexbuf, *q;
395 : : unsigned char ch, cl, *p;
396 [ - + ]: 15 : if(!str) {
397 : 0 : X509V3err(X509V3_F_STRING_TO_HEX,X509V3_R_INVALID_NULL_ARGUMENT);
398 : 0 : return NULL;
399 : : }
400 [ + - ]: 15 : if(!(hexbuf = OPENSSL_malloc(strlen(str) >> 1))) goto err;
401 [ + + ]: 210 : for(p = (unsigned char *)str, q = hexbuf; *p;) {
402 : 195 : ch = *p++;
403 : : #ifdef CHARSET_EBCDIC
404 : : ch = os_toebcdic[ch];
405 : : #endif
406 [ - + ]: 195 : if(ch == ':') continue;
407 : 195 : cl = *p++;
408 : : #ifdef CHARSET_EBCDIC
409 : : cl = os_toebcdic[cl];
410 : : #endif
411 [ - + ]: 195 : if(!cl) {
412 : 0 : X509V3err(X509V3_F_STRING_TO_HEX,X509V3_R_ODD_NUMBER_OF_DIGITS);
413 : 0 : OPENSSL_free(hexbuf);
414 : 0 : return NULL;
415 : : }
416 [ + + ]: 195 : if(isupper(ch)) ch = tolower(ch);
417 [ + + ]: 195 : if(isupper(cl)) cl = tolower(cl);
418 : :
419 [ + + ]: 195 : if((ch >= '0') && (ch <= '9')) ch -= '0';
420 [ + - ]: 9 : else if ((ch >= 'a') && (ch <= 'f')) ch -= 'a' - 10;
421 : : else goto badhex;
422 : :
423 [ + + ]: 195 : if((cl >= '0') && (cl <= '9')) cl -= '0';
424 [ + - ]: 63 : else if ((cl >= 'a') && (cl <= 'f')) cl -= 'a' - 10;
425 : : else goto badhex;
426 : :
427 : 195 : *q++ = (ch << 4) | cl;
428 : : }
429 : :
430 [ + - ]: 15 : if(len) *len = q - hexbuf;
431 : :
432 : 15 : return hexbuf;
433 : :
434 : : err:
435 [ # # ]: 0 : if(hexbuf) OPENSSL_free(hexbuf);
436 : 0 : X509V3err(X509V3_F_STRING_TO_HEX,ERR_R_MALLOC_FAILURE);
437 : 0 : return NULL;
438 : :
439 : : badhex:
440 : 0 : OPENSSL_free(hexbuf);
441 : 0 : X509V3err(X509V3_F_STRING_TO_HEX,X509V3_R_ILLEGAL_HEX_DIGIT);
442 : 0 : return NULL;
443 : :
444 : : }
445 : :
446 : : /* V2I name comparison function: returns zero if 'name' matches
447 : : * cmp or cmp.*
448 : : */
449 : :
450 : 6 : int name_cmp(const char *name, const char *cmp)
451 : : {
452 : : int len, ret;
453 : : char c;
454 : 6 : len = strlen(cmp);
455 [ + - ]: 6 : if((ret = strncmp(name, cmp, len))) return ret;
456 : 6 : c = name[len];
457 [ - + ]: 6 : if(!c || (c=='.')) return 0;
458 : 0 : return 1;
459 : : }
460 : :
461 : 0 : static int sk_strcmp(const char * const *a, const char * const *b)
462 : : {
463 : 0 : return strcmp(*a, *b);
464 : : }
465 : :
466 : 0 : STACK_OF(OPENSSL_STRING) *X509_get1_email(X509 *x)
467 : : {
468 : : GENERAL_NAMES *gens;
469 : : STACK_OF(OPENSSL_STRING) *ret;
470 : :
471 : 0 : gens = X509_get_ext_d2i(x, NID_subject_alt_name, NULL, NULL);
472 : 0 : ret = get_email(X509_get_subject_name(x), gens);
473 : 0 : sk_GENERAL_NAME_pop_free(gens, GENERAL_NAME_free);
474 : 0 : return ret;
475 : : }
476 : :
477 : 0 : STACK_OF(OPENSSL_STRING) *X509_get1_ocsp(X509 *x)
478 : : {
479 : : AUTHORITY_INFO_ACCESS *info;
480 : 0 : STACK_OF(OPENSSL_STRING) *ret = NULL;
481 : : int i;
482 : :
483 : 0 : info = X509_get_ext_d2i(x, NID_info_access, NULL, NULL);
484 [ # # ]: 0 : if (!info)
485 : : return NULL;
486 [ # # ]: 0 : for (i = 0; i < sk_ACCESS_DESCRIPTION_num(info); i++)
487 : : {
488 : 0 : ACCESS_DESCRIPTION *ad = sk_ACCESS_DESCRIPTION_value(info, i);
489 [ # # ]: 0 : if (OBJ_obj2nid(ad->method) == NID_ad_OCSP)
490 : : {
491 [ # # ]: 0 : if (ad->location->type == GEN_URI)
492 : : {
493 [ # # ]: 0 : if (!append_ia5(&ret, ad->location->d.uniformResourceIdentifier))
494 : : break;
495 : : }
496 : : }
497 : : }
498 : 0 : AUTHORITY_INFO_ACCESS_free(info);
499 : 0 : return ret;
500 : : }
501 : :
502 : 0 : STACK_OF(OPENSSL_STRING) *X509_REQ_get1_email(X509_REQ *x)
503 : : {
504 : : GENERAL_NAMES *gens;
505 : : STACK_OF(X509_EXTENSION) *exts;
506 : : STACK_OF(OPENSSL_STRING) *ret;
507 : :
508 : 0 : exts = X509_REQ_get_extensions(x);
509 : 0 : gens = X509V3_get_d2i(exts, NID_subject_alt_name, NULL, NULL);
510 : 0 : ret = get_email(X509_REQ_get_subject_name(x), gens);
511 : 0 : sk_GENERAL_NAME_pop_free(gens, GENERAL_NAME_free);
512 : 0 : sk_X509_EXTENSION_pop_free(exts, X509_EXTENSION_free);
513 : 0 : return ret;
514 : : }
515 : :
516 : :
517 : 0 : static STACK_OF(OPENSSL_STRING) *get_email(X509_NAME *name, GENERAL_NAMES *gens)
518 : : {
519 : 0 : STACK_OF(OPENSSL_STRING) *ret = NULL;
520 : : X509_NAME_ENTRY *ne;
521 : 0 : ASN1_IA5STRING *email;
522 : : GENERAL_NAME *gen;
523 : : int i;
524 : : /* Now add any email address(es) to STACK */
525 : 0 : i = -1;
526 : : /* First supplied X509_NAME */
527 [ # # ]: 0 : while((i = X509_NAME_get_index_by_NID(name,
528 : : NID_pkcs9_emailAddress, i)) >= 0) {
529 : 0 : ne = X509_NAME_get_entry(name, i);
530 : 0 : email = X509_NAME_ENTRY_get_data(ne);
531 [ # # ]: 0 : if(!append_ia5(&ret, email)) return NULL;
532 : : }
533 [ # # ]: 0 : for(i = 0; i < sk_GENERAL_NAME_num(gens); i++)
534 : : {
535 : 0 : gen = sk_GENERAL_NAME_value(gens, i);
536 [ # # ]: 0 : if(gen->type != GEN_EMAIL) continue;
537 [ # # ]: 0 : if(!append_ia5(&ret, gen->d.ia5)) return NULL;
538 : : }
539 : 0 : return ret;
540 : : }
541 : :
542 : 0 : static void str_free(OPENSSL_STRING str)
543 : : {
544 : 0 : OPENSSL_free(str);
545 : 0 : }
546 : :
547 : 0 : static int append_ia5(STACK_OF(OPENSSL_STRING) **sk, ASN1_IA5STRING *email)
548 : : {
549 : : char *emtmp;
550 : : /* First some sanity checks */
551 [ # # ]: 0 : if(email->type != V_ASN1_IA5STRING) return 1;
552 [ # # ][ # # ]: 0 : if(!email->data || !email->length) return 1;
553 [ # # ]: 0 : if(!*sk) *sk = sk_OPENSSL_STRING_new(sk_strcmp);
554 [ # # ]: 0 : if(!*sk) return 0;
555 : : /* Don't add duplicates */
556 [ # # ]: 0 : if(sk_OPENSSL_STRING_find(*sk, (char *)email->data) != -1) return 1;
557 : 0 : emtmp = BUF_strdup((char *)email->data);
558 [ # # ][ # # ]: 0 : if(!emtmp || !sk_OPENSSL_STRING_push(*sk, emtmp)) {
559 : 0 : X509_email_free(*sk);
560 : 0 : *sk = NULL;
561 : : return 0;
562 : : }
563 : : return 1;
564 : : }
565 : :
566 : 0 : void X509_email_free(STACK_OF(OPENSSL_STRING) *sk)
567 : : {
568 : 0 : sk_OPENSSL_STRING_pop_free(sk, str_free);
569 : 0 : }
570 : :
571 : : typedef int (*equal_fn)(const unsigned char *pattern, size_t pattern_len,
572 : : const unsigned char *subject, size_t subject_len,
573 : : unsigned int flags);
574 : :
575 : : /* Skip pattern prefix to match "wildcard" subject */
576 : 61790 : static void skip_prefix(const unsigned char **p, size_t *plen,
577 : : const unsigned char *subject, size_t subject_len,
578 : : unsigned int flags)
579 : : {
580 : 30895 : const unsigned char *pattern = *p;
581 : 30895 : size_t pattern_len = *plen;
582 : :
583 : : /*
584 : : * If subject starts with a leading '.' followed by more octets, and
585 : : * pattern is longer, compare just an equal-length suffix with the
586 : : * full subject (starting at the '.'), provided the prefix contains
587 : : * no NULs.
588 : : */
589 [ + + ]: 30895 : if ((flags & _X509_CHECK_FLAG_DOT_SUBDOMAINS) == 0)
590 : 30895 : return;
591 : :
592 [ + + ][ + - ]: 25608 : while (pattern_len > subject_len && *pattern)
593 : : {
594 [ - + ][ # # ]: 22182 : if ((flags & X509_CHECK_FLAG_SINGLE_LABEL_SUBDOMAINS) &&
595 : : *pattern == '.')
596 : : break;
597 : 22182 : ++pattern;
598 : 22182 : --pattern_len;
599 : : }
600 : :
601 : : /* Skip if entire prefix acceptable */
602 [ + + ]: 3426 : if (pattern_len == subject_len)
603 : : {
604 : 2644 : *p = pattern;
605 : 2644 : *plen = pattern_len;
606 : : }
607 : : }
608 : :
609 : : /* Compare while ASCII ignoring case. */
610 : 30170 : static int equal_nocase(const unsigned char *pattern, size_t pattern_len,
611 : : const unsigned char *subject, size_t subject_len,
612 : : unsigned int flags)
613 : : {
614 : 30170 : skip_prefix(&pattern, &pattern_len, subject, subject_len, flags);
615 [ + + ]: 30170 : if (pattern_len != subject_len)
616 : : return 0;
617 [ + + ]: 15000 : while (pattern_len)
618 : : {
619 : 14085 : unsigned char l = *pattern;
620 : 14085 : unsigned char r = *subject;
621 : : /* The pattern must not contain NUL characters. */
622 [ + - ]: 14085 : if (l == 0)
623 : : return 0;
624 [ + + ]: 14085 : if (l != r)
625 : : {
626 [ + + ]: 6203 : if ('A' <= l && l <= 'Z')
627 : 360 : l = (l - 'A') + 'a';
628 [ + + ]: 6203 : if ('A' <= r && r <= 'Z')
629 : 320 : r = (r - 'A') + 'a';
630 [ + + ]: 6203 : if (l != r)
631 : : return 0;
632 : : }
633 : 8522 : ++pattern;
634 : 8522 : ++subject;
635 : 8522 : --pattern_len;
636 : : }
637 : : return 1;
638 : : }
639 : :
640 : : /* Compare using memcmp. */
641 : 725 : static int equal_case(const unsigned char *pattern, size_t pattern_len,
642 : : const unsigned char *subject, size_t subject_len,
643 : : unsigned int flags)
644 : : {
645 : 725 : skip_prefix(&pattern, &pattern_len, subject, subject_len, flags);
646 [ + - ]: 725 : if (pattern_len != subject_len)
647 : : return 0;
648 : 725 : return !memcmp(pattern, subject, pattern_len);
649 : : }
650 : :
651 : : /* RFC 5280, section 7.5, requires that only the domain is compared in
652 : : a case-insensitive manner. */
653 : 14745 : static int equal_email(const unsigned char *a, size_t a_len,
654 : : const unsigned char *b, size_t b_len,
655 : : unsigned int unused_flags)
656 : : {
657 : 14745 : size_t i = a_len;
658 [ + + ]: 14745 : if (a_len != b_len)
659 : : return 0;
660 : : /* We search backwards for the '@' character, so that we do
661 : : not have to deal with quoted local-parts. The domain part
662 : : is compared in a case-insensitive manner. */
663 [ + + ]: 6826 : while (i > 0)
664 : : {
665 : 6251 : --i;
666 [ + + ][ + + ]: 6251 : if (a[i] == '@' || b[i] == '@')
667 : : {
668 [ + + ]: 2431 : if (!equal_nocase(a + i, a_len - i,
669 : : b + i, a_len - i, 0))
670 : : return 0;
671 : : break;
672 : : }
673 : : }
674 [ + + ]: 725 : if (i == 0)
675 : 590 : i = a_len;
676 : 725 : return equal_case(a, i, b, i, 0);
677 : : }
678 : :
679 : : /* Compare the prefix and suffix with the subject, and check that the
680 : : characters in-between are valid. */
681 : 570 : static int wildcard_match(const unsigned char *prefix, size_t prefix_len,
682 : : const unsigned char *suffix, size_t suffix_len,
683 : : const unsigned char *subject, size_t subject_len,
684 : : unsigned int flags)
685 : : {
686 : : const unsigned char *wildcard_start;
687 : : const unsigned char *wildcard_end;
688 : : const unsigned char *p;
689 : 570 : int allow_multi = 0;
690 : 570 : int allow_idna = 0;
691 : :
692 [ + + ]: 570 : if (subject_len < prefix_len + suffix_len)
693 : : return 0;
694 [ + - ]: 170 : if (!equal_nocase(prefix, prefix_len, subject, prefix_len, flags))
695 : : return 0;
696 : 170 : wildcard_start = subject + prefix_len;
697 : 170 : wildcard_end = subject + (subject_len - suffix_len);
698 [ + + ]: 170 : if (!equal_nocase(wildcard_end, suffix_len, suffix, suffix_len, flags))
699 : : return 0;
700 : : /*
701 : : * If the wildcard makes up the entire first label, it must match at
702 : : * least one character.
703 : : */
704 [ + - ][ + + ]: 80 : if (prefix_len == 0 && *suffix == '.')
705 : : {
706 [ + - ]: 60 : if (wildcard_start == wildcard_end)
707 : : return 0;
708 : 60 : allow_idna = 1;
709 [ - + ]: 60 : if (flags & X509_CHECK_FLAG_MULTI_LABEL_WILDCARDS)
710 : 0 : allow_multi = 1;
711 : : }
712 : : /* IDNA labels cannot match partial wildcards */
713 [ + + ]: 80 : if (!allow_idna &&
714 [ + - ]: 20 : subject_len >= 4 && strncasecmp((char *)subject, "xn--", 4) == 0)
715 : : return 0;
716 : : /* The wildcard may match a literal '*' */
717 [ + + ][ + + ]: 80 : if (wildcard_end == wildcard_start + 1 && *wildcard_start == '*')
718 : : return 1;
719 : : /*
720 : : * Check that the part matched by the wildcard contains only
721 : : * permitted characters and only matches a single label unless
722 : : * allow_multi is set.
723 : : */
724 [ + + ]: 250 : for (p = wildcard_start; p != wildcard_end; ++p)
725 [ + - ][ - + ]: 255 : if (!(('0' <= *p && *p <= '9') ||
726 [ + + ]: 220 : ('A' <= *p && *p <= 'Z') ||
727 [ + + ]: 50 : ('a' <= *p && *p <= 'z') ||
728 [ # # ]: 0 : *p == '-' || (allow_multi && *p == '.')))
729 : : return 0;
730 : : return 1;
731 : : }
732 : :
733 : : #define LABEL_START (1 << 0)
734 : : #define LABEL_END (1 << 1)
735 : : #define LABEL_HYPHEN (1 << 2)
736 : : #define LABEL_IDNA (1 << 3)
737 : :
738 : 13020 : static const unsigned char *valid_star(const unsigned char *p, size_t len,
739 : : unsigned int flags)
740 : : {
741 : 13020 : const unsigned char *star = 0;
742 : : size_t i;
743 : 13020 : int state = LABEL_START;
744 : 13020 : int dots = 0;
745 [ + + ]: 98830 : for (i = 0; i < len; ++i)
746 : : {
747 : : /*
748 : : * Locate first and only legal wildcard, either at the start
749 : : * or end of a non-IDNA first and not final label.
750 : : */
751 [ + + ]: 93206 : if (p[i] == '*')
752 : : {
753 : 3420 : int atstart = (state & LABEL_START);
754 [ + + ][ + - ]: 3420 : int atend = (i == len - 1 || p[i+i] == '.');
755 : : /*
756 : : * At most one wildcard per pattern.
757 : : * No wildcards in IDNA labels.
758 : : * No wildcards after the first label.
759 : : */
760 [ + + ][ + + ]: 3420 : if (star != NULL || (state & LABEL_IDNA) != 0 || dots)
761 : : return NULL;
762 : : /* Only full-label '*.example.com' wildcards? */
763 [ - + ]: 2660 : if ((flags & X509_CHECK_FLAG_NO_PARTIAL_WILDCARDS)
764 [ # # ]: 0 : && (!atstart || !atend))
765 : : return NULL;
766 : : /* No 'foo*bar' wildcards */
767 [ + - ]: 2660 : if (!atstart && !atend)
768 : : return NULL;
769 : 2660 : star = &p[i];
770 : 2660 : state &= ~LABEL_START;
771 : : }
772 [ + + ]: 89786 : else if ((state & LABEL_START) != 0)
773 : : {
774 : : /*
775 : : * At the start of a label, skip any "xn--" and
776 : : * remain in the LABEL_START state, but set the
777 : : * IDNA label state
778 : : */
779 [ + + ][ + + ]: 18188 : if ((state & LABEL_IDNA) == 0 && len - i >= 4
780 [ + + ]: 11234 : && strncasecmp((char *)&p[i], "xn--", 4) == 0)
781 : : {
782 : 190 : i += 3;
783 : 190 : state |= LABEL_IDNA;
784 : 190 : continue;
785 : : }
786 : : /* Labels must start with a letter or digit */
787 : 17998 : state &= ~LABEL_START;
788 [ + + ]: 17998 : if (('a' <= p[i] && p[i] <= 'z')
789 : 17998 : || ('A' <= p[i] && p[i] <= 'Z')
790 [ - + ]: 1900 : || ('0' <= p[i] && p[i] <= '9'))
791 : 16098 : continue;
792 : : return NULL;
793 : : }
794 [ + + ]: 71598 : else if (('a' <= p[i] && p[i] <= 'z')
795 : 71598 : || ('A' <= p[i] && p[i] <= 'Z')
796 [ - + ]: 13514 : || ('0' <= p[i] && p[i] <= '9'))
797 : : {
798 : 58084 : state &= LABEL_IDNA;
799 : 58084 : continue;
800 : : }
801 [ + + ]: 13514 : else if (p[i] == '.')
802 : : {
803 [ + - ]: 8588 : if (state & (LABEL_HYPHEN | LABEL_START))
804 : : return NULL;
805 : 8588 : state = LABEL_START;
806 : 8588 : ++dots;
807 : : }
808 [ + + ]: 4926 : else if (p[i] == '-')
809 : : {
810 [ + - ]: 190 : if (state & LABEL_HYPHEN)
811 : : return NULL;
812 : 190 : state |= LABEL_HYPHEN;
813 : : }
814 : : else
815 : : return NULL;
816 : : }
817 : :
818 : : /*
819 : : * The final label must not end in a hyphen or ".", and
820 : : * there must be at least two dots after the star.
821 : : */
822 [ + + ]: 5624 : if ((state & (LABEL_START | LABEL_HYPHEN)) != 0
823 [ + + ]: 5054 : || dots < 2)
824 : : return NULL;
825 : 3154 : return star;
826 : : }
827 : :
828 : : /* Compare using wildcards. */
829 : 14733 : static int equal_wildcard(const unsigned char *pattern, size_t pattern_len,
830 : : const unsigned char *subject, size_t subject_len,
831 : : unsigned int flags)
832 : : {
833 : 14733 : const unsigned char *star = NULL;
834 : :
835 : : /*
836 : : * Subject names starting with '.' can only match a wildcard pattern
837 : : * via a subject sub-domain pattern suffix match.
838 : : */
839 [ + + ][ + + ]: 14733 : if (!(subject_len > 1 && subject[0] == '.'))
840 : 13020 : star = valid_star(pattern, pattern_len, flags);
841 [ + + ]: 14733 : if (star == NULL)
842 : 14163 : return equal_nocase(pattern, pattern_len,
843 : : subject, subject_len, flags);
844 : 570 : return wildcard_match(pattern, star - pattern,
845 : 570 : star + 1, (pattern + pattern_len) - star - 1,
846 : : subject, subject_len, flags);
847 : : }
848 : :
849 : : /* Compare an ASN1_STRING to a supplied string. If they match
850 : : * return 1. If cmp_type > 0 only compare if string matches the
851 : : * type, otherwise convert it to UTF8.
852 : : */
853 : :
854 : 44217 : static int do_check_string(ASN1_STRING *a, int cmp_type, equal_fn equal,
855 : : unsigned int flags, const char *b, size_t blen,
856 : : char **peername)
857 : : {
858 : 44217 : int rv = 0;
859 : :
860 [ + - ][ + - ]: 44217 : if (!a->data || !a->length)
861 : : return 0;
862 [ + + ]: 44217 : if (cmp_type > 0)
863 : : {
864 [ + - ]: 5547 : if (cmp_type != a->type)
865 : : return 0;
866 [ + - ]: 5547 : if (cmp_type == V_ASN1_IA5STRING)
867 : 5547 : rv = equal(a->data, a->length,
868 : : (unsigned char *)b, blen, flags);
869 [ # # ][ # # ]: 0 : else if (a->length == (int)blen && !memcmp(a->data, b, blen))
870 : 0 : rv = 1;
871 [ - + ]: 5547 : if (rv > 0 && peername)
872 : 0 : *peername = BUF_strndup((char *)a->data, a->length);
873 : : }
874 : : else
875 : : {
876 : : int astrlen;
877 : : unsigned char *astr;
878 : 38670 : astrlen = ASN1_STRING_to_UTF8(&astr, a);
879 [ - + ]: 38670 : if (astrlen < 0)
880 : 0 : return -1;
881 : 38670 : rv = equal(astr, astrlen, (unsigned char *)b, blen, flags);
882 : 38670 : OPENSSL_free(astr);
883 [ - + ]: 38670 : if (rv > 0 && peername)
884 : 38670 : *peername = BUF_strndup((char *)astr, astrlen);
885 : : }
886 : 44217 : return rv;
887 : : }
888 : :
889 : 55470 : static int do_x509_check(X509 *x, const char *chk, size_t chklen,
890 : : unsigned int flags, int check_type,
891 : : char **peername)
892 : : {
893 : 55470 : GENERAL_NAMES *gens = NULL;
894 : 55470 : X509_NAME *name = NULL;
895 : : int i;
896 : : int cnid;
897 : : int alt_type;
898 : 55470 : int san_present = 0;
899 : 55470 : int rv = 0;
900 : : equal_fn equal;
901 : :
902 : : /* See below, this flag is internal-only */
903 : 55470 : flags &= ~_X509_CHECK_FLAG_DOT_SUBDOMAINS;
904 [ + + ]: 55470 : if (check_type == GEN_EMAIL)
905 : : {
906 : : cnid = NID_pkcs9_emailAddress;
907 : : alt_type = V_ASN1_IA5STRING;
908 : : equal = equal_email;
909 : : }
910 [ + - ]: 36980 : else if (check_type == GEN_DNS)
911 : : {
912 : 36980 : cnid = NID_commonName;
913 : : /* Implicit client-side DNS sub-domain pattern */
914 [ + + ][ + + ]: 36980 : if (chklen > 1 && chk[0] == '.')
915 : 4300 : flags |= _X509_CHECK_FLAG_DOT_SUBDOMAINS;
916 : 36980 : alt_type = V_ASN1_IA5STRING;
917 [ + + ]: 36980 : if (flags & X509_CHECK_FLAG_NO_WILDCARDS)
918 : : equal = equal_nocase;
919 : : else
920 : 18490 : equal = equal_wildcard;
921 : : }
922 : : else
923 : : {
924 : : cnid = 0;
925 : : alt_type = V_ASN1_OCTET_STRING;
926 : : equal = equal_case;
927 : : }
928 : :
929 [ - + ]: 55470 : if (chklen == 0)
930 : 0 : chklen = strlen(chk);
931 : :
932 : 55470 : gens = X509_get_ext_d2i(x, NID_subject_alt_name, NULL, NULL);
933 [ + + ]: 55470 : if (gens)
934 : : {
935 [ + + ]: 22029 : for (i = 0; i < sk_GENERAL_NAME_num(gens); i++)
936 : : {
937 : : GENERAL_NAME *gen;
938 : : ASN1_STRING *cstr;
939 : 11094 : gen = sk_GENERAL_NAME_value(gens, i);
940 [ + + ]: 11094 : if (gen->type != check_type)
941 : 5547 : continue;
942 : 5547 : san_present = 1;
943 [ + + ]: 5547 : if (check_type == GEN_EMAIL)
944 : 1849 : cstr = gen->d.rfc822Name;
945 [ + - ]: 3698 : else if (check_type == GEN_DNS)
946 : 3698 : cstr = gen->d.dNSName;
947 : : else
948 : 0 : cstr = gen->d.iPAddress;
949 : : /* Positive on success, negative on error! */
950 [ + + ]: 5547 : if ((rv = do_check_string(cstr, alt_type, equal, flags,
951 : : chk, chklen, peername)) != 0)
952 : : break;
953 : : }
954 : 11094 : GENERAL_NAMES_free(gens);
955 [ + + ]: 11094 : if (rv != 0)
956 : : return rv;
957 [ + - ]: 10935 : if (!cnid
958 [ + + ]: 10935 : || (san_present
959 [ - + ]: 5388 : && !(flags & X509_CHECK_FLAG_ALWAYS_CHECK_SUBJECT)))
960 : : return 0;
961 : : }
962 : 49923 : i = -1;
963 : 49923 : name = X509_get_subject_name(x);
964 [ + + ]: 87957 : while((i = X509_NAME_get_index_by_NID(name, cnid, i)) >= 0)
965 : : {
966 : : X509_NAME_ENTRY *ne;
967 : : ASN1_STRING *str;
968 : 38670 : ne = X509_NAME_get_entry(name, i);
969 : 38670 : str = X509_NAME_ENTRY_get_data(ne);
970 : : /* Positive on success, negative on error! */
971 [ + + ]: 38670 : if ((rv = do_check_string(str, -1, equal, flags,
972 : : chk, chklen, peername)) != 0)
973 : : return rv;
974 : : }
975 : : return 0;
976 : : }
977 : :
978 : 36980 : int X509_check_host(X509 *x, const char *chk, size_t chklen,
979 : : unsigned int flags, char **peername)
980 : : {
981 [ + - ]: 36980 : if (chk == NULL)
982 : : return -2;
983 : : /*
984 : : * Embedded NULs are disallowed, except as the last character of a
985 : : * string of length 2 or more (tolerate caller including terminating
986 : : * NUL in string length).
987 : : */
988 [ - + ]: 36980 : if (chklen == 0)
989 : 0 : chklen = strlen(chk);
990 [ + + ][ + - ]: 36980 : else if (memchr(chk, '\0', chklen > 1 ? chklen-1 : chklen))
991 : : return -2;
992 [ + + ][ - + ]: 36980 : if (chklen > 1 && chk[chklen-1] == '\0')
993 : 0 : --chklen;
994 : 36980 : return do_x509_check(x, chk, chklen, flags, GEN_DNS, peername);
995 : : }
996 : :
997 : 18490 : int X509_check_email(X509 *x, const char *chk, size_t chklen,
998 : : unsigned int flags)
999 : : {
1000 [ + - ]: 18490 : if (chk == NULL)
1001 : : return -2;
1002 : : /*
1003 : : * Embedded NULs are disallowed, except as the last character of a
1004 : : * string of length 2 or more (tolerate caller including terminating
1005 : : * NUL in string length).
1006 : : */
1007 [ - + ]: 18490 : if (chklen == 0)
1008 : 0 : chklen = strlen((char *)chk);
1009 [ + + ][ + - ]: 18490 : else if (memchr(chk, '\0', chklen > 1 ? chklen-1 : chklen))
1010 : : return -2;
1011 [ + + ][ - + ]: 18490 : if (chklen > 1 && chk[chklen-1] == '\0')
1012 : 0 : --chklen;
1013 : 18490 : return do_x509_check(x, chk, chklen, flags, GEN_EMAIL, NULL);
1014 : : }
1015 : :
1016 : 0 : int X509_check_ip(X509 *x, const unsigned char *chk, size_t chklen,
1017 : : unsigned int flags)
1018 : : {
1019 [ # # ]: 0 : if (chk == NULL)
1020 : : return -2;
1021 : 0 : return do_x509_check(x, (char *)chk, chklen, flags, GEN_IPADD, NULL);
1022 : : }
1023 : :
1024 : 0 : int X509_check_ip_asc(X509 *x, const char *ipasc, unsigned int flags)
1025 : : {
1026 : : unsigned char ipout[16];
1027 : : size_t iplen;
1028 : :
1029 [ # # ]: 0 : if (ipasc == NULL)
1030 : : return -2;
1031 : 0 : iplen = (size_t) a2i_ipadd(ipout, ipasc);
1032 [ # # ]: 0 : if (iplen == 0)
1033 : : return -2;
1034 : 0 : return do_x509_check(x, (char *)ipout, iplen, flags, GEN_IPADD, NULL);
1035 : : }
1036 : :
1037 : : /* Convert IP addresses both IPv4 and IPv6 into an
1038 : : * OCTET STRING compatible with RFC3280.
1039 : : */
1040 : :
1041 : 0 : ASN1_OCTET_STRING *a2i_IPADDRESS(const char *ipasc)
1042 : : {
1043 : : unsigned char ipout[16];
1044 : : ASN1_OCTET_STRING *ret;
1045 : : int iplen;
1046 : :
1047 : : /* If string contains a ':' assume IPv6 */
1048 : :
1049 : 0 : iplen = a2i_ipadd(ipout, ipasc);
1050 : :
1051 [ # # ]: 0 : if (!iplen)
1052 : : return NULL;
1053 : :
1054 : 0 : ret = ASN1_OCTET_STRING_new();
1055 [ # # ]: 0 : if (!ret)
1056 : : return NULL;
1057 [ # # ]: 0 : if (!ASN1_OCTET_STRING_set(ret, ipout, iplen))
1058 : : {
1059 : 0 : ASN1_OCTET_STRING_free(ret);
1060 : 0 : return NULL;
1061 : : }
1062 : : return ret;
1063 : : }
1064 : :
1065 : 0 : ASN1_OCTET_STRING *a2i_IPADDRESS_NC(const char *ipasc)
1066 : : {
1067 : 0 : ASN1_OCTET_STRING *ret = NULL;
1068 : : unsigned char ipout[32];
1069 : 0 : char *iptmp = NULL, *p;
1070 : : int iplen1, iplen2;
1071 : 0 : p = strchr(ipasc,'/');
1072 [ # # ]: 0 : if (!p)
1073 : : return NULL;
1074 : 0 : iptmp = BUF_strdup(ipasc);
1075 [ # # ]: 0 : if (!iptmp)
1076 : : return NULL;
1077 : 0 : p = iptmp + (p - ipasc);
1078 : 0 : *p++ = 0;
1079 : :
1080 : 0 : iplen1 = a2i_ipadd(ipout, iptmp);
1081 : :
1082 [ # # ]: 0 : if (!iplen1)
1083 : : goto err;
1084 : :
1085 : 0 : iplen2 = a2i_ipadd(ipout + iplen1, p);
1086 : :
1087 : 0 : OPENSSL_free(iptmp);
1088 : 0 : iptmp = NULL;
1089 : :
1090 [ # # ]: 0 : if (!iplen2 || (iplen1 != iplen2))
1091 : : goto err;
1092 : :
1093 : 0 : ret = ASN1_OCTET_STRING_new();
1094 [ # # ]: 0 : if (!ret)
1095 : : goto err;
1096 [ # # ]: 0 : if (!ASN1_OCTET_STRING_set(ret, ipout, iplen1 + iplen2))
1097 : : goto err;
1098 : :
1099 : : return ret;
1100 : :
1101 : : err:
1102 [ # # ]: 0 : if (iptmp)
1103 : 0 : OPENSSL_free(iptmp);
1104 [ # # ]: 0 : if (ret)
1105 : 0 : ASN1_OCTET_STRING_free(ret);
1106 : : return NULL;
1107 : : }
1108 : :
1109 : :
1110 : 0 : int a2i_ipadd(unsigned char *ipout, const char *ipasc)
1111 : : {
1112 : : /* If string contains a ':' assume IPv6 */
1113 : :
1114 [ # # ]: 0 : if (strchr(ipasc, ':'))
1115 : : {
1116 [ # # ]: 0 : if (!ipv6_from_asc(ipout, ipasc))
1117 : : return 0;
1118 : 0 : return 16;
1119 : : }
1120 : : else
1121 : : {
1122 [ # # ]: 0 : if (!ipv4_from_asc(ipout, ipasc))
1123 : : return 0;
1124 : 0 : return 4;
1125 : : }
1126 : : }
1127 : :
1128 : 0 : static int ipv4_from_asc(unsigned char *v4, const char *in)
1129 : : {
1130 : : int a0, a1, a2, a3;
1131 [ # # ]: 0 : if (sscanf(in, "%d.%d.%d.%d", &a0, &a1, &a2, &a3) != 4)
1132 : : return 0;
1133 [ # # ][ # # ]: 0 : if ((a0 < 0) || (a0 > 255) || (a1 < 0) || (a1 > 255)
[ # # ]
1134 [ # # ][ # # ]: 0 : || (a2 < 0) || (a2 > 255) || (a3 < 0) || (a3 > 255))
[ # # ][ # # ]
1135 : : return 0;
1136 : 0 : v4[0] = a0;
1137 : 0 : v4[1] = a1;
1138 : 0 : v4[2] = a2;
1139 : 0 : v4[3] = a3;
1140 : 0 : return 1;
1141 : : }
1142 : :
1143 : : typedef struct {
1144 : : /* Temporary store for IPV6 output */
1145 : : unsigned char tmp[16];
1146 : : /* Total number of bytes in tmp */
1147 : : int total;
1148 : : /* The position of a zero (corresponding to '::') */
1149 : : int zero_pos;
1150 : : /* Number of zeroes */
1151 : : int zero_cnt;
1152 : : } IPV6_STAT;
1153 : :
1154 : :
1155 : 0 : static int ipv6_from_asc(unsigned char *v6, const char *in)
1156 : : {
1157 : : IPV6_STAT v6stat;
1158 : 0 : v6stat.total = 0;
1159 : 0 : v6stat.zero_pos = -1;
1160 : 0 : v6stat.zero_cnt = 0;
1161 : : /* Treat the IPv6 representation as a list of values
1162 : : * separated by ':'. The presence of a '::' will parse
1163 : : * as one, two or three zero length elements.
1164 : : */
1165 [ # # ]: 0 : if (!CONF_parse_list(in, ':', 0, ipv6_cb, &v6stat))
1166 : : return 0;
1167 : :
1168 : : /* Now for some sanity checks */
1169 : :
1170 [ # # ]: 0 : if (v6stat.zero_pos == -1)
1171 : : {
1172 : : /* If no '::' must have exactly 16 bytes */
1173 [ # # ]: 0 : if (v6stat.total != 16)
1174 : : return 0;
1175 : : }
1176 : : else
1177 : : {
1178 : : /* If '::' must have less than 16 bytes */
1179 [ # # ]: 0 : if (v6stat.total == 16)
1180 : : return 0;
1181 : : /* More than three zeroes is an error */
1182 [ # # ]: 0 : if (v6stat.zero_cnt > 3)
1183 : : return 0;
1184 : : /* Can only have three zeroes if nothing else present */
1185 [ # # ]: 0 : else if (v6stat.zero_cnt == 3)
1186 : : {
1187 [ # # ]: 0 : if (v6stat.total > 0)
1188 : : return 0;
1189 : : }
1190 : : /* Can only have two zeroes if at start or end */
1191 [ # # ]: 0 : else if (v6stat.zero_cnt == 2)
1192 : : {
1193 [ # # ]: 0 : if ((v6stat.zero_pos != 0)
1194 [ # # ]: 0 : && (v6stat.zero_pos != v6stat.total))
1195 : : return 0;
1196 : : }
1197 : : else
1198 : : /* Can only have one zero if *not* start or end */
1199 : : {
1200 [ # # ]: 0 : if ((v6stat.zero_pos == 0)
1201 [ # # ]: 0 : || (v6stat.zero_pos == v6stat.total))
1202 : : return 0;
1203 : : }
1204 : : }
1205 : :
1206 : : /* Format result */
1207 : :
1208 [ # # ]: 0 : if (v6stat.zero_pos >= 0)
1209 : : {
1210 : : /* Copy initial part */
1211 : 0 : memcpy(v6, v6stat.tmp, v6stat.zero_pos);
1212 : : /* Zero middle */
1213 : 0 : memset(v6 + v6stat.zero_pos, 0, 16 - v6stat.total);
1214 : : /* Copy final part */
1215 [ # # ]: 0 : if (v6stat.total != v6stat.zero_pos)
1216 : 0 : memcpy(v6 + v6stat.zero_pos + 16 - v6stat.total,
1217 : 0 : v6stat.tmp + v6stat.zero_pos,
1218 : 0 : v6stat.total - v6stat.zero_pos);
1219 : : }
1220 : : else
1221 : : memcpy(v6, v6stat.tmp, 16);
1222 : :
1223 : : return 1;
1224 : : }
1225 : :
1226 : 0 : static int ipv6_cb(const char *elem, int len, void *usr)
1227 : : {
1228 : 0 : IPV6_STAT *s = usr;
1229 : : /* Error if 16 bytes written */
1230 [ # # ]: 0 : if (s->total == 16)
1231 : : return 0;
1232 [ # # ]: 0 : if (len == 0)
1233 : : {
1234 : : /* Zero length element, corresponds to '::' */
1235 [ # # ]: 0 : if (s->zero_pos == -1)
1236 : 0 : s->zero_pos = s->total;
1237 : : /* If we've already got a :: its an error */
1238 [ # # ]: 0 : else if (s->zero_pos != s->total)
1239 : : return 0;
1240 : 0 : s->zero_cnt++;
1241 : : }
1242 : : else
1243 : : {
1244 : : /* If more than 4 characters could be final a.b.c.d form */
1245 [ # # ]: 0 : if (len > 4)
1246 : : {
1247 : : /* Need at least 4 bytes left */
1248 [ # # ]: 0 : if (s->total > 12)
1249 : : return 0;
1250 : : /* Must be end of string */
1251 [ # # ]: 0 : if (elem[len])
1252 : : return 0;
1253 [ # # ]: 0 : if (!ipv4_from_asc(s->tmp + s->total, elem))
1254 : : return 0;
1255 : 0 : s->total += 4;
1256 : : }
1257 : : else
1258 : : {
1259 [ # # ]: 0 : if (!ipv6_hex(s->tmp + s->total, elem, len))
1260 : : return 0;
1261 : 0 : s->total += 2;
1262 : : }
1263 : : }
1264 : : return 1;
1265 : : }
1266 : :
1267 : : /* Convert a string of up to 4 hex digits into the corresponding
1268 : : * IPv6 form.
1269 : : */
1270 : :
1271 : 0 : static int ipv6_hex(unsigned char *out, const char *in, int inlen)
1272 : : {
1273 : : unsigned char c;
1274 : 0 : unsigned int num = 0;
1275 [ # # ]: 0 : if (inlen > 4)
1276 : : return 0;
1277 [ # # ]: 0 : while(inlen--)
1278 : : {
1279 : 0 : c = *in++;
1280 : 0 : num <<= 4;
1281 [ # # ]: 0 : if ((c >= '0') && (c <= '9'))
1282 : 0 : num |= c - '0';
1283 [ # # ]: 0 : else if ((c >= 'A') && (c <= 'F'))
1284 : 0 : num |= c - 'A' + 10;
1285 [ # # ]: 0 : else if ((c >= 'a') && (c <= 'f'))
1286 : 0 : num |= c - 'a' + 10;
1287 : : else
1288 : : return 0;
1289 : : }
1290 : 0 : out[0] = num >> 8;
1291 : 0 : out[1] = num & 0xff;
1292 : 0 : return 1;
1293 : : }
1294 : :
1295 : :
1296 : 0 : int X509V3_NAME_from_section(X509_NAME *nm, STACK_OF(CONF_VALUE)*dn_sk,
1297 : : unsigned long chtype)
1298 : : {
1299 : : CONF_VALUE *v;
1300 : : int i, mval;
1301 : : char *p, *type;
1302 [ # # ]: 0 : if (!nm)
1303 : : return 0;
1304 : :
1305 [ # # ]: 0 : for (i = 0; i < sk_CONF_VALUE_num(dn_sk); i++)
1306 : : {
1307 : 0 : v=sk_CONF_VALUE_value(dn_sk,i);
1308 : 0 : type=v->name;
1309 : : /* Skip past any leading X. X: X, etc to allow for
1310 : : * multiple instances
1311 : : */
1312 [ # # ]: 0 : for(p = type; *p ; p++)
1313 : : #ifndef CHARSET_EBCDIC
1314 [ # # ][ # # ]: 0 : if ((*p == ':') || (*p == ',') || (*p == '.'))
1315 : : #else
1316 : : if ((*p == os_toascii[':']) || (*p == os_toascii[',']) || (*p == os_toascii['.']))
1317 : : #endif
1318 : : {
1319 : 0 : p++;
1320 [ # # ]: 0 : if(*p) type = p;
1321 : : break;
1322 : : }
1323 : : #ifndef CHARSET_EBCDIC
1324 [ # # ]: 0 : if (*type == '+')
1325 : : #else
1326 : : if (*type == os_toascii['+'])
1327 : : #endif
1328 : : {
1329 : 0 : mval = -1;
1330 : 0 : type++;
1331 : : }
1332 : : else
1333 : : mval = 0;
1334 [ # # ]: 0 : if (!X509_NAME_add_entry_by_txt(nm,type, chtype,
1335 : 0 : (unsigned char *) v->value,-1,-1,mval))
1336 : : return 0;
1337 : :
1338 : : }
1339 : : return 1;
1340 : : }
|
