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