?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Added WirelessManager, a port of wpa_supplicant.
[AROS.git] / workbench / network / WirelessManager / src / tls / x509v3.c
blobbc93df6837873d9ce826f689c5ca96a47a09cc3d
1 /*
2 * X.509v3 certificate parsing and processing (RFC 3280 profile)
3 * Copyright (c) 2006-2007, Jouni Malinen <j@w1.fi>
4 *
5 * This program is free software; you can redistribute it and/or modify
6 * it under the terms of the GNU General Public License version 2 as
7 * published by the Free Software Foundation.
8 *
9 * Alternatively, this software may be distributed under the terms of BSD
10 * license.
11 *
12 * See README and COPYING for more details.
13 */
14
15 #include "includes.h"
16
17 #include "common.h"
18 #include "crypto/crypto.h"
19 #include "asn1.h"
20 #include "x509v3.h"
21
22
23 static void x509_free_name(struct x509_name *name)
24 {
25 size_t i;
26
27 for (i = 0; i < name->num_attr; i++) {
28 os_free(name->attr[i].value);
29 name->attr[i].value = NULL;
30 name->attr[i].type = X509_NAME_ATTR_NOT_USED;
31 }
32 name->num_attr = 0;
33 os_free(name->email);
34 name->email = NULL;
35
36 os_free(name->alt_email);
37 os_free(name->dns);
38 os_free(name->uri);
39 os_free(name->ip);
40 name->alt_email = name->dns = name->uri = NULL;
41 name->ip = NULL;
42 name->ip_len = 0;
43 os_memset(&name->rid, 0, sizeof(name->rid));
44 }
45
46
47 /**
48 * x509_certificate_free - Free an X.509 certificate
49 * @cert: Certificate to be freed
50 */
51 void x509_certificate_free(struct x509_certificate *cert)
52 {
53 if (cert == NULL)
54 return;
55 if (cert->next) {
56 wpa_printf(MSG_DEBUG, "X509: x509_certificate_free: cer=%p "
57 "was still on a list (next=%p)\n",
58 cert, cert->next);
59 }
60 x509_free_name(&cert->issuer);
61 x509_free_name(&cert->subject);
62 os_free(cert->public_key);
63 os_free(cert->sign_value);
64 os_free(cert);
65 }
66
67
68 /**
69 * x509_certificate_free - Free an X.509 certificate chain
70 * @cert: Pointer to the first certificate in the chain
71 */
72 void x509_certificate_chain_free(struct x509_certificate *cert)
73 {
74 struct x509_certificate *next;
75
76 while (cert) {
77 next = cert->next;
78 cert->next = NULL;
79 x509_certificate_free(cert);
80 cert = next;
81 }
82 }
83
84
85 static int x509_whitespace(char c)
86 {
87 return c == ' ' || c == '\t';
88 }
89
90
91 static void x509_str_strip_whitespace(char *a)
92 {
93 char *ipos, *opos;
94 int remove_whitespace = 1;
95
96 ipos = opos = a;
97
98 while (*ipos) {
99 if (remove_whitespace && x509_whitespace(*ipos))
100 ipos++;
101 else {
102 remove_whitespace = x509_whitespace(*ipos);
103 *opos++ = *ipos++;
104 }
105 }
106
107 *opos-- = '\0';
108 if (opos > a && x509_whitespace(*opos))
109 *opos = '\0';
110 }
111
112
113 static int x509_str_compare(const char *a, const char *b)
114 {
115 char *aa, *bb;
116 int ret;
117
118 if (!a && b)
119 return -1;
120 if (a && !b)
121 return 1;
122 if (!a && !b)
123 return 0;
124
125 aa = os_strdup(a);
126 bb = os_strdup(b);
127
128 if (aa == NULL || bb == NULL) {
129 os_free(aa);
130 os_free(bb);
131 return os_strcasecmp(a, b);
132 }
133
134 x509_str_strip_whitespace(aa);
135 x509_str_strip_whitespace(bb);
136
137 ret = os_strcasecmp(aa, bb);
138
139 os_free(aa);
140 os_free(bb);
141
142 return ret;
143 }
144
145
146 /**
147 * x509_name_compare - Compare X.509 certificate names
148 * @a: Certificate name
149 * @b: Certificate name
150 * Returns: <0, 0, or >0 based on whether a is less than, equal to, or
151 * greater than b
152 */
153 int x509_name_compare(struct x509_name *a, struct x509_name *b)
154 {
155 int res;
156 size_t i;
157
158 if (!a && b)
159 return -1;
160 if (a && !b)
161 return 1;
162 if (!a && !b)
163 return 0;
164 if (a->num_attr < b->num_attr)
165 return -1;
166 if (a->num_attr > b->num_attr)
167 return 1;
168
169 for (i = 0; i < a->num_attr; i++) {
170 if (a->attr[i].type < b->attr[i].type)
171 return -1;
172 if (a->attr[i].type > b->attr[i].type)
173 return -1;
174 res = x509_str_compare(a->attr[i].value, b->attr[i].value);
175 if (res)
176 return res;
177 }
178 res = x509_str_compare(a->email, b->email);
179 if (res)
180 return res;
181
182 return 0;
183 }
184
185
186 static int x509_parse_algorithm_identifier(
187 const u8 *buf, size_t len,
188 struct x509_algorithm_identifier *id, const u8 **next)
189 {
190 struct asn1_hdr hdr;
191 const u8 *pos, *end;
192
193 /*
194 * AlgorithmIdentifier ::= SEQUENCE {
195 * algorithm OBJECT IDENTIFIER,
196 * parameters ANY DEFINED BY algorithm OPTIONAL
197 * }
198 */
199
200 if (asn1_get_next(buf, len, &hdr) < 0 ||
201 hdr.class != ASN1_CLASS_UNIVERSAL ||
202 hdr.tag != ASN1_TAG_SEQUENCE) {
203 wpa_printf(MSG_DEBUG, "X509: Expected SEQUENCE "
204 "(AlgorithmIdentifier) - found class %d tag 0x%x",
205 hdr.class, hdr.tag);
206 return -1;
207 }
208 pos = hdr.payload;
209 end = pos + hdr.length;
210
211 if (end > buf + len)
212 return -1;
213
214 *next = end;
215
216 if (asn1_get_oid(pos, end - pos, &id->oid, &pos))
217 return -1;
218
219 /* TODO: optional parameters */
220
221 return 0;
222 }
223
224
225 static int x509_parse_public_key(const u8 *buf, size_t len,
226 struct x509_certificate *cert,
227 const u8 **next)
228 {
229 struct asn1_hdr hdr;
230 const u8 *pos, *end;
231
232 /*
233 * SubjectPublicKeyInfo ::= SEQUENCE {
234 * algorithm AlgorithmIdentifier,
235 * subjectPublicKey BIT STRING
236 * }
237 */
238
239 pos = buf;
240 end = buf + len;
241
242 if (asn1_get_next(pos, end - pos, &hdr) < 0 ||
243 hdr.class != ASN1_CLASS_UNIVERSAL ||
244 hdr.tag != ASN1_TAG_SEQUENCE) {
245 wpa_printf(MSG_DEBUG, "X509: Expected SEQUENCE "
246 "(SubjectPublicKeyInfo) - found class %d tag 0x%x",
247 hdr.class, hdr.tag);
248 return -1;
249 }
250 pos = hdr.payload;
251
252 if (pos + hdr.length > end)
253 return -1;
254 end = pos + hdr.length;
255 *next = end;
256
257 if (x509_parse_algorithm_identifier(pos, end - pos,
258 &cert->public_key_alg, &pos))
259 return -1;
260
261 if (asn1_get_next(pos, end - pos, &hdr) < 0 ||
262 hdr.class != ASN1_CLASS_UNIVERSAL ||
263 hdr.tag != ASN1_TAG_BITSTRING) {
264 wpa_printf(MSG_DEBUG, "X509: Expected BITSTRING "
265 "(subjectPublicKey) - found class %d tag 0x%x",
266 hdr.class, hdr.tag);
267 return -1;
268 }
269 if (hdr.length < 1)
270 return -1;
271 pos = hdr.payload;
272 if (*pos) {
273 wpa_printf(MSG_DEBUG, "X509: BITSTRING - %d unused bits",
274 *pos);
275 /*
276 * TODO: should this be rejected? X.509 certificates are
277 * unlikely to use such a construction. Now we would end up
278 * including the extra bits in the buffer which may also be
279 * ok.
280 */
281 }
282 os_free(cert->public_key);
283 cert->public_key = os_malloc(hdr.length - 1);
284 if (cert->public_key == NULL) {
285 wpa_printf(MSG_DEBUG, "X509: Failed to allocate memory for "
286 "public key");
287 return -1;
288 }
289 os_memcpy(cert->public_key, pos + 1, hdr.length - 1);
290 cert->public_key_len = hdr.length - 1;
291 wpa_hexdump(MSG_MSGDUMP, "X509: subjectPublicKey",
292 cert->public_key, cert->public_key_len);
293
294 return 0;
295 }
296
297
298 static int x509_parse_name(const u8 *buf, size_t len, struct x509_name *name,
299 const u8 **next)
300 {
301 struct asn1_hdr hdr;
302 const u8 *pos, *end, *set_pos, *set_end, *seq_pos, *seq_end;
303 struct asn1_oid oid;
304 char *val;
305
306 /*
307 * Name ::= CHOICE { RDNSequence }
308 * RDNSequence ::= SEQUENCE OF RelativeDistinguishedName
309 * RelativeDistinguishedName ::= SET OF AttributeTypeAndValue
310 * AttributeTypeAndValue ::= SEQUENCE {
311 * type AttributeType,
312 * value AttributeValue
313 * }
314 * AttributeType ::= OBJECT IDENTIFIER
315 * AttributeValue ::= ANY DEFINED BY AttributeType
316 */
317
318 if (asn1_get_next(buf, len, &hdr) < 0 ||
319 hdr.class != ASN1_CLASS_UNIVERSAL ||
320 hdr.tag != ASN1_TAG_SEQUENCE) {
321 wpa_printf(MSG_DEBUG, "X509: Expected SEQUENCE "
322 "(Name / RDNSequencer) - found class %d tag 0x%x",
323 hdr.class, hdr.tag);
324 return -1;
325 }
326 pos = hdr.payload;
327
328 if (pos + hdr.length > buf + len)
329 return -1;
330
331 end = *next = pos + hdr.length;
332
333 while (pos < end) {
334 enum x509_name_attr_type type;
335
336 if (asn1_get_next(pos, end - pos, &hdr) < 0 ||
337 hdr.class != ASN1_CLASS_UNIVERSAL ||
338 hdr.tag != ASN1_TAG_SET) {
339 wpa_printf(MSG_DEBUG, "X509: Expected SET "
340 "(RelativeDistinguishedName) - found class "
341 "%d tag 0x%x", hdr.class, hdr.tag);
342 x509_free_name(name);
343 return -1;
344 }
345
346 set_pos = hdr.payload;
347 pos = set_end = hdr.payload + hdr.length;
348
349 if (asn1_get_next(set_pos, set_end - set_pos, &hdr) < 0 ||
350 hdr.class != ASN1_CLASS_UNIVERSAL ||
351 hdr.tag != ASN1_TAG_SEQUENCE) {
352 wpa_printf(MSG_DEBUG, "X509: Expected SEQUENCE "
353 "(AttributeTypeAndValue) - found class %d "
354 "tag 0x%x", hdr.class, hdr.tag);
355 x509_free_name(name);
356 return -1;
357 }
358
359 seq_pos = hdr.payload;
360 seq_end = hdr.payload + hdr.length;
361
362 if (asn1_get_oid(seq_pos, seq_end - seq_pos, &oid, &seq_pos)) {
363 x509_free_name(name);
364 return -1;
365 }
366
367 if (asn1_get_next(seq_pos, seq_end - seq_pos, &hdr) < 0 ||
368 hdr.class != ASN1_CLASS_UNIVERSAL) {
369 wpa_printf(MSG_DEBUG, "X509: Failed to parse "
370 "AttributeValue");
371 x509_free_name(name);
372 return -1;
373 }
374
375 /* RFC 3280:
376 * MUST: country, organization, organizational-unit,
377 * distinguished name qualifier, state or province name,
378 * common name, serial number.
379 * SHOULD: locality, title, surname, given name, initials,
380 * pseudonym, generation qualifier.
381 * MUST: domainComponent (RFC 2247).
382 */
383 type = X509_NAME_ATTR_NOT_USED;
384 if (oid.len == 4 &&
385 oid.oid[0] == 2 && oid.oid[1] == 5 && oid.oid[2] == 4) {
386 /* id-at ::= 2.5.4 */
387 switch (oid.oid[3]) {
388 case 3:
389 /* commonName */
390 type = X509_NAME_ATTR_CN;
391 break;
392 case 6:
393 /* countryName */
394 type = X509_NAME_ATTR_C;
395 break;
396 case 7:
397 /* localityName */
398 type = X509_NAME_ATTR_L;
399 break;
400 case 8:
401 /* stateOrProvinceName */
402 type = X509_NAME_ATTR_ST;
403 break;
404 case 10:
405 /* organizationName */
406 type = X509_NAME_ATTR_O;
407 break;
408 case 11:
409 /* organizationalUnitName */
410 type = X509_NAME_ATTR_OU;
411 break;
412 }
413 } else if (oid.len == 7 &&
414 oid.oid[0] == 1 && oid.oid[1] == 2 &&
415 oid.oid[2] == 840 && oid.oid[3] == 113549 &&
416 oid.oid[4] == 1 && oid.oid[5] == 9 &&
417 oid.oid[6] == 1) {
418 /* 1.2.840.113549.1.9.1 - e-mailAddress */
419 os_free(name->email);
420 name->email = os_malloc(hdr.length + 1);
421 if (name->email == NULL) {
422 x509_free_name(name);
423 return -1;
424 }
425 os_memcpy(name->email, hdr.payload, hdr.length);
426 name->email[hdr.length] = '\0';
427 continue;
428 } else if (oid.len == 7 &&
429 oid.oid[0] == 0 && oid.oid[1] == 9 &&
430 oid.oid[2] == 2342 && oid.oid[3] == 19200300 &&
431 oid.oid[4] == 100 && oid.oid[5] == 1 &&
432 oid.oid[6] == 25) {
433 /* 0.9.2342.19200300.100.1.25 - domainComponent */
434 type = X509_NAME_ATTR_DC;
435 }
436
437 if (type == X509_NAME_ATTR_NOT_USED) {
438 wpa_hexdump(MSG_DEBUG, "X509: Unrecognized OID",
439 (u8 *) oid.oid,
440 oid.len * sizeof(oid.oid[0]));
441 wpa_hexdump_ascii(MSG_MSGDUMP, "X509: Attribute Data",
442 hdr.payload, hdr.length);
443 continue;
444 }
445
446 if (name->num_attr == X509_MAX_NAME_ATTRIBUTES) {
447 wpa_printf(MSG_INFO, "X509: Too many Name attributes");
448 x509_free_name(name);
449 return -1;
450 }
451
452 val = os_malloc(hdr.length + 1);
453 if (val == NULL) {
454 x509_free_name(name);
455 return -1;
456 }
457 os_memcpy(val, hdr.payload, hdr.length);
458 val[hdr.length] = '\0';
459 if (os_strlen(val) != hdr.length) {
460 wpa_printf(MSG_INFO, "X509: Reject certificate with "
461 "embedded NUL byte in a string (%s[NUL])",
462 val);
463 x509_free_name(name);
464 return -1;
465 }
466
467 name->attr[name->num_attr].type = type;
468 name->attr[name->num_attr].value = val;
469 name->num_attr++;
470 }
471
472 return 0;
473 }
474
475
476 static char * x509_name_attr_str(enum x509_name_attr_type type)
477 {
478 switch (type) {
479 case X509_NAME_ATTR_NOT_USED:
480 return "[N/A]";
481 case X509_NAME_ATTR_DC:
482 return "DC";
483 case X509_NAME_ATTR_CN:
484 return "CN";
485 case X509_NAME_ATTR_C:
486 return "C";
487 case X509_NAME_ATTR_L:
488 return "L";
489 case X509_NAME_ATTR_ST:
490 return "ST";
491 case X509_NAME_ATTR_O:
492 return "O";
493 case X509_NAME_ATTR_OU:
494 return "OU";
495 }
496 return "?";
497 }
498
499
500 /**
501 * x509_name_string - Convert an X.509 certificate name into a string
502 * @name: Name to convert
503 * @buf: Buffer for the string
504 * @len: Maximum buffer length
505 */
506 void x509_name_string(struct x509_name *name, char *buf, size_t len)
507 {
508 char *pos, *end;
509 int ret;
510 size_t i;
511
512 if (len == 0)
513 return;
514
515 pos = buf;
516 end = buf + len;
517
518 for (i = 0; i < name->num_attr; i++) {
519 ret = os_snprintf(pos, end - pos, "%s=%s, ",
520 x509_name_attr_str(name->attr[i].type),
521 name->attr[i].value);
522 if (ret < 0 || ret >= end - pos)
523 goto done;
524 pos += ret;
525 }
526
527 if (pos > buf + 1 && pos[-1] == ' ' && pos[-2] == ',') {
528 pos--;
529 *pos = '\0';
530 pos--;
531 *pos = '\0';
532 }
533
534 if (name->email) {
535 ret = os_snprintf(pos, end - pos, "/emailAddress=%s",
536 name->email);
537 if (ret < 0 || ret >= end - pos)
538 goto done;
539 pos += ret;
540 }
541
542 done:
543 end[-1] = '\0';
544 }
545
546
547 static int x509_parse_time(const u8 *buf, size_t len, u8 asn1_tag,
548 os_time_t *val)
549 {
550 const char *pos;
551 int year, month, day, hour, min, sec;
552
553 /*
554 * Time ::= CHOICE {
555 * utcTime UTCTime,
556 * generalTime GeneralizedTime
557 * }
558 *
559 * UTCTime: YYMMDDHHMMSSZ
560 * GeneralizedTime: YYYYMMDDHHMMSSZ
561 */
562
563 pos = (const char *) buf;
564
565 switch (asn1_tag) {
566 case ASN1_TAG_UTCTIME:
567 if (len != 13 || buf[12] != 'Z') {
568 wpa_hexdump_ascii(MSG_DEBUG, "X509: Unrecognized "
569 "UTCTime format", buf, len);
570 return -1;
571 }
572 if (sscanf(pos, "%02d", &year) != 1) {
573 wpa_hexdump_ascii(MSG_DEBUG, "X509: Failed to parse "
574 "UTCTime year", buf, len);
575 return -1;
576 }
577 if (year < 50)
578 year += 2000;
579 else
580 year += 1900;
581 pos += 2;
582 break;
583 case ASN1_TAG_GENERALIZEDTIME:
584 if (len != 15 || buf[14] != 'Z') {
585 wpa_hexdump_ascii(MSG_DEBUG, "X509: Unrecognized "
586 "GeneralizedTime format", buf, len);
587 return -1;
588 }
589 if (sscanf(pos, "%04d", &year) != 1) {
590 wpa_hexdump_ascii(MSG_DEBUG, "X509: Failed to parse "
591 "GeneralizedTime year", buf, len);
592 return -1;
593 }
594 pos += 4;
595 break;
596 default:
597 wpa_printf(MSG_DEBUG, "X509: Expected UTCTime or "
598 "GeneralizedTime - found tag 0x%x", asn1_tag);
599 return -1;
600 }
601
602 if (sscanf(pos, "%02d", &month) != 1) {
603 wpa_hexdump_ascii(MSG_DEBUG, "X509: Failed to parse Time "
604 "(month)", buf, len);
605 return -1;
606 }
607 pos += 2;
608
609 if (sscanf(pos, "%02d", &day) != 1) {
610 wpa_hexdump_ascii(MSG_DEBUG, "X509: Failed to parse Time "
611 "(day)", buf, len);
612 return -1;
613 }
614 pos += 2;
615
616 if (sscanf(pos, "%02d", &hour) != 1) {
617 wpa_hexdump_ascii(MSG_DEBUG, "X509: Failed to parse Time "
618 "(hour)", buf, len);
619 return -1;
620 }
621 pos += 2;
622
623 if (sscanf(pos, "%02d", &min) != 1) {
624 wpa_hexdump_ascii(MSG_DEBUG, "X509: Failed to parse Time "
625 "(min)", buf, len);
626 return -1;
627 }
628 pos += 2;
629
630 if (sscanf(pos, "%02d", &sec) != 1) {
631 wpa_hexdump_ascii(MSG_DEBUG, "X509: Failed to parse Time "
632 "(sec)", buf, len);
633 return -1;
634 }
635
636 if (os_mktime(year, month, day, hour, min, sec, val) < 0) {
637 wpa_hexdump_ascii(MSG_DEBUG, "X509: Failed to convert Time",
638 buf, len);
639 if (year < 1970) {
640 /*
641 * At least some test certificates have been configured
642 * to use dates prior to 1970. Set the date to
643 * beginning of 1970 to handle these case.
644 */
645 wpa_printf(MSG_DEBUG, "X509: Year=%d before epoch - "
646 "assume epoch as the time", year);
647 *val = 0;
648 return 0;
649 }
650 return -1;
651 }
652
653 return 0;
654 }
655
656
657 static int x509_parse_validity(const u8 *buf, size_t len,
658 struct x509_certificate *cert, const u8 **next)
659 {
660 struct asn1_hdr hdr;
661 const u8 *pos;
662 size_t plen;
663
664 /*
665 * Validity ::= SEQUENCE {
666 * notBefore Time,
667 * notAfter Time
668 * }
669 *
670 * RFC 3280, 4.1.2.5:
671 * CAs conforming to this profile MUST always encode certificate
672 * validity dates through the year 2049 as UTCTime; certificate
673 * validity dates in 2050 or later MUST be encoded as GeneralizedTime.
674 */
675
676 if (asn1_get_next(buf, len, &hdr) < 0 ||
677 hdr.class != ASN1_CLASS_UNIVERSAL ||
678 hdr.tag != ASN1_TAG_SEQUENCE) {
679 wpa_printf(MSG_DEBUG, "X509: Expected SEQUENCE "
680 "(Validity) - found class %d tag 0x%x",
681 hdr.class, hdr.tag);
682 return -1;
683 }
684 pos = hdr.payload;
685 plen = hdr.length;
686
687 if (pos + plen > buf + len)
688 return -1;
689
690 *next = pos + plen;
691
692 if (asn1_get_next(pos, plen, &hdr) < 0 ||
693 hdr.class != ASN1_CLASS_UNIVERSAL ||
694 x509_parse_time(hdr.payload, hdr.length, hdr.tag,
695 &cert->not_before) < 0) {
696 wpa_hexdump_ascii(MSG_DEBUG, "X509: Failed to parse notBefore "
697 "Time", hdr.payload, hdr.length);
698 return -1;
699 }
700
701 pos = hdr.payload + hdr.length;
702 plen = *next - pos;
703
704 if (asn1_get_next(pos, plen, &hdr) < 0 ||
705 hdr.class != ASN1_CLASS_UNIVERSAL ||
706 x509_parse_time(hdr.payload, hdr.length, hdr.tag,
707 &cert->not_after) < 0) {
708 wpa_hexdump_ascii(MSG_DEBUG, "X509: Failed to parse notAfter "
709 "Time", hdr.payload, hdr.length);
710 return -1;
711 }
712
713 wpa_printf(MSG_MSGDUMP, "X509: Validity: notBefore: %lu notAfter: %lu",
714 (unsigned long) cert->not_before,
715 (unsigned long) cert->not_after);
716
717 return 0;
718 }
719
720
721 static int x509_id_ce_oid(struct asn1_oid *oid)
722 {
723 /* id-ce arc from X.509 for standard X.509v3 extensions */
724 return oid->len >= 4 &&
725 oid->oid[0] == 2 /* joint-iso-ccitt */ &&
726 oid->oid[1] == 5 /* ds */ &&
727 oid->oid[2] == 29 /* id-ce */;
728 }
729
730
731 static int x509_parse_ext_key_usage(struct x509_certificate *cert,
732 const u8 *pos, size_t len)
733 {
734 struct asn1_hdr hdr;
735
736 /*
737 * KeyUsage ::= BIT STRING {
738 * digitalSignature (0),
739 * nonRepudiation (1),
740 * keyEncipherment (2),
741 * dataEncipherment (3),
742 * keyAgreement (4),
743 * keyCertSign (5),
744 * cRLSign (6),
745 * encipherOnly (7),
746 * decipherOnly (8) }
747 */
748
749 if (asn1_get_next(pos, len, &hdr) < 0 ||
750 hdr.class != ASN1_CLASS_UNIVERSAL ||
751 hdr.tag != ASN1_TAG_BITSTRING ||
752 hdr.length < 1) {
753 wpa_printf(MSG_DEBUG, "X509: Expected BIT STRING in "
754 "KeyUsage; found %d tag 0x%x len %d",
755 hdr.class, hdr.tag, hdr.length);
756 return -1;
757 }
758
759 cert->extensions_present |= X509_EXT_KEY_USAGE;
760 cert->key_usage = asn1_bit_string_to_long(hdr.payload, hdr.length);
761
762 wpa_printf(MSG_DEBUG, "X509: KeyUsage 0x%lx", cert->key_usage);
763
764 return 0;
765 }
766
767
768 static int x509_parse_ext_basic_constraints(struct x509_certificate *cert,
769 const u8 *pos, size_t len)
770 {
771 struct asn1_hdr hdr;
772 unsigned long value;
773 size_t left;
774
775 /*
776 * BasicConstraints ::= SEQUENCE {
777 * cA BOOLEAN DEFAULT FALSE,
778 * pathLenConstraint INTEGER (0..MAX) OPTIONAL }
779 */
780
781 if (asn1_get_next(pos, len, &hdr) < 0 ||
782 hdr.class != ASN1_CLASS_UNIVERSAL ||
783 hdr.tag != ASN1_TAG_SEQUENCE) {
784 wpa_printf(MSG_DEBUG, "X509: Expected SEQUENCE in "
785 "BasicConstraints; found %d tag 0x%x",
786 hdr.class, hdr.tag);
787 return -1;
788 }
789
790 cert->extensions_present |= X509_EXT_BASIC_CONSTRAINTS;
791
792 if (hdr.length == 0)
793 return 0;
794
795 if (asn1_get_next(hdr.payload, hdr.length, &hdr) < 0 ||
796 hdr.class != ASN1_CLASS_UNIVERSAL) {
797 wpa_printf(MSG_DEBUG, "X509: Failed to parse "
798 "BasicConstraints");
799 return -1;
800 }
801
802 if (hdr.tag == ASN1_TAG_BOOLEAN) {
803 if (hdr.length != 1) {
804 wpa_printf(MSG_DEBUG, "X509: Unexpected "
805 "Boolean length (%u) in BasicConstraints",
806 hdr.length);
807 return -1;
808 }
809 cert->ca = hdr.payload[0];
810
811 if (hdr.payload + hdr.length == pos + len) {
812 wpa_printf(MSG_DEBUG, "X509: BasicConstraints - cA=%d",
813 cert->ca);
814 return 0;
815 }
816
817 if (asn1_get_next(hdr.payload + hdr.length, len - hdr.length,
818 &hdr) < 0 ||
819 hdr.class != ASN1_CLASS_UNIVERSAL) {
820 wpa_printf(MSG_DEBUG, "X509: Failed to parse "
821 "BasicConstraints");
822 return -1;
823 }
824 }
825
826 if (hdr.tag != ASN1_TAG_INTEGER) {
827 wpa_printf(MSG_DEBUG, "X509: Expected INTEGER in "
828 "BasicConstraints; found class %d tag 0x%x",
829 hdr.class, hdr.tag);
830 return -1;
831 }
832
833 pos = hdr.payload;
834 left = hdr.length;
835 value = 0;
836 while (left) {
837 value <<= 8;
838 value |= *pos++;
839 left--;
840 }
841
842 cert->path_len_constraint = value;
843 cert->extensions_present |= X509_EXT_PATH_LEN_CONSTRAINT;
844
845 wpa_printf(MSG_DEBUG, "X509: BasicConstraints - cA=%d "
846 "pathLenConstraint=%lu",
847 cert->ca, cert->path_len_constraint);
848
849 return 0;
850 }
851
852
853 static int x509_parse_alt_name_rfc8222(struct x509_name *name,
854 const u8 *pos, size_t len)
855 {
856 /* rfc822Name IA5String */
857 wpa_hexdump_ascii(MSG_MSGDUMP, "X509: altName - rfc822Name", pos, len);
858 os_free(name->alt_email);
859 name->alt_email = os_zalloc(len + 1);
860 if (name->alt_email == NULL)
861 return -1;
862 os_memcpy(name->alt_email, pos, len);
863 if (os_strlen(name->alt_email) != len) {
864 wpa_printf(MSG_INFO, "X509: Reject certificate with "
865 "embedded NUL byte in rfc822Name (%s[NUL])",
866 name->alt_email);
867 os_free(name->alt_email);
868 name->alt_email = NULL;
869 return -1;
870 }
871 return 0;
872 }
873
874
875 static int x509_parse_alt_name_dns(struct x509_name *name,
876 const u8 *pos, size_t len)
877 {
878 /* dNSName IA5String */
879 wpa_hexdump_ascii(MSG_MSGDUMP, "X509: altName - dNSName", pos, len);
880 os_free(name->dns);
881 name->dns = os_zalloc(len + 1);
882 if (name->dns == NULL)
883 return -1;
884 os_memcpy(name->dns, pos, len);
885 if (os_strlen(name->dns) != len) {
886 wpa_printf(MSG_INFO, "X509: Reject certificate with "
887 "embedded NUL byte in dNSName (%s[NUL])",
888 name->dns);
889 os_free(name->dns);
890 name->dns = NULL;
891 return -1;
892 }
893 return 0;
894 }
895
896
897 static int x509_parse_alt_name_uri(struct x509_name *name,
898 const u8 *pos, size_t len)
899 {
900 /* uniformResourceIdentifier IA5String */
901 wpa_hexdump_ascii(MSG_MSGDUMP,
902 "X509: altName - uniformResourceIdentifier",
903 pos, len);
904 os_free(name->uri);
905 name->uri = os_zalloc(len + 1);
906 if (name->uri == NULL)
907 return -1;
908 os_memcpy(name->uri, pos, len);
909 if (os_strlen(name->uri) != len) {
910 wpa_printf(MSG_INFO, "X509: Reject certificate with "
911 "embedded NUL byte in uniformResourceIdentifier "
912 "(%s[NUL])", name->uri);
913 os_free(name->uri);
914 name->uri = NULL;
915 return -1;
916 }
917 return 0;
918 }
919
920
921 static int x509_parse_alt_name_ip(struct x509_name *name,
922 const u8 *pos, size_t len)
923 {
924 /* iPAddress OCTET STRING */
925 wpa_hexdump(MSG_MSGDUMP, "X509: altName - iPAddress", pos, len);
926 os_free(name->ip);
927 name->ip = os_malloc(len);
928 if (name->ip == NULL)
929 return -1;
930 os_memcpy(name->ip, pos, len);
931 name->ip_len = len;
932 return 0;
933 }
934
935
936 static int x509_parse_alt_name_rid(struct x509_name *name,
937 const u8 *pos, size_t len)
938 {
939 char buf[80];
940
941 /* registeredID OBJECT IDENTIFIER */
942 if (asn1_parse_oid(pos, len, &name->rid) < 0)
943 return -1;
944
945 asn1_oid_to_str(&name->rid, buf, sizeof(buf));
946 wpa_printf(MSG_MSGDUMP, "X509: altName - registeredID: %s", buf);
947
948 return 0;
949 }
950
951
952 static int x509_parse_ext_alt_name(struct x509_name *name,
953 const u8 *pos, size_t len)
954 {
955 struct asn1_hdr hdr;
956 const u8 *p, *end;
957
958 /*
959 * GeneralNames ::= SEQUENCE SIZE (1..MAX) OF GeneralName
960 *
961 * GeneralName ::= CHOICE {
962 * otherName [0] OtherName,
963 * rfc822Name [1] IA5String,
964 * dNSName [2] IA5String,
965 * x400Address [3] ORAddress,
966 * directoryName [4] Name,
967 * ediPartyName [5] EDIPartyName,
968 * uniformResourceIdentifier [6] IA5String,
969 * iPAddress [7] OCTET STRING,
970 * registeredID [8] OBJECT IDENTIFIER }
971 *
972 * OtherName ::= SEQUENCE {
973 * type-id OBJECT IDENTIFIER,
974 * value [0] EXPLICIT ANY DEFINED BY type-id }
975 *
976 * EDIPartyName ::= SEQUENCE {
977 * nameAssigner [0] DirectoryString OPTIONAL,
978 * partyName [1] DirectoryString }
979 */
980
981 for (p = pos, end = pos + len; p < end; p = hdr.payload + hdr.length) {
982 int res;
983
984 if (asn1_get_next(p, end - p, &hdr) < 0) {
985 wpa_printf(MSG_DEBUG, "X509: Failed to parse "
986 "SubjectAltName item");
987 return -1;
988 }
989
990 if (hdr.class != ASN1_CLASS_CONTEXT_SPECIFIC)
991 continue;
992
993 switch (hdr.tag) {
994 case 1:
995 res = x509_parse_alt_name_rfc8222(name, hdr.payload,
996 hdr.length);
997 break;
998 case 2:
999 res = x509_parse_alt_name_dns(name, hdr.payload,
1000 hdr.length);
1001 break;
1002 case 6:
1003 res = x509_parse_alt_name_uri(name, hdr.payload,
1004 hdr.length);
1005 break;
1006 case 7:
1007 res = x509_parse_alt_name_ip(name, hdr.payload,
1008 hdr.length);
1009 break;
1010 case 8:
1011 res = x509_parse_alt_name_rid(name, hdr.payload,
1012 hdr.length);
1013 break;
1014 case 0: /* TODO: otherName */
1015 case 3: /* TODO: x500Address */
1016 case 4: /* TODO: directoryName */
1017 case 5: /* TODO: ediPartyName */
1018 default:
1019 res = 0;
1020 break;
1021 }
1022 if (res < 0)
1023 return res;
1024 }
1025
1026 return 0;
1027 }
1028
1029
1030 static int x509_parse_ext_subject_alt_name(struct x509_certificate *cert,
1031 const u8 *pos, size_t len)
1032 {
1033 struct asn1_hdr hdr;
1034
1035 /* SubjectAltName ::= GeneralNames */
1036
1037 if (asn1_get_next(pos, len, &hdr) < 0 ||
1038 hdr.class != ASN1_CLASS_UNIVERSAL ||
1039 hdr.tag != ASN1_TAG_SEQUENCE) {
1040 wpa_printf(MSG_DEBUG, "X509: Expected SEQUENCE in "
1041 "SubjectAltName; found %d tag 0x%x",
1042 hdr.class, hdr.tag);
1043 return -1;
1044 }
1045
1046 wpa_printf(MSG_DEBUG, "X509: SubjectAltName");
1047 cert->extensions_present |= X509_EXT_SUBJECT_ALT_NAME;
1048
1049 if (hdr.length == 0)
1050 return 0;
1051
1052 return x509_parse_ext_alt_name(&cert->subject, hdr.payload,
1053 hdr.length);
1054 }
1055
1056
1057 static int x509_parse_ext_issuer_alt_name(struct x509_certificate *cert,
1058 const u8 *pos, size_t len)
1059 {
1060 struct asn1_hdr hdr;
1061
1062 /* IssuerAltName ::= GeneralNames */
1063
1064 if (asn1_get_next(pos, len, &hdr) < 0 ||
1065 hdr.class != ASN1_CLASS_UNIVERSAL ||
1066 hdr.tag != ASN1_TAG_SEQUENCE) {
1067 wpa_printf(MSG_DEBUG, "X509: Expected SEQUENCE in "
1068 "IssuerAltName; found %d tag 0x%x",
1069 hdr.class, hdr.tag);
1070 return -1;
1071 }
1072
1073 wpa_printf(MSG_DEBUG, "X509: IssuerAltName");
1074 cert->extensions_present |= X509_EXT_ISSUER_ALT_NAME;
1075
1076 if (hdr.length == 0)
1077 return 0;
1078
1079 return x509_parse_ext_alt_name(&cert->issuer, hdr.payload,
1080 hdr.length);
1081 }
1082
1083
1084 static int x509_parse_extension_data(struct x509_certificate *cert,
1085 struct asn1_oid *oid,
1086 const u8 *pos, size_t len)
1087 {
1088 if (!x509_id_ce_oid(oid))
1089 return 1;
1090
1091 /* TODO: add other extensions required by RFC 3280, Ch 4.2:
1092 * certificate policies (section 4.2.1.5)
1093 * name constraints (section 4.2.1.11)
1094 * policy constraints (section 4.2.1.12)
1095 * extended key usage (section 4.2.1.13)
1096 * inhibit any-policy (section 4.2.1.15)
1097 */
1098 switch (oid->oid[3]) {
1099 case 15: /* id-ce-keyUsage */
1100 return x509_parse_ext_key_usage(cert, pos, len);
1101 case 17: /* id-ce-subjectAltName */
1102 return x509_parse_ext_subject_alt_name(cert, pos, len);
1103 case 18: /* id-ce-issuerAltName */
1104 return x509_parse_ext_issuer_alt_name(cert, pos, len);
1105 case 19: /* id-ce-basicConstraints */
1106 return x509_parse_ext_basic_constraints(cert, pos, len);
1107 default:
1108 return 1;
1109 }
1110 }
1111
1112
1113 static int x509_parse_extension(struct x509_certificate *cert,
1114 const u8 *pos, size_t len, const u8 **next)
1115 {
1116 const u8 *end;
1117 struct asn1_hdr hdr;
1118 struct asn1_oid oid;
1119 int critical_ext = 0, res;
1120 char buf[80];
1121
1122 /*
1123 * Extension ::= SEQUENCE {
1124 * extnID OBJECT IDENTIFIER,
1125 * critical BOOLEAN DEFAULT FALSE,
1126 * extnValue OCTET STRING
1127 * }
1128 */
1129
1130 if (asn1_get_next(pos, len, &hdr) < 0 ||
1131 hdr.class != ASN1_CLASS_UNIVERSAL ||
1132 hdr.tag != ASN1_TAG_SEQUENCE) {
1133 wpa_printf(MSG_DEBUG, "X509: Unexpected ASN.1 header in "
1134 "Extensions: class %d tag 0x%x; expected SEQUENCE",
1135 hdr.class, hdr.tag);
1136 return -1;
1137 }
1138 pos = hdr.payload;
1139 *next = end = pos + hdr.length;
1140
1141 if (asn1_get_oid(pos, end - pos, &oid, &pos) < 0) {
1142 wpa_printf(MSG_DEBUG, "X509: Unexpected ASN.1 data for "
1143 "Extension (expected OID)");
1144 return -1;
1145 }
1146
1147 if (asn1_get_next(pos, end - pos, &hdr) < 0 ||
1148 hdr.class != ASN1_CLASS_UNIVERSAL ||
1149 (hdr.tag != ASN1_TAG_BOOLEAN &&
1150 hdr.tag != ASN1_TAG_OCTETSTRING)) {
1151 wpa_printf(MSG_DEBUG, "X509: Unexpected ASN.1 header in "
1152 "Extensions: class %d tag 0x%x; expected BOOLEAN "
1153 "or OCTET STRING", hdr.class, hdr.tag);
1154 return -1;
1155 }
1156
1157 if (hdr.tag == ASN1_TAG_BOOLEAN) {
1158 if (hdr.length != 1) {
1159 wpa_printf(MSG_DEBUG, "X509: Unexpected "
1160 "Boolean length (%u)", hdr.length);
1161 return -1;
1162 }
1163 critical_ext = hdr.payload[0];
1164 pos = hdr.payload;
1165 if (asn1_get_next(pos, end - pos, &hdr) < 0 ||
1166 (hdr.class != ASN1_CLASS_UNIVERSAL &&
1167 hdr.class != ASN1_CLASS_PRIVATE) ||
1168 hdr.tag != ASN1_TAG_OCTETSTRING) {
1169 wpa_printf(MSG_DEBUG, "X509: Unexpected ASN.1 header "
1170 "in Extensions: class %d tag 0x%x; "
1171 "expected OCTET STRING",
1172 hdr.class, hdr.tag);
1173 return -1;
1174 }
1175 }
1176
1177 asn1_oid_to_str(&oid, buf, sizeof(buf));
1178 wpa_printf(MSG_DEBUG, "X509: Extension: extnID=%s critical=%d",
1179 buf, critical_ext);
1180 wpa_hexdump(MSG_MSGDUMP, "X509: extnValue", hdr.payload, hdr.length);
1181
1182 res = x509_parse_extension_data(cert, &oid, hdr.payload, hdr.length);
1183 if (res < 0)
1184 return res;
1185 if (res == 1 && critical_ext) {
1186 wpa_printf(MSG_INFO, "X509: Unknown critical extension %s",
1187 buf);
1188 return -1;
1189 }
1190
1191 return 0;
1192 }
1193
1194
1195 static int x509_parse_extensions(struct x509_certificate *cert,
1196 const u8 *pos, size_t len)
1197 {
1198 const u8 *end;
1199 struct asn1_hdr hdr;
1200
1201 /* Extensions ::= SEQUENCE SIZE (1..MAX) OF Extension */
1202
1203 if (asn1_get_next(pos, len, &hdr) < 0 ||
1204 hdr.class != ASN1_CLASS_UNIVERSAL ||
1205 hdr.tag != ASN1_TAG_SEQUENCE) {
1206 wpa_printf(MSG_DEBUG, "X509: Unexpected ASN.1 data "
1207 "for Extensions: class %d tag 0x%x; "
1208 "expected SEQUENCE", hdr.class, hdr.tag);
1209 return -1;
1210 }
1211
1212 pos = hdr.payload;
1213 end = pos + hdr.length;
1214
1215 while (pos < end) {
1216 if (x509_parse_extension(cert, pos, end - pos, &pos)
1217 < 0)
1218 return -1;
1219 }
1220
1221 return 0;
1222 }
1223
1224
1225 static int x509_parse_tbs_certificate(const u8 *buf, size_t len,
1226 struct x509_certificate *cert,
1227 const u8 **next)
1228 {
1229 struct asn1_hdr hdr;
1230 const u8 *pos, *end;
1231 size_t left;
1232 char sbuf[128];
1233 unsigned long value;
1234
1235 /* tbsCertificate TBSCertificate ::= SEQUENCE */
1236 if (asn1_get_next(buf, len, &hdr) < 0 ||
1237 hdr.class != ASN1_CLASS_UNIVERSAL ||
1238 hdr.tag != ASN1_TAG_SEQUENCE) {
1239 wpa_printf(MSG_DEBUG, "X509: tbsCertificate did not start "
1240 "with a valid SEQUENCE - found class %d tag 0x%x",
1241 hdr.class, hdr.tag);
1242 return -1;
1243 }
1244 pos = hdr.payload;
1245 end = *next = pos + hdr.length;
1246
1247 /*
1248 * version [0] EXPLICIT Version DEFAULT v1
1249 * Version ::= INTEGER { v1(0), v2(1), v3(2) }
1250 */
1251 if (asn1_get_next(pos, end - pos, &hdr) < 0)
1252 return -1;
1253 pos = hdr.payload;
1254
1255 if (hdr.class == ASN1_CLASS_CONTEXT_SPECIFIC) {
1256 if (asn1_get_next(pos, end - pos, &hdr) < 0)
1257 return -1;
1258
1259 if (hdr.class != ASN1_CLASS_UNIVERSAL ||
1260 hdr.tag != ASN1_TAG_INTEGER) {
1261 wpa_printf(MSG_DEBUG, "X509: No INTEGER tag found for "
1262 "version field - found class %d tag 0x%x",
1263 hdr.class, hdr.tag);
1264 return -1;
1265 }
1266 if (hdr.length != 1) {
1267 wpa_printf(MSG_DEBUG, "X509: Unexpected version field "
1268 "length %u (expected 1)", hdr.length);
1269 return -1;
1270 }
1271 pos = hdr.payload;
1272 left = hdr.length;
1273 value = 0;
1274 while (left) {
1275 value <<= 8;
1276 value |= *pos++;
1277 left--;
1278 }
1279
1280 cert->version = value;
1281 if (cert->version != X509_CERT_V1 &&
1282 cert->version != X509_CERT_V2 &&
1283 cert->version != X509_CERT_V3) {
1284 wpa_printf(MSG_DEBUG, "X509: Unsupported version %d",
1285 cert->version + 1);
1286 return -1;
1287 }
1288
1289 if (asn1_get_next(pos, end - pos, &hdr) < 0)
1290 return -1;
1291 } else
1292 cert->version = X509_CERT_V1;
1293 wpa_printf(MSG_MSGDUMP, "X509: Version X.509v%d", cert->version + 1);
1294
1295 /* serialNumber CertificateSerialNumber ::= INTEGER */
1296 if (hdr.class != ASN1_CLASS_UNIVERSAL ||
1297 hdr.tag != ASN1_TAG_INTEGER) {
1298 wpa_printf(MSG_DEBUG, "X509: No INTEGER tag found for "
1299 "serialNumber; class=%d tag=0x%x",
1300 hdr.class, hdr.tag);
1301 return -1;
1302 }
1303
1304 pos = hdr.payload;
1305 left = hdr.length;
1306 while (left) {
1307 cert->serial_number <<= 8;
1308 cert->serial_number |= *pos++;
1309 left--;
1310 }
1311 wpa_printf(MSG_MSGDUMP, "X509: serialNumber %lu", cert->serial_number);
1312
1313 /* signature AlgorithmIdentifier */
1314 if (x509_parse_algorithm_identifier(pos, end - pos, &cert->signature,
1315 &pos))
1316 return -1;
1317
1318 /* issuer Name */
1319 if (x509_parse_name(pos, end - pos, &cert->issuer, &pos))
1320 return -1;
1321 x509_name_string(&cert->issuer, sbuf, sizeof(sbuf));
1322 wpa_printf(MSG_MSGDUMP, "X509: issuer %s", sbuf);
1323
1324 /* validity Validity */
1325 if (x509_parse_validity(pos, end - pos, cert, &pos))
1326 return -1;
1327
1328 /* subject Name */
1329 if (x509_parse_name(pos, end - pos, &cert->subject, &pos))
1330 return -1;
1331 x509_name_string(&cert->subject, sbuf, sizeof(sbuf));
1332 wpa_printf(MSG_MSGDUMP, "X509: subject %s", sbuf);
1333
1334 /* subjectPublicKeyInfo SubjectPublicKeyInfo */
1335 if (x509_parse_public_key(pos, end - pos, cert, &pos))
1336 return -1;
1337
1338 if (pos == end)
1339 return 0;
1340
1341 if (cert->version == X509_CERT_V1)
1342 return 0;
1343
1344 if (asn1_get_next(pos, end - pos, &hdr) < 0 ||
1345 hdr.class != ASN1_CLASS_CONTEXT_SPECIFIC) {
1346 wpa_printf(MSG_DEBUG, "X509: Expected Context-Specific"
1347 " tag to parse optional tbsCertificate "
1348 "field(s); parsed class %d tag 0x%x",
1349 hdr.class, hdr.tag);
1350 return -1;
1351 }
1352
1353 if (hdr.tag == 1) {
1354 /* issuerUniqueID [1] IMPLICIT UniqueIdentifier OPTIONAL */
1355 wpa_printf(MSG_DEBUG, "X509: issuerUniqueID");
1356 /* TODO: parse UniqueIdentifier ::= BIT STRING */
1357
1358 if (hdr.payload + hdr.length == end)
1359 return 0;
1360
1361 if (asn1_get_next(pos, end - pos, &hdr) < 0 ||
1362 hdr.class != ASN1_CLASS_CONTEXT_SPECIFIC) {
1363 wpa_printf(MSG_DEBUG, "X509: Expected Context-Specific"
1364 " tag to parse optional tbsCertificate "
1365 "field(s); parsed class %d tag 0x%x",
1366 hdr.class, hdr.tag);
1367 return -1;
1368 }
1369 }
1370
1371 if (hdr.tag == 2) {
1372 /* subjectUniqueID [2] IMPLICIT UniqueIdentifier OPTIONAL */
1373 wpa_printf(MSG_DEBUG, "X509: subjectUniqueID");
1374 /* TODO: parse UniqueIdentifier ::= BIT STRING */
1375
1376 if (hdr.payload + hdr.length == end)
1377 return 0;
1378
1379 if (asn1_get_next(pos, end - pos, &hdr) < 0 ||
1380 hdr.class != ASN1_CLASS_CONTEXT_SPECIFIC) {
1381 wpa_printf(MSG_DEBUG, "X509: Expected Context-Specific"
1382 " tag to parse optional tbsCertificate "
1383 "field(s); parsed class %d tag 0x%x",
1384 hdr.class, hdr.tag);
1385 return -1;
1386 }
1387 }
1388
1389 if (hdr.tag != 3) {
1390 wpa_printf(MSG_DEBUG, "X509: Ignored unexpected "
1391 "Context-Specific tag %d in optional "
1392 "tbsCertificate fields", hdr.tag);
1393 return 0;
1394 }
1395
1396 /* extensions [3] EXPLICIT Extensions OPTIONAL */
1397
1398 if (cert->version != X509_CERT_V3) {
1399 wpa_printf(MSG_DEBUG, "X509: X.509%d certificate and "
1400 "Extensions data which are only allowed for "
1401 "version 3", cert->version + 1);
1402 return -1;
1403 }
1404
1405 if (x509_parse_extensions(cert, hdr.payload, hdr.length) < 0)
1406 return -1;
1407
1408 pos = hdr.payload + hdr.length;
1409 if (pos < end) {
1410 wpa_hexdump(MSG_DEBUG,
1411 "X509: Ignored extra tbsCertificate data",
1412 pos, end - pos);
1413 }
1414
1415 return 0;
1416 }
1417
1418
1419 static int x509_rsadsi_oid(struct asn1_oid *oid)
1420 {
1421 return oid->len >= 4 &&
1422 oid->oid[0] == 1 /* iso */ &&
1423 oid->oid[1] == 2 /* member-body */ &&
1424 oid->oid[2] == 840 /* us */ &&
1425 oid->oid[3] == 113549 /* rsadsi */;
1426 }
1427
1428
1429 static int x509_pkcs_oid(struct asn1_oid *oid)
1430 {
1431 return oid->len >= 5 &&
1432 x509_rsadsi_oid(oid) &&
1433 oid->oid[4] == 1 /* pkcs */;
1434 }
1435
1436
1437 static int x509_digest_oid(struct asn1_oid *oid)
1438 {
1439 return oid->len >= 5 &&
1440 x509_rsadsi_oid(oid) &&
1441 oid->oid[4] == 2 /* digestAlgorithm */;
1442 }
1443
1444
1445 static int x509_sha1_oid(struct asn1_oid *oid)
1446 {
1447 return oid->len == 6 &&
1448 oid->oid[0] == 1 /* iso */ &&
1449 oid->oid[1] == 3 /* identified-organization */ &&
1450 oid->oid[2] == 14 /* oiw */ &&
1451 oid->oid[3] == 3 /* secsig */ &&
1452 oid->oid[4] == 2 /* algorithms */ &&
1453 oid->oid[5] == 26 /* id-sha1 */;
1454 }
1455
1456
1457 static int x509_sha256_oid(struct asn1_oid *oid)
1458 {
1459 return oid->len == 9 &&
1460 oid->oid[0] == 2 /* joint-iso-itu-t */ &&
1461 oid->oid[1] == 16 /* country */ &&
1462 oid->oid[2] == 840 /* us */ &&
1463 oid->oid[3] == 1 /* organization */ &&
1464 oid->oid[4] == 101 /* gov */ &&
1465 oid->oid[5] == 3 /* csor */ &&
1466 oid->oid[6] == 4 /* nistAlgorithm */ &&
1467 oid->oid[7] == 2 /* hashAlgs */ &&
1468 oid->oid[8] == 1 /* sha256 */;
1469 }
1470
1471
1472 /**
1473 * x509_certificate_parse - Parse a X.509 certificate in DER format
1474 * @buf: Pointer to the X.509 certificate in DER format
1475 * @len: Buffer length
1476 * Returns: Pointer to the parsed certificate or %NULL on failure
1477 *
1478 * Caller is responsible for freeing the returned certificate by calling
1479 * x509_certificate_free().
1480 */
1481 struct x509_certificate * x509_certificate_parse(const u8 *buf, size_t len)
1482 {
1483 struct asn1_hdr hdr;
1484 const u8 *pos, *end, *hash_start;
1485 struct x509_certificate *cert;
1486
1487 cert = os_zalloc(sizeof(*cert) + len);
1488 if (cert == NULL)
1489 return NULL;
1490 os_memcpy(cert + 1, buf, len);
1491 cert->cert_start = (u8 *) (cert + 1);
1492 cert->cert_len = len;
1493
1494 pos = buf;
1495 end = buf + len;
1496
1497 /* RFC 3280 - X.509 v3 certificate / ASN.1 DER */
1498
1499 /* Certificate ::= SEQUENCE */
1500 if (asn1_get_next(pos, len, &hdr) < 0 ||
1501 hdr.class != ASN1_CLASS_UNIVERSAL ||
1502 hdr.tag != ASN1_TAG_SEQUENCE) {
1503 wpa_printf(MSG_DEBUG, "X509: Certificate did not start with "
1504 "a valid SEQUENCE - found class %d tag 0x%x",
1505 hdr.class, hdr.tag);
1506 x509_certificate_free(cert);
1507 return NULL;
1508 }
1509 pos = hdr.payload;
1510
1511 if (pos + hdr.length > end) {
1512 x509_certificate_free(cert);
1513 return NULL;
1514 }
1515
1516 if (pos + hdr.length < end) {
1517 wpa_hexdump(MSG_MSGDUMP, "X509: Ignoring extra data after DER "
1518 "encoded certificate",
1519 pos + hdr.length, end - pos + hdr.length);
1520 end = pos + hdr.length;
1521 }
1522
1523 hash_start = pos;
1524 cert->tbs_cert_start = cert->cert_start + (hash_start - buf);
1525 if (x509_parse_tbs_certificate(pos, end - pos, cert, &pos)) {
1526 x509_certificate_free(cert);
1527 return NULL;
1528 }
1529 cert->tbs_cert_len = pos - hash_start;
1530
1531 /* signatureAlgorithm AlgorithmIdentifier */
1532 if (x509_parse_algorithm_identifier(pos, end - pos,
1533 &cert->signature_alg, &pos)) {
1534 x509_certificate_free(cert);
1535 return NULL;
1536 }
1537
1538 /* signatureValue BIT STRING */
1539 if (asn1_get_next(pos, end - pos, &hdr) < 0 ||
1540 hdr.class != ASN1_CLASS_UNIVERSAL ||
1541 hdr.tag != ASN1_TAG_BITSTRING) {
1542 wpa_printf(MSG_DEBUG, "X509: Expected BITSTRING "
1543 "(signatureValue) - found class %d tag 0x%x",
1544 hdr.class, hdr.tag);
1545 x509_certificate_free(cert);
1546 return NULL;
1547 }
1548 if (hdr.length < 1) {
1549 x509_certificate_free(cert);
1550 return NULL;
1551 }
1552 pos = hdr.payload;
1553 if (*pos) {
1554 wpa_printf(MSG_DEBUG, "X509: BITSTRING - %d unused bits",
1555 *pos);
1556 /* PKCS #1 v1.5 10.2.1:
1557 * It is an error if the length in bits of the signature S is
1558 * not a multiple of eight.
1559 */
1560 x509_certificate_free(cert);
1561 return NULL;
1562 }
1563 os_free(cert->sign_value);
1564 cert->sign_value = os_malloc(hdr.length - 1);
1565 if (cert->sign_value == NULL) {
1566 wpa_printf(MSG_DEBUG, "X509: Failed to allocate memory for "
1567 "signatureValue");
1568 x509_certificate_free(cert);
1569 return NULL;
1570 }
1571 os_memcpy(cert->sign_value, pos + 1, hdr.length - 1);
1572 cert->sign_value_len = hdr.length - 1;
1573 wpa_hexdump(MSG_MSGDUMP, "X509: signature",
1574 cert->sign_value, cert->sign_value_len);
1575
1576 return cert;
1577 }
1578
1579
1580 /**
1581 * x509_certificate_check_signature - Verify certificate signature
1582 * @issuer: Issuer certificate
1583 * @cert: Certificate to be verified
1584 * Returns: 0 if cert has a valid signature that was signed by the issuer,
1585 * -1 if not
1586 */
1587 int x509_certificate_check_signature(struct x509_certificate *issuer,
1588 struct x509_certificate *cert)
1589 {
1590 struct crypto_public_key *pk;
1591 u8 *data;
1592 const u8 *pos, *end, *next, *da_end;
1593 size_t data_len;
1594 struct asn1_hdr hdr;
1595 struct asn1_oid oid;
1596 u8 hash[32];
1597 size_t hash_len;
1598
1599 if (!x509_pkcs_oid(&cert->signature.oid) ||
1600 cert->signature.oid.len != 7 ||
1601 cert->signature.oid.oid[5] != 1 /* pkcs-1 */) {
1602 wpa_printf(MSG_DEBUG, "X509: Unrecognized signature "
1603 "algorithm");
1604 return -1;
1605 }
1606
1607 pk = crypto_public_key_import(issuer->public_key,
1608 issuer->public_key_len);
1609 if (pk == NULL)
1610 return -1;
1611
1612 data_len = cert->sign_value_len;
1613 data = os_malloc(data_len);
1614 if (data == NULL) {
1615 crypto_public_key_free(pk);
1616 return -1;
1617 }
1618
1619 if (crypto_public_key_decrypt_pkcs1(pk, cert->sign_value,
1620 cert->sign_value_len, data,
1621 &data_len) < 0) {
1622 wpa_printf(MSG_DEBUG, "X509: Failed to decrypt signature");
1623 crypto_public_key_free(pk);
1624 os_free(data);
1625 return -1;
1626 }
1627 crypto_public_key_free(pk);
1628
1629 wpa_hexdump(MSG_MSGDUMP, "X509: Signature data D", data, data_len);
1630
1631 /*
1632 * PKCS #1 v1.5, 10.1.2:
1633 *
1634 * DigestInfo ::= SEQUENCE {
1635 * digestAlgorithm DigestAlgorithmIdentifier,
1636 * digest Digest
1637 * }
1638 *
1639 * DigestAlgorithmIdentifier ::= AlgorithmIdentifier
1640 *
1641 * Digest ::= OCTET STRING
1642 *
1643 */
1644 if (asn1_get_next(data, data_len, &hdr) < 0 ||
1645 hdr.class != ASN1_CLASS_UNIVERSAL ||
1646 hdr.tag != ASN1_TAG_SEQUENCE) {
1647 wpa_printf(MSG_DEBUG, "X509: Expected SEQUENCE "
1648 "(DigestInfo) - found class %d tag 0x%x",
1649 hdr.class, hdr.tag);
1650 os_free(data);
1651 return -1;
1652 }
1653
1654 pos = hdr.payload;
1655 end = pos + hdr.length;
1656
1657 /*
1658 * X.509:
1659 * AlgorithmIdentifier ::= SEQUENCE {
1660 * algorithm OBJECT IDENTIFIER,
1661 * parameters ANY DEFINED BY algorithm OPTIONAL
1662 * }
1663 */
1664
1665 if (asn1_get_next(pos, end - pos, &hdr) < 0 ||
1666 hdr.class != ASN1_CLASS_UNIVERSAL ||
1667 hdr.tag != ASN1_TAG_SEQUENCE) {
1668 wpa_printf(MSG_DEBUG, "X509: Expected SEQUENCE "
1669 "(AlgorithmIdentifier) - found class %d tag 0x%x",
1670 hdr.class, hdr.tag);
1671 os_free(data);
1672 return -1;
1673 }
1674 da_end = hdr.payload + hdr.length;
1675
1676 if (asn1_get_oid(hdr.payload, hdr.length, &oid, &next)) {
1677 wpa_printf(MSG_DEBUG, "X509: Failed to parse digestAlgorithm");
1678 os_free(data);
1679 return -1;
1680 }
1681
1682 if (x509_sha1_oid(&oid)) {
1683 if (cert->signature.oid.oid[6] !=
1684 5 /* sha-1WithRSAEncryption */) {
1685 wpa_printf(MSG_DEBUG, "X509: digestAlgorithm SHA1 "
1686 "does not match with certificate "
1687 "signatureAlgorithm (%lu)",
1688 cert->signature.oid.oid[6]);
1689 os_free(data);
1690 return -1;
1691 }
1692 goto skip_digest_oid;
1693 }
1694
1695 if (x509_sha256_oid(&oid)) {
1696 if (cert->signature.oid.oid[6] !=
1697 11 /* sha2561WithRSAEncryption */) {
1698 wpa_printf(MSG_DEBUG, "X509: digestAlgorithm SHA256 "
1699 "does not match with certificate "
1700 "signatureAlgorithm (%lu)",
1701 cert->signature.oid.oid[6]);
1702 os_free(data);
1703 return -1;
1704 }
1705 goto skip_digest_oid;
1706 }
1707
1708 if (!x509_digest_oid(&oid)) {
1709 wpa_printf(MSG_DEBUG, "X509: Unrecognized digestAlgorithm");
1710 os_free(data);
1711 return -1;
1712 }
1713 switch (oid.oid[5]) {
1714 case 5: /* md5 */
1715 if (cert->signature.oid.oid[6] != 4 /* md5WithRSAEncryption */)
1716 {
1717 wpa_printf(MSG_DEBUG, "X509: digestAlgorithm MD5 does "
1718 "not match with certificate "
1719 "signatureAlgorithm (%lu)",
1720 cert->signature.oid.oid[6]);
1721 os_free(data);
1722 return -1;
1723 }
1724 break;
1725 case 2: /* md2 */
1726 case 4: /* md4 */
1727 default:
1728 wpa_printf(MSG_DEBUG, "X509: Unsupported digestAlgorithm "
1729 "(%lu)", oid.oid[5]);
1730 os_free(data);
1731 return -1;
1732 }
1733
1734 skip_digest_oid:
1735 /* Digest ::= OCTET STRING */
1736 pos = da_end;
1737 end = data + data_len;
1738
1739 if (asn1_get_next(pos, end - pos, &hdr) < 0 ||
1740 hdr.class != ASN1_CLASS_UNIVERSAL ||
1741 hdr.tag != ASN1_TAG_OCTETSTRING) {
1742 wpa_printf(MSG_DEBUG, "X509: Expected OCTETSTRING "
1743 "(Digest) - found class %d tag 0x%x",
1744 hdr.class, hdr.tag);
1745 os_free(data);
1746 return -1;
1747 }
1748 wpa_hexdump(MSG_MSGDUMP, "X509: Decrypted Digest",
1749 hdr.payload, hdr.length);
1750
1751 switch (cert->signature.oid.oid[6]) {
1752 case 4: /* md5WithRSAEncryption */
1753 md5_vector(1, &cert->tbs_cert_start, &cert->tbs_cert_len,
1754 hash);
1755 hash_len = 16;
1756 wpa_hexdump(MSG_MSGDUMP, "X509: Certificate hash (MD5)",
1757 hash, hash_len);
1758 break;
1759 case 5: /* sha-1WithRSAEncryption */
1760 sha1_vector(1, &cert->tbs_cert_start, &cert->tbs_cert_len,
1761 hash);
1762 hash_len = 20;
1763 wpa_hexdump(MSG_MSGDUMP, "X509: Certificate hash (SHA1)",
1764 hash, hash_len);
1765 break;
1766 case 11: /* sha256WithRSAEncryption */
1767 sha256_vector(1, &cert->tbs_cert_start, &cert->tbs_cert_len,
1768 hash);
1769 hash_len = 32;
1770 wpa_hexdump(MSG_MSGDUMP, "X509: Certificate hash (SHA256)",
1771 hash, hash_len);
1772 break;
1773 case 2: /* md2WithRSAEncryption */
1774 case 12: /* sha384WithRSAEncryption */
1775 case 13: /* sha512WithRSAEncryption */
1776 default:
1777 wpa_printf(MSG_INFO, "X509: Unsupported certificate signature "
1778 "algorithm (%lu)", cert->signature.oid.oid[6]);
1779 os_free(data);
1780 return -1;
1781 }
1782
1783 if (hdr.length != hash_len ||
1784 os_memcmp(hdr.payload, hash, hdr.length) != 0) {
1785 wpa_printf(MSG_INFO, "X509: Certificate Digest does not match "
1786 "with calculated tbsCertificate hash");
1787 os_free(data);
1788 return -1;
1789 }
1790
1791 os_free(data);
1792
1793 wpa_printf(MSG_DEBUG, "X509: Certificate Digest matches with "
1794 "calculated tbsCertificate hash");
1795
1796 return 0;
1797 }
1798
1799
1800 static int x509_valid_issuer(const struct x509_certificate *cert)
1801 {
1802 if ((cert->extensions_present & X509_EXT_BASIC_CONSTRAINTS) &&
1803 !cert->ca) {
1804 wpa_printf(MSG_DEBUG, "X509: Non-CA certificate used as an "
1805 "issuer");
1806 return -1;
1807 }
1808
1809 if (cert->version == X509_CERT_V3 &&
1810 !(cert->extensions_present & X509_EXT_BASIC_CONSTRAINTS)) {
1811 wpa_printf(MSG_DEBUG, "X509: v3 CA certificate did not "
1812 "include BasicConstraints extension");
1813 return -1;
1814 }
1815
1816 if ((cert->extensions_present & X509_EXT_KEY_USAGE) &&
1817 !(cert->key_usage & X509_KEY_USAGE_KEY_CERT_SIGN)) {
1818 wpa_printf(MSG_DEBUG, "X509: Issuer certificate did not have "
1819 "keyCertSign bit in Key Usage");
1820 return -1;
1821 }
1822
1823 return 0;
1824 }
1825
1826
1827 /**
1828 * x509_certificate_chain_validate - Validate X.509 certificate chain
1829 * @trusted: List of trusted certificates
1830 * @chain: Certificate chain to be validated (first chain must be issued by
1831 * signed by the second certificate in the chain and so on)
1832 * @reason: Buffer for returning failure reason (X509_VALIDATE_*)
1833 * Returns: 0 if chain is valid, -1 if not
1834 */
1835 int x509_certificate_chain_validate(struct x509_certificate *trusted,
1836 struct x509_certificate *chain,
1837 int *reason)
1838 {
1839 long unsigned idx;
1840 int chain_trusted = 0;
1841 struct x509_certificate *cert, *trust;
1842 char buf[128];
1843 struct os_time now;
1844
1845 *reason = X509_VALIDATE_OK;
1846
1847 wpa_printf(MSG_DEBUG, "X509: Validate certificate chain");
1848 os_get_time(&now);
1849
1850 for (cert = chain, idx = 0; cert; cert = cert->next, idx++) {
1851 x509_name_string(&cert->subject, buf, sizeof(buf));
1852 wpa_printf(MSG_DEBUG, "X509: %lu: %s", idx, buf);
1853
1854 if (chain_trusted)
1855 continue;
1856
1857 if ((unsigned long) now.sec <
1858 (unsigned long) cert->not_before ||
1859 (unsigned long) now.sec >
1860 (unsigned long) cert->not_after) {
1861 wpa_printf(MSG_INFO, "X509: Certificate not valid "
1862 "(now=%lu not_before=%lu not_after=%lu)",
1863 now.sec, cert->not_before, cert->not_after);
1864 *reason = X509_VALIDATE_CERTIFICATE_EXPIRED;
1865 return -1;
1866 }
1867
1868 if (cert->next) {
1869 if (x509_name_compare(&cert->issuer,
1870 &cert->next->subject) != 0) {
1871 wpa_printf(MSG_DEBUG, "X509: Certificate "
1872 "chain issuer name mismatch");
1873 x509_name_string(&cert->issuer, buf,
1874 sizeof(buf));
1875 wpa_printf(MSG_DEBUG, "X509: cert issuer: %s",
1876 buf);
1877 x509_name_string(&cert->next->subject, buf,
1878 sizeof(buf));
1879 wpa_printf(MSG_DEBUG, "X509: next cert "
1880 "subject: %s", buf);
1881 *reason = X509_VALIDATE_CERTIFICATE_UNKNOWN;
1882 return -1;
1883 }
1884
1885 if (x509_valid_issuer(cert->next) < 0) {
1886 *reason = X509_VALIDATE_BAD_CERTIFICATE;
1887 return -1;
1888 }
1889
1890 if ((cert->next->extensions_present &
1891 X509_EXT_PATH_LEN_CONSTRAINT) &&
1892 idx > cert->next->path_len_constraint) {
1893 wpa_printf(MSG_DEBUG, "X509: pathLenConstraint"
1894 " not met (idx=%lu issuer "
1895 "pathLenConstraint=%lu)", idx,
1896 cert->next->path_len_constraint);
1897 *reason = X509_VALIDATE_BAD_CERTIFICATE;
1898 return -1;
1899 }
1900
1901 if (x509_certificate_check_signature(cert->next, cert)
1902 < 0) {
1903 wpa_printf(MSG_DEBUG, "X509: Invalid "
1904 "certificate signature within "
1905 "chain");
1906 *reason = X509_VALIDATE_BAD_CERTIFICATE;
1907 return -1;
1908 }
1909 }
1910
1911 for (trust = trusted; trust; trust = trust->next) {
1912 if (x509_name_compare(&cert->issuer, &trust->subject)
1913 == 0)
1914 break;
1915 }
1916
1917 if (trust) {
1918 wpa_printf(MSG_DEBUG, "X509: Found issuer from the "
1919 "list of trusted certificates");
1920 if (x509_valid_issuer(trust) < 0) {
1921 *reason = X509_VALIDATE_BAD_CERTIFICATE;
1922 return -1;
1923 }
1924
1925 if (x509_certificate_check_signature(trust, cert) < 0)
1926 {
1927 wpa_printf(MSG_DEBUG, "X509: Invalid "
1928 "certificate signature");
1929 *reason = X509_VALIDATE_BAD_CERTIFICATE;
1930 return -1;
1931 }
1932
1933 wpa_printf(MSG_DEBUG, "X509: Trusted certificate "
1934 "found to complete the chain");
1935 chain_trusted = 1;
1936 }
1937 }
1938
1939 if (!chain_trusted) {
1940 wpa_printf(MSG_DEBUG, "X509: Did not find any of the issuers "
1941 "from the list of trusted certificates");
1942 if (trusted) {
1943 *reason = X509_VALIDATE_UNKNOWN_CA;
1944 return -1;
1945 }
1946 wpa_printf(MSG_DEBUG, "X509: Certificate chain validation "
1947 "disabled - ignore unknown CA issue");
1948 }
1949
1950 wpa_printf(MSG_DEBUG, "X509: Certificate chain valid");
1951
1952 return 0;
1953 }
1954
1955
1956 /**
1957 * x509_certificate_get_subject - Get a certificate based on Subject name
1958 * @chain: Certificate chain to search through
1959 * @name: Subject name to search for
1960 * Returns: Pointer to the certificate with the given Subject name or
1961 * %NULL on failure
1962 */
1963 struct x509_certificate *
1964 x509_certificate_get_subject(struct x509_certificate *chain,
1965 struct x509_name *name)
1966 {
1967 struct x509_certificate *cert;
1968
1969 for (cert = chain; cert; cert = cert->next) {
1970 if (x509_name_compare(&cert->subject, name) == 0)
1971 return cert;
1972 }
1973 return NULL;
1974 }
1975
1976
1977 /**
1978 * x509_certificate_self_signed - Is the certificate self-signed?
1979 * @cert: Certificate
1980 * Returns: 1 if certificate is self-signed, 0 if not
1981 */
1982 int x509_certificate_self_signed(struct x509_certificate *cert)
1983 {
1984 return x509_name_compare(&cert->issuer, &cert->subject) == 0;
1985 }
Mirror of AROS' svn.