v3_purp.c@ 86560

Last change on this file since 86560 was 86560, checked in by vboxsync, 5 years ago
openssl-1.1.1h: Applied our OpenSSL changes to 1.1.1h. Didn't check te build. bugref:9847
File size: 29.7 KB

Line
1	/*
2	* Copyright 1999-2020 The OpenSSL Project Authors. All Rights Reserved.
3	*
4	* Licensed under the OpenSSL license (the "License"). You may not use
5	* this file except in compliance with the License. You can obtain a copy
6	* in the file LICENSE in the source distribution or at
7	* https://www.openssl.org/source/license.html
8	*/
9
10	#include <stdio.h>
11	#include "internal/cryptlib.h"
12	#include "internal/numbers.h"
13	#include <openssl/x509v3.h>
14	#include <openssl/x509_vfy.h>
15	#include "crypto/x509.h"
16	#include "../x509/x509_local.h" /* for x509_signing_allowed() */
17	#include "internal/tsan_assist.h"
18
19	static void x509v3_cache_extensions(X509 *x);
20
21	static int check_ssl_ca(const X509 *x);
22	static int check_purpose_ssl_client(const X509_PURPOSE xp, const X509 x,
23	int ca);
24	static int check_purpose_ssl_server(const X509_PURPOSE xp, const X509 x,
25	int ca);
26	static int check_purpose_ns_ssl_server(const X509_PURPOSE xp, const X509 x,
27	int ca);
28	static int purpose_smime(const X509 *x, int ca);
29	static int check_purpose_smime_sign(const X509_PURPOSE xp, const X509 x,
30	int ca);
31	static int check_purpose_smime_encrypt(const X509_PURPOSE xp, const X509 x,
32	int ca);
33	static int check_purpose_crl_sign(const X509_PURPOSE xp, const X509 x,
34	int ca);
35	static int check_purpose_timestamp_sign(const X509_PURPOSE xp, const X509 x,
36	int ca);
37	static int no_check(const X509_PURPOSE xp, const X509 x, int ca);
38	static int ocsp_helper(const X509_PURPOSE xp, const X509 x, int ca);
39
40	static int xp_cmp(const X509_PURPOSE const a, const X509_PURPOSE const b);
41	static void xptable_free(X509_PURPOSE *p);
42
43	static X509_PURPOSE xstandard[] = {
44	{X509_PURPOSE_SSL_CLIENT, X509_TRUST_SSL_CLIENT, 0,
45	check_purpose_ssl_client, "SSL client", "sslclient", NULL},
46	{X509_PURPOSE_SSL_SERVER, X509_TRUST_SSL_SERVER, 0,
47	check_purpose_ssl_server, "SSL server", "sslserver", NULL},
48	{X509_PURPOSE_NS_SSL_SERVER, X509_TRUST_SSL_SERVER, 0,
49	check_purpose_ns_ssl_server, "Netscape SSL server", "nssslserver", NULL},
50	{X509_PURPOSE_SMIME_SIGN, X509_TRUST_EMAIL, 0, check_purpose_smime_sign,
51	"S/MIME signing", "smimesign", NULL},
52	{X509_PURPOSE_SMIME_ENCRYPT, X509_TRUST_EMAIL, 0,
53	check_purpose_smime_encrypt, "S/MIME encryption", "smimeencrypt", NULL},
54	{X509_PURPOSE_CRL_SIGN, X509_TRUST_COMPAT, 0, check_purpose_crl_sign,
55	"CRL signing", "crlsign", NULL},
56	{X509_PURPOSE_ANY, X509_TRUST_DEFAULT, 0, no_check, "Any Purpose", "any",
57	NULL},
58	{X509_PURPOSE_OCSP_HELPER, X509_TRUST_COMPAT, 0, ocsp_helper,
59	"OCSP helper", "ocsphelper", NULL},
60	{X509_PURPOSE_TIMESTAMP_SIGN, X509_TRUST_TSA, 0,
61	check_purpose_timestamp_sign, "Time Stamp signing", "timestampsign",
62	NULL},
63	};
64
65	#define X509_PURPOSE_COUNT OSSL_NELEM(xstandard)
66
67	static STACK_OF(X509_PURPOSE) *xptable = NULL;
68
69	static int xp_cmp(const X509_PURPOSE const a, const X509_PURPOSE const b)
70	{
71	return (a)->purpose - (b)->purpose;
72	}
73
74	/*
75	* As much as I'd like to make X509_check_purpose use a "const" X509* I
76	* really can't because it does recalculate hashes and do other non-const
77	* things.
78	*/
79	int X509_check_purpose(X509 *x, int id, int ca)
80	{
81	int idx;
82	const X509_PURPOSE *pt;
83
84	x509v3_cache_extensions(x);
85	if (x->ex_flags & EXFLAG_INVALID)
86	return -1;
87
88	/* Return if side-effect only call */
89	if (id == -1)
90	return 1;
91	idx = X509_PURPOSE_get_by_id(id);
92	if (idx == -1)
93	return -1;
94	pt = X509_PURPOSE_get0(idx);
95	return pt->check_purpose(pt, x, ca);
96	}
97
98	int X509_PURPOSE_set(int *p, int purpose)
99	{
100	if (X509_PURPOSE_get_by_id(purpose) == -1) {
101	X509V3err(X509V3_F_X509_PURPOSE_SET, X509V3_R_INVALID_PURPOSE);
102	return 0;
103	}
104	*p = purpose;
105	return 1;
106	}
107
108	int X509_PURPOSE_get_count(void)
109	{
110	if (!xptable)
111	return X509_PURPOSE_COUNT;
112	return sk_X509_PURPOSE_num(xptable) + X509_PURPOSE_COUNT;
113	}
114
115	X509_PURPOSE *X509_PURPOSE_get0(int idx)
116	{
117	if (idx < 0)
118	return NULL;
119	if (idx < (int)X509_PURPOSE_COUNT)
120	return xstandard + idx;
121	return sk_X509_PURPOSE_value(xptable, idx - X509_PURPOSE_COUNT);
122	}
123
124	int X509_PURPOSE_get_by_sname(const char *sname)
125	{
126	int i;
127	X509_PURPOSE *xptmp;
128	for (i = 0; i < X509_PURPOSE_get_count(); i++) {
129	xptmp = X509_PURPOSE_get0(i);
130	if (strcmp(xptmp->sname, sname) == 0)
131	return i;
132	}
133	return -1;
134	}
135
136	int X509_PURPOSE_get_by_id(int purpose)
137	{
138	X509_PURPOSE tmp;
139	int idx;
140
141	if ((purpose >= X509_PURPOSE_MIN) && (purpose <= X509_PURPOSE_MAX))
142	return purpose - X509_PURPOSE_MIN;
143	if (xptable == NULL)
144	return -1;
145	tmp.purpose = purpose;
146	idx = sk_X509_PURPOSE_find(xptable, &tmp);
147	if (idx < 0)
148	return -1;
149	return idx + X509_PURPOSE_COUNT;
150	}
151
152	int X509_PURPOSE_add(int id, int trust, int flags,
153	int (ck) (const X509_PURPOSE , const X509 *, int),
154	const char name, const char sname, void *arg)
155	{
156	int idx;
157	X509_PURPOSE *ptmp;
158	/*
159	* This is set according to what we change: application can't set it
160	*/
161	flags &= ~X509_PURPOSE_DYNAMIC;
162	/* This will always be set for application modified trust entries */
163	flags \|= X509_PURPOSE_DYNAMIC_NAME;
164	/* Get existing entry if any */
165	idx = X509_PURPOSE_get_by_id(id);
166	/* Need a new entry */
167	if (idx == -1) {
168	if ((ptmp = OPENSSL_malloc(sizeof(*ptmp))) == NULL) {
169	X509V3err(X509V3_F_X509_PURPOSE_ADD, ERR_R_MALLOC_FAILURE);
170	return 0;
171	}
172	ptmp->flags = X509_PURPOSE_DYNAMIC;
173	} else
174	ptmp = X509_PURPOSE_get0(idx);
175
176	/* OPENSSL_free existing name if dynamic */
177	if (ptmp->flags & X509_PURPOSE_DYNAMIC_NAME) {
178	OPENSSL_free(ptmp->name);
179	OPENSSL_free(ptmp->sname);
180	}
181	/* dup supplied name */
182	ptmp->name = OPENSSL_strdup(name);
183	ptmp->sname = OPENSSL_strdup(sname);
184	if (!ptmp->name \|\| !ptmp->sname) {
185	X509V3err(X509V3_F_X509_PURPOSE_ADD, ERR_R_MALLOC_FAILURE);
186	goto err;
187	}
188	/* Keep the dynamic flag of existing entry */
189	ptmp->flags &= X509_PURPOSE_DYNAMIC;
190	/* Set all other flags */
191	ptmp->flags \|= flags;
192
193	ptmp->purpose = id;
194	ptmp->trust = trust;
195	ptmp->check_purpose = ck;
196	ptmp->usr_data = arg;
197
198	/* If its a new entry manage the dynamic table */
199	if (idx == -1) {
200	if (xptable == NULL
201	&& (xptable = sk_X509_PURPOSE_new(xp_cmp)) == NULL) {
202	X509V3err(X509V3_F_X509_PURPOSE_ADD, ERR_R_MALLOC_FAILURE);
203	goto err;
204	}
205	if (!sk_X509_PURPOSE_push(xptable, ptmp)) {
206	X509V3err(X509V3_F_X509_PURPOSE_ADD, ERR_R_MALLOC_FAILURE);
207	goto err;
208	}
209	}
210	return 1;
211	err:
212	if (idx == -1) {
213	OPENSSL_free(ptmp->name);
214	OPENSSL_free(ptmp->sname);
215	OPENSSL_free(ptmp);
216	}
217	return 0;
218	}
219
220	static void xptable_free(X509_PURPOSE *p)
221	{
222	if (!p)
223	return;
224	if (p->flags & X509_PURPOSE_DYNAMIC) {
225	if (p->flags & X509_PURPOSE_DYNAMIC_NAME) {
226	OPENSSL_free(p->name);
227	OPENSSL_free(p->sname);
228	}
229	OPENSSL_free(p);
230	}
231	}
232
233	void X509_PURPOSE_cleanup(void)
234	{
235	sk_X509_PURPOSE_pop_free(xptable, xptable_free);
236	xptable = NULL;
237	}
238
239	int X509_PURPOSE_get_id(const X509_PURPOSE *xp)
240	{
241	return xp->purpose;
242	}
243
244	char X509_PURPOSE_get0_name(const X509_PURPOSE xp)
245	{
246	return xp->name;
247	}
248
249	char X509_PURPOSE_get0_sname(const X509_PURPOSE xp)
250	{
251	return xp->sname;
252	}
253
254	int X509_PURPOSE_get_trust(const X509_PURPOSE *xp)
255	{
256	return xp->trust;
257	}
258
259	static int nid_cmp(const int a, const int b)
260	{
261	return a - b;
262	}
263
264	DECLARE_OBJ_BSEARCH_CMP_FN(int, int, nid);
265	IMPLEMENT_OBJ_BSEARCH_CMP_FN(int, int, nid);
266
267	int X509_supported_extension(X509_EXTENSION *ex)
268	{
269	/*
270	* This table is a list of the NIDs of supported extensions: that is
271	* those which are used by the verify process. If an extension is
272	* critical and doesn't appear in this list then the verify process will
273	* normally reject the certificate. The list must be kept in numerical
274	* order because it will be searched using bsearch.
275	*/
276
277	static const int supported_nids[] = {
278	NID_netscape_cert_type, /* 71 */
279	NID_key_usage, /* 83 */
280	NID_subject_alt_name, /* 85 */
281	NID_basic_constraints, /* 87 */
282	NID_certificate_policies, /* 89 */
283	NID_crl_distribution_points, /* 103 */
284	NID_ext_key_usage, /* 126 */
285	#ifndef OPENSSL_NO_RFC3779
286	NID_sbgp_ipAddrBlock, /* 290 */
287	NID_sbgp_autonomousSysNum, /* 291 */
288	#endif
289	NID_policy_constraints, /* 401 */
290	NID_proxyCertInfo, /* 663 */
291	NID_name_constraints, /* 666 */
292	NID_policy_mappings, /* 747 */
293	NID_inhibit_any_policy /* 748 */
294	};
295
296	int ex_nid = OBJ_obj2nid(X509_EXTENSION_get_object(ex));
297
298	if (ex_nid == NID_undef)
299	return 0;
300
301	if (OBJ_bsearch_nid(&ex_nid, supported_nids, OSSL_NELEM(supported_nids)))
302	return 1;
303	return 0;
304	}
305
306	static int setup_dp(X509 x, DIST_POINT dp)
307	{
308	X509_NAME *iname = NULL;
309	int i;
310
311	if (dp->reasons) {
312	if (dp->reasons->length > 0)
313	dp->dp_reasons = dp->reasons->data[0];
314	if (dp->reasons->length > 1)
315	dp->dp_reasons \|= (dp->reasons->data[1] << 8);
316	dp->dp_reasons &= CRLDP_ALL_REASONS;
317	} else
318	dp->dp_reasons = CRLDP_ALL_REASONS;
319	if (!dp->distpoint \|\| (dp->distpoint->type != 1))
320	return 1;
321	for (i = 0; i < sk_GENERAL_NAME_num(dp->CRLissuer); i++) {
322	GENERAL_NAME *gen = sk_GENERAL_NAME_value(dp->CRLissuer, i);
323	if (gen->type == GEN_DIRNAME) {
324	iname = gen->d.directoryName;
325	break;
326	}
327	}
328	if (!iname)
329	iname = X509_get_issuer_name(x);
330
331	return DIST_POINT_set_dpname(dp->distpoint, iname);
332	}
333
334	static int setup_crldp(X509 *x)
335	{
336	int i;
337
338	x->crldp = X509_get_ext_d2i(x, NID_crl_distribution_points, &i, NULL);
339	if (x->crldp == NULL && i != -1)
340	return 0;
341	for (i = 0; i < sk_DIST_POINT_num(x->crldp); i++) {
342	if (!setup_dp(x, sk_DIST_POINT_value(x->crldp, i)))
343	return 0;
344	}
345	return 1;
346	}
347
348	/* Check that issuer public key algorithm matches subject signature algorithm */
349	static int check_sig_alg_match(const EVP_PKEY pkey, const X509 subject)
350	{
351	int pkey_nid;
352
353	if (pkey == NULL)
354	return X509_V_ERR_NO_ISSUER_PUBLIC_KEY;
355	if (OBJ_find_sigid_algs(OBJ_obj2nid(subject->cert_info.signature.algorithm),
356	NULL, &pkey_nid) == 0)
357	return X509_V_ERR_UNSUPPORTED_SIGNATURE_ALGORITHM;
358	if (EVP_PKEY_type(pkey_nid) != EVP_PKEY_base_id(pkey))
359	return X509_V_ERR_SIGNATURE_ALGORITHM_MISMATCH;
360	return X509_V_OK;
361	}
362
363	#define V1_ROOT (EXFLAG_V1\|EXFLAG_SS)
364	#define ku_reject(x, usage) \
365	(((x)->ex_flags & EXFLAG_KUSAGE) && !((x)->ex_kusage & (usage)))
366	#define xku_reject(x, usage) \
367	(((x)->ex_flags & EXFLAG_XKUSAGE) && !((x)->ex_xkusage & (usage)))
368	#define ns_reject(x, usage) \
369	(((x)->ex_flags & EXFLAG_NSCERT) && !((x)->ex_nscert & (usage)))
370
371	static void x509v3_cache_extensions(X509 *x)
372	{
373	BASIC_CONSTRAINTS *bs;
374	PROXY_CERT_INFO_EXTENSION *pci;
375	ASN1_BIT_STRING *usage;
376	ASN1_BIT_STRING *ns;
377	EXTENDED_KEY_USAGE *extusage;
378	X509_EXTENSION *ex;
379	int i;
380
381	#ifdef tsan_ld_acq
382	/* fast lock-free check, see end of the function for details. */
383	if (tsan_ld_acq((TSAN_QUALIFIER int *)&x->ex_cached))
384	return;
385	#endif
386
387	CRYPTO_THREAD_write_lock(x->lock);
388	if (x->ex_flags & EXFLAG_SET) {
389	CRYPTO_THREAD_unlock(x->lock);
390	return;
391	}
392
393	if (!X509_digest(x, EVP_sha1(), x->sha1_hash, NULL))
394	x->ex_flags \|= EXFLAG_INVALID;
395	/* V1 should mean no extensions ... */
396	if (!X509_get_version(x))
397	x->ex_flags \|= EXFLAG_V1;
398	/* Handle basic constraints */
399	if ((bs = X509_get_ext_d2i(x, NID_basic_constraints, &i, NULL))) {
400	if (bs->ca)
401	x->ex_flags \|= EXFLAG_CA;
402	if (bs->pathlen) {
403	if (bs->pathlen->type == V_ASN1_NEG_INTEGER) {
404	x->ex_flags \|= EXFLAG_INVALID;
405	x->ex_pathlen = 0;
406	} else {
407	x->ex_pathlen = ASN1_INTEGER_get(bs->pathlen);
408	if (!bs->ca && x->ex_pathlen != 0) {
409	x->ex_flags \|= EXFLAG_INVALID;
410	x->ex_pathlen = 0;
411	}
412	}
413	} else
414	x->ex_pathlen = -1;
415	BASIC_CONSTRAINTS_free(bs);
416	x->ex_flags \|= EXFLAG_BCONS;
417	} else if (i != -1) {
418	x->ex_flags \|= EXFLAG_INVALID;
419	}
420	/* Handle proxy certificates */
421	if ((pci = X509_get_ext_d2i(x, NID_proxyCertInfo, &i, NULL))) {
422	if (x->ex_flags & EXFLAG_CA
423	\|\| X509_get_ext_by_NID(x, NID_subject_alt_name, -1) >= 0
424	\|\| X509_get_ext_by_NID(x, NID_issuer_alt_name, -1) >= 0) {
425	x->ex_flags \|= EXFLAG_INVALID;
426	}
427	if (pci->pcPathLengthConstraint) {
428	x->ex_pcpathlen = ASN1_INTEGER_get(pci->pcPathLengthConstraint);
429	} else
430	x->ex_pcpathlen = -1;
431	PROXY_CERT_INFO_EXTENSION_free(pci);
432	x->ex_flags \|= EXFLAG_PROXY;
433	} else if (i != -1) {
434	x->ex_flags \|= EXFLAG_INVALID;
435	}
436	/* Handle key usage */
437	if ((usage = X509_get_ext_d2i(x, NID_key_usage, &i, NULL))) {
438	if (usage->length > 0) {
439	x->ex_kusage = usage->data[0];
440	if (usage->length > 1)
441	x->ex_kusage \|= usage->data[1] << 8;
442	} else
443	x->ex_kusage = 0;
444	x->ex_flags \|= EXFLAG_KUSAGE;
445	ASN1_BIT_STRING_free(usage);
446	} else if (i != -1) {
447	x->ex_flags \|= EXFLAG_INVALID;
448	}
449	x->ex_xkusage = 0;
450	if ((extusage = X509_get_ext_d2i(x, NID_ext_key_usage, &i, NULL))) {
451	x->ex_flags \|= EXFLAG_XKUSAGE;
452	for (i = 0; i < sk_ASN1_OBJECT_num(extusage); i++) {
453	switch (OBJ_obj2nid(sk_ASN1_OBJECT_value(extusage, i))) {
454	case NID_server_auth:
455	x->ex_xkusage \|= XKU_SSL_SERVER;
456	break;
457
458	case NID_client_auth:
459	x->ex_xkusage \|= XKU_SSL_CLIENT;
460	break;
461
462	case NID_email_protect:
463	x->ex_xkusage \|= XKU_SMIME;
464	break;
465
466	case NID_code_sign:
467	x->ex_xkusage \|= XKU_CODE_SIGN;
468	break;
469
470	case NID_ms_sgc:
471	case NID_ns_sgc:
472	x->ex_xkusage \|= XKU_SGC;
473	break;
474
475	case NID_OCSP_sign:
476	x->ex_xkusage \|= XKU_OCSP_SIGN;
477	break;
478
479	case NID_time_stamp:
480	x->ex_xkusage \|= XKU_TIMESTAMP;
481	break;
482
483	case NID_dvcs:
484	x->ex_xkusage \|= XKU_DVCS;
485	break;
486
487	case NID_anyExtendedKeyUsage:
488	x->ex_xkusage \|= XKU_ANYEKU;
489	break;
490	}
491	}
492	sk_ASN1_OBJECT_pop_free(extusage, ASN1_OBJECT_free);
493	} else if (i != -1) {
494	x->ex_flags \|= EXFLAG_INVALID;
495	}
496
497	if ((ns = X509_get_ext_d2i(x, NID_netscape_cert_type, &i, NULL))) {
498	if (ns->length > 0)
499	x->ex_nscert = ns->data[0];
500	else
501	x->ex_nscert = 0;
502	x->ex_flags \|= EXFLAG_NSCERT;
503	ASN1_BIT_STRING_free(ns);
504	} else if (i != -1) {
505	x->ex_flags \|= EXFLAG_INVALID;
506	}
507	x->skid = X509_get_ext_d2i(x, NID_subject_key_identifier, &i, NULL);
508	if (x->skid == NULL && i != -1)
509	x->ex_flags \|= EXFLAG_INVALID;
510	x->akid = X509_get_ext_d2i(x, NID_authority_key_identifier, &i, NULL);
511	if (x->akid == NULL && i != -1)
512	x->ex_flags \|= EXFLAG_INVALID;
513	/* Does subject name match issuer ? */
514	if (!X509_NAME_cmp(X509_get_subject_name(x), X509_get_issuer_name(x))) {
515	x->ex_flags \|= EXFLAG_SI; /* cert is self-issued */
516	if (X509_check_akid(x, x->akid) == X509_V_OK /* SKID matches AKID */
517	/* .. and the signature alg matches the PUBKEY alg: */
518	&& check_sig_alg_match(X509_get0_pubkey(x), x) == X509_V_OK)
519	x->ex_flags \|= EXFLAG_SS; /* indicate self-signed */
520	}
521	x->altname = X509_get_ext_d2i(x, NID_subject_alt_name, &i, NULL);
522	if (x->altname == NULL && i != -1)
523	x->ex_flags \|= EXFLAG_INVALID;
524	x->nc = X509_get_ext_d2i(x, NID_name_constraints, &i, NULL);
525	if (x->nc == NULL && i != -1)
526	x->ex_flags \|= EXFLAG_INVALID;
527	if (!setup_crldp(x))
528	x->ex_flags \|= EXFLAG_INVALID;
529
530	#ifndef OPENSSL_NO_RFC3779
531	x->rfc3779_addr = X509_get_ext_d2i(x, NID_sbgp_ipAddrBlock, &i, NULL);
532	if (x->rfc3779_addr == NULL && i != -1)
533	x->ex_flags \|= EXFLAG_INVALID;
534	x->rfc3779_asid = X509_get_ext_d2i(x, NID_sbgp_autonomousSysNum, &i, NULL);
535	if (x->rfc3779_asid == NULL && i != -1)
536	x->ex_flags \|= EXFLAG_INVALID;
537	#endif
538	for (i = 0; i < X509_get_ext_count(x); i++) {
539	ex = X509_get_ext(x, i);
540	if (OBJ_obj2nid(X509_EXTENSION_get_object(ex))
541	== NID_freshest_crl)
542	x->ex_flags \|= EXFLAG_FRESHEST;
543	if (!X509_EXTENSION_get_critical(ex))
544	continue;
545	if (!X509_supported_extension(ex)) {
546	x->ex_flags \|= EXFLAG_CRITICAL;
547	break;
548	}
549	}
550	x509_init_sig_info(x);
551	x->ex_flags \|= EXFLAG_SET;
552	#ifdef tsan_st_rel
553	tsan_st_rel((TSAN_QUALIFIER int *)&x->ex_cached, 1);
554	/*
555	* Above store triggers fast lock-free check in the beginning of the
556	* function. But one has to ensure that the structure is "stable", i.e.
557	* all stores are visible on all processors. Hence the release fence.
558	*/
559	#endif
560	CRYPTO_THREAD_unlock(x->lock);
561	}
562
563	/*-
564	* CA checks common to all purposes
565	* return codes:
566	* 0 not a CA
567	* 1 is a CA
568	* 2 Only possible in older versions of openSSL when basicConstraints are absent
569	* new versions will not return this value. May be a CA
570	* 3 basicConstraints absent but self signed V1.
571	* 4 basicConstraints absent but keyUsage present and keyCertSign asserted.
572	* 5 Netscape specific CA Flags present
573	*/
574
575	static int check_ca(const X509 *x)
576	{
577	/* keyUsage if present should allow cert signing */
578	if (ku_reject(x, KU_KEY_CERT_SIGN))
579	return 0;
580	if (x->ex_flags & EXFLAG_BCONS) {
581	if (x->ex_flags & EXFLAG_CA)
582	return 1;
583	/* If basicConstraints says not a CA then say so */
584	else
585	return 0;
586	} else {
587	/* we support V1 roots for... uh, I don't really know why. */
588	if ((x->ex_flags & V1_ROOT) == V1_ROOT)
589	return 3;
590	/*
591	* If key usage present it must have certSign so tolerate it
592	*/
593	else if (x->ex_flags & EXFLAG_KUSAGE)
594	return 4;
595	/* Older certificates could have Netscape-specific CA types */
596	else if (x->ex_flags & EXFLAG_NSCERT && x->ex_nscert & NS_ANY_CA)
597	return 5;
598	/* can this still be regarded a CA certificate? I doubt it */
599	return 0;
600	}
601	}
602
603	void X509_set_proxy_flag(X509 *x)
604	{
605	x->ex_flags \|= EXFLAG_PROXY;
606	}
607
608	void X509_set_proxy_pathlen(X509 *x, long l)
609	{
610	x->ex_pcpathlen = l;
611	}
612
613	int X509_check_ca(X509 *x)
614	{
615	x509v3_cache_extensions(x);
616
617	return check_ca(x);
618	}
619
620	/* Check SSL CA: common checks for SSL client and server */
621	static int check_ssl_ca(const X509 *x)
622	{
623	int ca_ret;
624	ca_ret = check_ca(x);
625	if (!ca_ret)
626	return 0;
627	/* check nsCertType if present */
628	if (ca_ret != 5 \|\| x->ex_nscert & NS_SSL_CA)
629	return ca_ret;
630	else
631	return 0;
632	}
633
634	static int check_purpose_ssl_client(const X509_PURPOSE xp, const X509 x,
635	int ca)
636	{
637	if (xku_reject(x, XKU_SSL_CLIENT))
638	return 0;
639	if (ca)
640	return check_ssl_ca(x);
641	/* We need to do digital signatures or key agreement */
642	if (ku_reject(x, KU_DIGITAL_SIGNATURE \| KU_KEY_AGREEMENT))
643	return 0;
644	/* nsCertType if present should allow SSL client use */
645	if (ns_reject(x, NS_SSL_CLIENT))
646	return 0;
647	return 1;
648	}
649
650	/*
651	* Key usage needed for TLS/SSL server: digital signature, encipherment or
652	* key agreement. The ssl code can check this more thoroughly for individual
653	* key types.
654	*/
655	#define KU_TLS \
656	KU_DIGITAL_SIGNATURE\|KU_KEY_ENCIPHERMENT\|KU_KEY_AGREEMENT
657
658	static int check_purpose_ssl_server(const X509_PURPOSE xp, const X509 x,
659	int ca)
660	{
661	if (xku_reject(x, XKU_SSL_SERVER \| XKU_SGC))
662	return 0;
663	if (ca)
664	return check_ssl_ca(x);
665
666	if (ns_reject(x, NS_SSL_SERVER))
667	return 0;
668	if (ku_reject(x, KU_TLS))
669	return 0;
670
671	return 1;
672
673	}
674
675	static int check_purpose_ns_ssl_server(const X509_PURPOSE xp, const X509 x,
676	int ca)
677	{
678	int ret;
679	ret = check_purpose_ssl_server(xp, x, ca);
680	if (!ret \|\| ca)
681	return ret;
682	/* We need to encipher or Netscape complains */
683	if (ku_reject(x, KU_KEY_ENCIPHERMENT))
684	return 0;
685	return ret;
686	}
687
688	/* common S/MIME checks */
689	static int purpose_smime(const X509 *x, int ca)
690	{
691	if (xku_reject(x, XKU_SMIME))
692	return 0;
693	if (ca) {
694	int ca_ret;
695	ca_ret = check_ca(x);
696	if (!ca_ret)
697	return 0;
698	/* check nsCertType if present */
699	if (ca_ret != 5 \|\| x->ex_nscert & NS_SMIME_CA)
700	return ca_ret;
701	else
702	return 0;
703	}
704	if (x->ex_flags & EXFLAG_NSCERT) {
705	if (x->ex_nscert & NS_SMIME)
706	return 1;
707	/* Workaround for some buggy certificates */
708	if (x->ex_nscert & NS_SSL_CLIENT)
709	return 2;
710	return 0;
711	}
712	return 1;
713	}
714
715	static int check_purpose_smime_sign(const X509_PURPOSE xp, const X509 x,
716	int ca)
717	{
718	int ret;
719	ret = purpose_smime(x, ca);
720	if (!ret \|\| ca)
721	return ret;
722	if (ku_reject(x, KU_DIGITAL_SIGNATURE \| KU_NON_REPUDIATION))
723	return 0;
724	return ret;
725	}
726
727	static int check_purpose_smime_encrypt(const X509_PURPOSE xp, const X509 x,
728	int ca)
729	{
730	int ret;
731	ret = purpose_smime(x, ca);
732	if (!ret \|\| ca)
733	return ret;
734	if (ku_reject(x, KU_KEY_ENCIPHERMENT))
735	return 0;
736	return ret;
737	}
738
739	static int check_purpose_crl_sign(const X509_PURPOSE xp, const X509 x,
740	int ca)
741	{
742	if (ca) {
743	int ca_ret;
744	if ((ca_ret = check_ca(x)) != 2)
745	return ca_ret;
746	else
747	return 0;
748	}
749	if (ku_reject(x, KU_CRL_SIGN))
750	return 0;
751	return 1;
752	}
753
754	/*
755	* OCSP helper: this is not a full OCSP check. It just checks that each CA
756	* is valid. Additional checks must be made on the chain.
757	*/
758
759	static int ocsp_helper(const X509_PURPOSE xp, const X509 x, int ca)
760	{
761	/*
762	* Must be a valid CA. Should we really support the "I don't know" value
763	* (2)?
764	*/
765	if (ca)
766	return check_ca(x);
767	/* leaf certificate is checked in OCSP_verify() */
768	return 1;
769	}
770
771	static int check_purpose_timestamp_sign(const X509_PURPOSE xp, const X509 x,
772	int ca)
773	{
774	int i_ext;
775
776	/* If ca is true we must return if this is a valid CA certificate. */
777	if (ca)
778	return check_ca(x);
779
780	/*
781	* Check the optional key usage field:
782	* if Key Usage is present, it must be one of digitalSignature
783	* and/or nonRepudiation (other values are not consistent and shall
784	* be rejected).
785	*/
786	if ((x->ex_flags & EXFLAG_KUSAGE)
787	&& ((x->ex_kusage & ~(KU_NON_REPUDIATION \| KU_DIGITAL_SIGNATURE)) \|\|
788	!(x->ex_kusage & (KU_NON_REPUDIATION \| KU_DIGITAL_SIGNATURE))))
789	return 0;
790
791	/* Only time stamp key usage is permitted and it's required. */
792	if (!(x->ex_flags & EXFLAG_XKUSAGE) \|\| x->ex_xkusage != XKU_TIMESTAMP)
793	return 0;
794
795	/* Extended Key Usage MUST be critical */
796	i_ext = X509_get_ext_by_NID(x, NID_ext_key_usage, -1);
797	if (i_ext >= 0) {
798	X509_EXTENSION ext = X509_get_ext((X509 )x, i_ext);
799	if (!X509_EXTENSION_get_critical(ext))
800	return 0;
801	}
802
803	return 1;
804	}
805
806	static int no_check(const X509_PURPOSE xp, const X509 x, int ca)
807	{
808	return 1;
809	}
810
811	/*-
812	* Check if certificate I<issuer> is allowed to issue certificate I<subject>
813	* according to the B<keyUsage> field of I<issuer> if present
814	* depending on any proxyCertInfo extension of I<subject>.
815	* Returns 0 for OK, or positive for reason for rejection
816	* where reason codes match those for X509_verify_cert().
817	*/
818	int x509_signing_allowed(const X509 issuer, const X509 subject)
819	{
820	if (subject->ex_flags & EXFLAG_PROXY) {
821	if (ku_reject(issuer, KU_DIGITAL_SIGNATURE))
822	return X509_V_ERR_KEYUSAGE_NO_DIGITAL_SIGNATURE;
823	} else if (ku_reject(issuer, KU_KEY_CERT_SIGN))
824	return X509_V_ERR_KEYUSAGE_NO_CERTSIGN;
825	return X509_V_OK;
826	}
827
828	/*-
829	* Various checks to see if one certificate issued the second.
830	* This can be used to prune a set of possible issuer certificates
831	* which have been looked up using some simple method such as by
832	* subject name.
833	* These are:
834	* 1. Check issuer_name(subject) == subject_name(issuer)
835	* 2. If akid(subject) exists check it matches issuer
836	* 3. Check that issuer public key algorithm matches subject signature algorithm
837	* 4. If key_usage(issuer) exists check it supports certificate signing
838	* returns 0 for OK, positive for reason for mismatch, reasons match
839	* codes for X509_verify_cert()
840	*/
841
842	int X509_check_issued(X509 issuer, X509 subject)
843	{
844	int ret;
845
846	if ((ret = x509_likely_issued(issuer, subject)) != X509_V_OK)
847	return ret;
848	return x509_signing_allowed(issuer, subject);
849	}
850
851	/* do the checks 1., 2., and 3. as described above for X509_check_issued() */
852	int x509_likely_issued(X509 issuer, X509 subject)
853	{
854	if (X509_NAME_cmp(X509_get_subject_name(issuer),
855	X509_get_issuer_name(subject)))
856	return X509_V_ERR_SUBJECT_ISSUER_MISMATCH;
857
858	x509v3_cache_extensions(issuer);
859	if (issuer->ex_flags & EXFLAG_INVALID)
860	return X509_V_ERR_UNSPECIFIED;
861	x509v3_cache_extensions(subject);
862	if (subject->ex_flags & EXFLAG_INVALID)
863	return X509_V_ERR_UNSPECIFIED;
864
865	if (subject->akid) {
866	int ret = X509_check_akid(issuer, subject->akid);
867	if (ret != X509_V_OK)
868	return ret;
869	}
870
871	/* check if the subject signature alg matches the issuer's PUBKEY alg */
872	return check_sig_alg_match(X509_get0_pubkey(issuer), subject);
873	}
874
875	int X509_check_akid(X509 issuer, AUTHORITY_KEYID akid)
876	{
877
878	if (!akid)
879	return X509_V_OK;
880
881	/* Check key ids (if present) */
882	if (akid->keyid && issuer->skid &&
883	ASN1_OCTET_STRING_cmp(akid->keyid, issuer->skid))
884	return X509_V_ERR_AKID_SKID_MISMATCH;
885	/* Check serial number */
886	if (akid->serial &&
887	ASN1_INTEGER_cmp(X509_get_serialNumber(issuer), akid->serial))
888	return X509_V_ERR_AKID_ISSUER_SERIAL_MISMATCH;
889	/* Check issuer name */
890	if (akid->issuer) {
891	/*
892	* Ugh, for some peculiar reason AKID includes SEQUENCE OF
893	* GeneralName. So look for a DirName. There may be more than one but
894	* we only take any notice of the first.
895	*/
896	GENERAL_NAMES *gens;
897	GENERAL_NAME *gen;
898	X509_NAME *nm = NULL;
899	int i;
900	gens = akid->issuer;
901	for (i = 0; i < sk_GENERAL_NAME_num(gens); i++) {
902	gen = sk_GENERAL_NAME_value(gens, i);
903	if (gen->type == GEN_DIRNAME) {
904	nm = gen->d.dirn;
905	break;
906	}
907	}
908	if (nm && X509_NAME_cmp(nm, X509_get_issuer_name(issuer)))
909	return X509_V_ERR_AKID_ISSUER_SERIAL_MISMATCH;
910	}
911	return X509_V_OK;
912	}
913
914	uint32_t X509_get_extension_flags(X509 *x)
915	{
916	/* Call for side-effect of computing hash and caching extensions */
917	X509_check_purpose(x, -1, -1);
918	return x->ex_flags;
919	}
920
921	uint32_t X509_get_key_usage(X509 *x)
922	{
923	/* Call for side-effect of computing hash and caching extensions */
924	if (X509_check_purpose(x, -1, -1) != 1)
925	return 0;
926	if (x->ex_flags & EXFLAG_KUSAGE)
927	return x->ex_kusage;
928	return UINT32_MAX;
929	}
930
931	uint32_t X509_get_extended_key_usage(X509 *x)
932	{
933	/* Call for side-effect of computing hash and caching extensions */
934	if (X509_check_purpose(x, -1, -1) != 1)
935	return 0;
936	if (x->ex_flags & EXFLAG_XKUSAGE)
937	return x->ex_xkusage;
938	return UINT32_MAX;
939	}
940
941	const ASN1_OCTET_STRING X509_get0_subject_key_id(X509 x)
942	{
943	/* Call for side-effect of computing hash and caching extensions */
944	if (X509_check_purpose(x, -1, -1) != 1)
945	return NULL;
946	return x->skid;
947	}
948
949	const ASN1_OCTET_STRING X509_get0_authority_key_id(X509 x)
950	{
951	/* Call for side-effect of computing hash and caching extensions */
952	if (X509_check_purpose(x, -1, -1) != 1)
953	return NULL;
954	return (x->akid != NULL ? x->akid->keyid : NULL);
955	}
956
957	const GENERAL_NAMES X509_get0_authority_issuer(X509 x)
958	{
959	/* Call for side-effect of computing hash and caching extensions */
960	if (X509_check_purpose(x, -1, -1) != 1)
961	return NULL;
962	return (x->akid != NULL ? x->akid->issuer : NULL);
963	}
964
965	const ASN1_INTEGER X509_get0_authority_serial(X509 x)
966	{
967	/* Call for side-effect of computing hash and caching extensions */
968	if (X509_check_purpose(x, -1, -1) != 1)
969	return NULL;
970	return (x->akid != NULL ? x->akid->serial : NULL);
971	}
972
973	long X509_get_pathlen(X509 *x)
974	{
975	/* Called for side effect of caching extensions */
976	if (X509_check_purpose(x, -1, -1) != 1
977	\|\| (x->ex_flags & EXFLAG_BCONS) == 0)
978	return -1;
979	return x->ex_pathlen;
980	}
981
982	long X509_get_proxy_pathlen(X509 *x)
983	{
984	/* Called for side effect of caching extensions */
985	if (X509_check_purpose(x, -1, -1) != 1
986	\|\| (x->ex_flags & EXFLAG_PROXY) == 0)
987	return -1;
988	return x->ex_pcpathlen;
989	}

Note: See TracBrowser for help on using the repository browser.

source: vbox/trunk/src/libs/openssl-1.1.1h/crypto/x509v3/v3_purp.c@ 86560

Download in other formats: