/src/openssl/crypto/x509/x509_trust.c
Line | Count | Source (jump to first uncovered line) |
1 | | /* |
2 | | * Copyright 1999-2023 The OpenSSL Project Authors. All Rights Reserved. |
3 | | * |
4 | | * Licensed under the Apache License 2.0 (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 <openssl/x509v3.h> |
13 | | #include "crypto/x509.h" |
14 | | |
15 | | static int tr_cmp(const X509_TRUST *const *a, const X509_TRUST *const *b); |
16 | | static void trtable_free(X509_TRUST *p); |
17 | | |
18 | | static int trust_1oidany(X509_TRUST *trust, X509 *x, int flags); |
19 | | static int trust_1oid(X509_TRUST *trust, X509 *x, int flags); |
20 | | static int trust_compat(X509_TRUST *trust, X509 *x, int flags); |
21 | | |
22 | | static int obj_trust(int id, X509 *x, int flags); |
23 | | static int (*default_trust) (int id, X509 *x, int flags) = obj_trust; |
24 | | |
25 | | /* |
26 | | * WARNING: the following table should be kept in order of trust and without |
27 | | * any gaps so we can just subtract the minimum trust value to get an index |
28 | | * into the table |
29 | | */ |
30 | | |
31 | | static X509_TRUST trstandard[] = { |
32 | | {X509_TRUST_COMPAT, 0, trust_compat, "compatible", 0, NULL}, |
33 | | {X509_TRUST_SSL_CLIENT, 0, trust_1oidany, "SSL Client", NID_client_auth, |
34 | | NULL}, |
35 | | {X509_TRUST_SSL_SERVER, 0, trust_1oidany, "SSL Server", NID_server_auth, |
36 | | NULL}, |
37 | | {X509_TRUST_EMAIL, 0, trust_1oidany, "S/MIME email", NID_email_protect, |
38 | | NULL}, |
39 | | {X509_TRUST_OBJECT_SIGN, 0, trust_1oidany, "Object Signer", NID_code_sign, |
40 | | NULL}, |
41 | | {X509_TRUST_OCSP_SIGN, 0, trust_1oid, "OCSP responder", NID_OCSP_sign, |
42 | | NULL}, |
43 | | {X509_TRUST_OCSP_REQUEST, 0, trust_1oid, "OCSP request", NID_ad_OCSP, |
44 | | NULL}, |
45 | | {X509_TRUST_TSA, 0, trust_1oidany, "TSA server", NID_time_stamp, NULL} |
46 | | }; |
47 | | |
48 | 0 | #define X509_TRUST_COUNT OSSL_NELEM(trstandard) |
49 | | |
50 | | static STACK_OF(X509_TRUST) *trtable = NULL; |
51 | | |
52 | | static int tr_cmp(const X509_TRUST *const *a, const X509_TRUST *const *b) |
53 | 0 | { |
54 | 0 | return (*a)->trust - (*b)->trust; |
55 | 0 | } |
56 | | |
57 | | int (*X509_TRUST_set_default(int (*trust) (int, X509 *, int))) (int, X509 *, |
58 | 0 | int) { |
59 | 0 | int (*oldtrust) (int, X509 *, int); |
60 | 0 | oldtrust = default_trust; |
61 | 0 | default_trust = trust; |
62 | 0 | return oldtrust; |
63 | 0 | } |
64 | | |
65 | | /* Returns X509_TRUST_TRUSTED, X509_TRUST_REJECTED, or X509_TRUST_UNTRUSTED */ |
66 | | int X509_check_trust(X509 *x, int id, int flags) |
67 | 0 | { |
68 | 0 | X509_TRUST *pt; |
69 | 0 | int idx; |
70 | | |
71 | | /* We get this as a default value */ |
72 | 0 | if (id == X509_TRUST_DEFAULT) |
73 | 0 | return obj_trust(NID_anyExtendedKeyUsage, x, |
74 | 0 | flags | X509_TRUST_DO_SS_COMPAT); |
75 | 0 | idx = X509_TRUST_get_by_id(id); |
76 | 0 | if (idx < 0) |
77 | 0 | return default_trust(id, x, flags); |
78 | 0 | pt = X509_TRUST_get0(idx); |
79 | 0 | return pt->check_trust(pt, x, flags); |
80 | 0 | } |
81 | | |
82 | | int X509_TRUST_get_count(void) |
83 | 0 | { |
84 | 0 | if (!trtable) |
85 | 0 | return X509_TRUST_COUNT; |
86 | 0 | return sk_X509_TRUST_num(trtable) + X509_TRUST_COUNT; |
87 | 0 | } |
88 | | |
89 | | X509_TRUST *X509_TRUST_get0(int idx) |
90 | 0 | { |
91 | 0 | if (idx < 0) |
92 | 0 | return NULL; |
93 | 0 | if (idx < (int)X509_TRUST_COUNT) |
94 | 0 | return trstandard + idx; |
95 | 0 | return sk_X509_TRUST_value(trtable, idx - X509_TRUST_COUNT); |
96 | 0 | } |
97 | | |
98 | | int X509_TRUST_get_by_id(int id) |
99 | 0 | { |
100 | 0 | X509_TRUST tmp; |
101 | 0 | int idx; |
102 | |
|
103 | 0 | if ((id >= X509_TRUST_MIN) && (id <= X509_TRUST_MAX)) |
104 | 0 | return id - X509_TRUST_MIN; |
105 | 0 | if (trtable == NULL) |
106 | 0 | return -1; |
107 | 0 | tmp.trust = id; |
108 | | /* Ideally, this would be done under lock */ |
109 | 0 | sk_X509_TRUST_sort(trtable); |
110 | 0 | idx = sk_X509_TRUST_find(trtable, &tmp); |
111 | 0 | if (idx < 0) |
112 | 0 | return -1; |
113 | 0 | return idx + X509_TRUST_COUNT; |
114 | 0 | } |
115 | | |
116 | | int X509_TRUST_set(int *t, int trust) |
117 | 0 | { |
118 | 0 | if (X509_TRUST_get_by_id(trust) < 0) { |
119 | 0 | ERR_raise(ERR_LIB_X509, X509_R_INVALID_TRUST); |
120 | 0 | return 0; |
121 | 0 | } |
122 | 0 | *t = trust; |
123 | 0 | return 1; |
124 | 0 | } |
125 | | |
126 | | int X509_TRUST_add(int id, int flags, int (*ck) (X509_TRUST *, X509 *, int), |
127 | | const char *name, int arg1, void *arg2) |
128 | 0 | { |
129 | 0 | int idx; |
130 | 0 | X509_TRUST *trtmp; |
131 | | /* |
132 | | * This is set according to what we change: application can't set it |
133 | | */ |
134 | 0 | flags &= ~X509_TRUST_DYNAMIC; |
135 | | /* This will always be set for application modified trust entries */ |
136 | 0 | flags |= X509_TRUST_DYNAMIC_NAME; |
137 | | /* Get existing entry if any */ |
138 | 0 | idx = X509_TRUST_get_by_id(id); |
139 | | /* Need a new entry */ |
140 | 0 | if (idx < 0) { |
141 | 0 | if ((trtmp = OPENSSL_malloc(sizeof(*trtmp))) == NULL) |
142 | 0 | return 0; |
143 | 0 | trtmp->flags = X509_TRUST_DYNAMIC; |
144 | 0 | } else |
145 | 0 | trtmp = X509_TRUST_get0(idx); |
146 | | |
147 | | /* OPENSSL_free existing name if dynamic */ |
148 | 0 | if (trtmp->flags & X509_TRUST_DYNAMIC_NAME) |
149 | 0 | OPENSSL_free(trtmp->name); |
150 | | /* dup supplied name */ |
151 | 0 | if ((trtmp->name = OPENSSL_strdup(name)) == NULL) |
152 | 0 | goto err; |
153 | | /* Keep the dynamic flag of existing entry */ |
154 | 0 | trtmp->flags &= X509_TRUST_DYNAMIC; |
155 | | /* Set all other flags */ |
156 | 0 | trtmp->flags |= flags; |
157 | |
|
158 | 0 | trtmp->trust = id; |
159 | 0 | trtmp->check_trust = ck; |
160 | 0 | trtmp->arg1 = arg1; |
161 | 0 | trtmp->arg2 = arg2; |
162 | | |
163 | | /* If its a new entry manage the dynamic table */ |
164 | 0 | if (idx < 0) { |
165 | 0 | if (trtable == NULL |
166 | 0 | && (trtable = sk_X509_TRUST_new(tr_cmp)) == NULL) { |
167 | 0 | ERR_raise(ERR_LIB_X509, ERR_R_CRYPTO_LIB); |
168 | 0 | goto err; |
169 | 0 | } |
170 | 0 | if (!sk_X509_TRUST_push(trtable, trtmp)) { |
171 | 0 | ERR_raise(ERR_LIB_X509, ERR_R_CRYPTO_LIB); |
172 | 0 | goto err; |
173 | 0 | } |
174 | 0 | } |
175 | 0 | return 1; |
176 | 0 | err: |
177 | 0 | if (idx < 0) { |
178 | 0 | OPENSSL_free(trtmp->name); |
179 | 0 | OPENSSL_free(trtmp); |
180 | 0 | } |
181 | 0 | return 0; |
182 | 0 | } |
183 | | |
184 | | static void trtable_free(X509_TRUST *p) |
185 | 0 | { |
186 | 0 | if (p == NULL) |
187 | 0 | return; |
188 | 0 | if (p->flags & X509_TRUST_DYNAMIC) { |
189 | 0 | if (p->flags & X509_TRUST_DYNAMIC_NAME) |
190 | 0 | OPENSSL_free(p->name); |
191 | 0 | OPENSSL_free(p); |
192 | 0 | } |
193 | 0 | } |
194 | | |
195 | | void X509_TRUST_cleanup(void) |
196 | 0 | { |
197 | 0 | sk_X509_TRUST_pop_free(trtable, trtable_free); |
198 | 0 | trtable = NULL; |
199 | 0 | } |
200 | | |
201 | | int X509_TRUST_get_flags(const X509_TRUST *xp) |
202 | 0 | { |
203 | 0 | return xp->flags; |
204 | 0 | } |
205 | | |
206 | | char *X509_TRUST_get0_name(const X509_TRUST *xp) |
207 | 0 | { |
208 | 0 | return xp->name; |
209 | 0 | } |
210 | | |
211 | | int X509_TRUST_get_trust(const X509_TRUST *xp) |
212 | 0 | { |
213 | 0 | return xp->trust; |
214 | 0 | } |
215 | | |
216 | | static int trust_1oidany(X509_TRUST *trust, X509 *x, int flags) |
217 | 0 | { |
218 | | /* |
219 | | * Declare the chain verified if the desired trust OID is not rejected in |
220 | | * any auxiliary trust info for this certificate, and the OID is either |
221 | | * expressly trusted, or else either "anyEKU" is trusted, or the |
222 | | * certificate is self-signed and X509_TRUST_NO_SS_COMPAT is not set. |
223 | | */ |
224 | 0 | flags |= X509_TRUST_DO_SS_COMPAT | X509_TRUST_OK_ANY_EKU; |
225 | 0 | return obj_trust(trust->arg1, x, flags); |
226 | 0 | } |
227 | | |
228 | | static int trust_1oid(X509_TRUST *trust, X509 *x, int flags) |
229 | 0 | { |
230 | | /* |
231 | | * Declare the chain verified only if the desired trust OID is not |
232 | | * rejected and is expressly trusted. Neither "anyEKU" nor "compat" |
233 | | * trust in self-signed certificates apply. |
234 | | */ |
235 | 0 | flags &= ~(X509_TRUST_DO_SS_COMPAT | X509_TRUST_OK_ANY_EKU); |
236 | 0 | return obj_trust(trust->arg1, x, flags); |
237 | 0 | } |
238 | | |
239 | | static int trust_compat(X509_TRUST *trust, X509 *x, int flags) |
240 | 0 | { |
241 | | /* Call for side-effect of setting EXFLAG_SS for self-signed-certs */ |
242 | 0 | if (X509_check_purpose(x, -1, 0) != 1) |
243 | 0 | return X509_TRUST_UNTRUSTED; |
244 | 0 | if ((flags & X509_TRUST_NO_SS_COMPAT) == 0 && (x->ex_flags & EXFLAG_SS)) |
245 | 0 | return X509_TRUST_TRUSTED; |
246 | 0 | else |
247 | 0 | return X509_TRUST_UNTRUSTED; |
248 | 0 | } |
249 | | |
250 | | static int obj_trust(int id, X509 *x, int flags) |
251 | 0 | { |
252 | 0 | X509_CERT_AUX *ax = x->aux; |
253 | 0 | int i; |
254 | |
|
255 | 0 | if (ax != NULL && ax->reject != NULL) { |
256 | 0 | for (i = 0; i < sk_ASN1_OBJECT_num(ax->reject); i++) { |
257 | 0 | ASN1_OBJECT *obj = sk_ASN1_OBJECT_value(ax->reject, i); |
258 | 0 | int nid = OBJ_obj2nid(obj); |
259 | |
|
260 | 0 | if (nid == id || (nid == NID_anyExtendedKeyUsage && |
261 | 0 | (flags & X509_TRUST_OK_ANY_EKU))) |
262 | 0 | return X509_TRUST_REJECTED; |
263 | 0 | } |
264 | 0 | } |
265 | | |
266 | 0 | if (ax != NULL && ax->trust != NULL) { |
267 | 0 | for (i = 0; i < sk_ASN1_OBJECT_num(ax->trust); i++) { |
268 | 0 | ASN1_OBJECT *obj = sk_ASN1_OBJECT_value(ax->trust, i); |
269 | 0 | int nid = OBJ_obj2nid(obj); |
270 | |
|
271 | 0 | if (nid == id || (nid == NID_anyExtendedKeyUsage && |
272 | 0 | (flags & X509_TRUST_OK_ANY_EKU))) |
273 | 0 | return X509_TRUST_TRUSTED; |
274 | 0 | } |
275 | | /* |
276 | | * Reject when explicit trust EKU are set and none match. |
277 | | * |
278 | | * Returning untrusted is enough for full chains that end in |
279 | | * self-signed roots, because when explicit trust is specified it |
280 | | * suppresses the default blanket trust of self-signed objects. |
281 | | * |
282 | | * But for partial chains, this is not enough, because absent a similar |
283 | | * trust-self-signed policy, non matching EKUs are indistinguishable |
284 | | * from lack of EKU constraints. |
285 | | * |
286 | | * Therefore, failure to match any trusted purpose must trigger an |
287 | | * explicit reject. |
288 | | */ |
289 | 0 | return X509_TRUST_REJECTED; |
290 | 0 | } |
291 | | |
292 | 0 | if ((flags & X509_TRUST_DO_SS_COMPAT) == 0) |
293 | 0 | return X509_TRUST_UNTRUSTED; |
294 | | |
295 | | /* |
296 | | * Not rejected, and there is no list of accepted uses, try compat. |
297 | | */ |
298 | 0 | return trust_compat(NULL, x, flags); |
299 | 0 | } |