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