Debian Codegraph @

external/boringssl/crypto/x509v3/v3_utl.c

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