make X509_CERT_AUX opaque
[openssl.git] / crypto / x509 / x509_trs.c
1 /* x509_trs.c */
2 /*
3  * Written by Dr Stephen N Henson (steve@openssl.org) for the OpenSSL project
4  * 1999.
5  */
6 /* ====================================================================
7  * Copyright (c) 1999 The OpenSSL Project.  All rights reserved.
8  *
9  * Redistribution and use in source and binary forms, with or without
10  * modification, are permitted provided that the following conditions
11  * are met:
12  *
13  * 1. Redistributions of source code must retain the above copyright
14  *    notice, this list of conditions and the following disclaimer.
15  *
16  * 2. Redistributions in binary form must reproduce the above copyright
17  *    notice, this list of conditions and the following disclaimer in
18  *    the documentation and/or other materials provided with the
19  *    distribution.
20  *
21  * 3. All advertising materials mentioning features or use of this
22  *    software must display the following acknowledgment:
23  *    "This product includes software developed by the OpenSSL Project
24  *    for use in the OpenSSL Toolkit. (http://www.OpenSSL.org/)"
25  *
26  * 4. The names "OpenSSL Toolkit" and "OpenSSL Project" must not be used to
27  *    endorse or promote products derived from this software without
28  *    prior written permission. For written permission, please contact
29  *    licensing@OpenSSL.org.
30  *
31  * 5. Products derived from this software may not be called "OpenSSL"
32  *    nor may "OpenSSL" appear in their names without prior written
33  *    permission of the OpenSSL Project.
34  *
35  * 6. Redistributions of any form whatsoever must retain the following
36  *    acknowledgment:
37  *    "This product includes software developed by the OpenSSL Project
38  *    for use in the OpenSSL Toolkit (http://www.OpenSSL.org/)"
39  *
40  * THIS SOFTWARE IS PROVIDED BY THE OpenSSL PROJECT ``AS IS'' AND ANY
41  * EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
42  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
43  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE OpenSSL PROJECT OR
44  * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
45  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
46  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
47  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
48  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
49  * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
50  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
51  * OF THE POSSIBILITY OF SUCH DAMAGE.
52  * ====================================================================
53  *
54  * This product includes cryptographic software written by Eric Young
55  * (eay@cryptsoft.com).  This product includes software written by Tim
56  * Hudson (tjh@cryptsoft.com).
57  *
58  */
59
60 #include <stdio.h>
61 #include "internal/cryptlib.h"
62 #include <openssl/x509v3.h>
63 #include "internal/x509_int.h"
64
65 static int tr_cmp(const X509_TRUST *const *a, const X509_TRUST *const *b);
66 static void trtable_free(X509_TRUST *p);
67
68 static int trust_1oidany(X509_TRUST *trust, X509 *x, int flags);
69 static int trust_1oid(X509_TRUST *trust, X509 *x, int flags);
70 static int trust_compat(X509_TRUST *trust, X509 *x, int flags);
71
72 static int obj_trust(int id, X509 *x, int flags);
73 static int (*default_trust) (int id, X509 *x, int flags) = obj_trust;
74
75 /*
76  * WARNING: the following table should be kept in order of trust and without
77  * any gaps so we can just subtract the minimum trust value to get an index
78  * into the table
79  */
80
81 static X509_TRUST trstandard[] = {
82     {X509_TRUST_COMPAT, 0, trust_compat, "compatible", 0, NULL},
83     {X509_TRUST_SSL_CLIENT, 0, trust_1oidany, "SSL Client", NID_client_auth,
84      NULL},
85     {X509_TRUST_SSL_SERVER, 0, trust_1oidany, "SSL Server", NID_server_auth,
86      NULL},
87     {X509_TRUST_EMAIL, 0, trust_1oidany, "S/MIME email", NID_email_protect,
88      NULL},
89     {X509_TRUST_OBJECT_SIGN, 0, trust_1oidany, "Object Signer", NID_code_sign,
90      NULL},
91     {X509_TRUST_OCSP_SIGN, 0, trust_1oid, "OCSP responder", NID_OCSP_sign,
92      NULL},
93     {X509_TRUST_OCSP_REQUEST, 0, trust_1oid, "OCSP request", NID_ad_OCSP,
94      NULL},
95     {X509_TRUST_TSA, 0, trust_1oidany, "TSA server", NID_time_stamp, NULL}
96 };
97
98 #define X509_TRUST_COUNT        OSSL_NELEM(trstandard)
99
100 static STACK_OF(X509_TRUST) *trtable = NULL;
101
102 static int tr_cmp(const X509_TRUST *const *a, const X509_TRUST *const *b)
103 {
104     return (*a)->trust - (*b)->trust;
105 }
106
107 int (*X509_TRUST_set_default(int (*trust) (int, X509 *, int))) (int, X509 *,
108                                                                 int) {
109     int (*oldtrust) (int, X509 *, int);
110     oldtrust = default_trust;
111     default_trust = trust;
112     return oldtrust;
113 }
114
115 int X509_check_trust(X509 *x, int id, int flags)
116 {
117     X509_TRUST *pt;
118     int idx;
119     if (id == -1)
120         return 1;
121     /* We get this as a default value */
122     if (id == 0) {
123         int rv;
124         rv = obj_trust(NID_anyExtendedKeyUsage, x, 0);
125         if (rv != X509_TRUST_UNTRUSTED)
126             return rv;
127         return trust_compat(NULL, x, 0);
128     }
129     idx = X509_TRUST_get_by_id(id);
130     if (idx == -1)
131         return default_trust(id, x, flags);
132     pt = X509_TRUST_get0(idx);
133     return pt->check_trust(pt, x, flags);
134 }
135
136 int X509_TRUST_get_count(void)
137 {
138     if (!trtable)
139         return X509_TRUST_COUNT;
140     return sk_X509_TRUST_num(trtable) + X509_TRUST_COUNT;
141 }
142
143 X509_TRUST *X509_TRUST_get0(int idx)
144 {
145     if (idx < 0)
146         return NULL;
147     if (idx < (int)X509_TRUST_COUNT)
148         return trstandard + idx;
149     return sk_X509_TRUST_value(trtable, idx - X509_TRUST_COUNT);
150 }
151
152 int X509_TRUST_get_by_id(int id)
153 {
154     X509_TRUST tmp;
155     int idx;
156     if ((id >= X509_TRUST_MIN) && (id <= X509_TRUST_MAX))
157         return id - X509_TRUST_MIN;
158     tmp.trust = id;
159     if (!trtable)
160         return -1;
161     idx = sk_X509_TRUST_find(trtable, &tmp);
162     if (idx == -1)
163         return -1;
164     return idx + X509_TRUST_COUNT;
165 }
166
167 int X509_TRUST_set(int *t, int trust)
168 {
169     if (X509_TRUST_get_by_id(trust) == -1) {
170         X509err(X509_F_X509_TRUST_SET, X509_R_INVALID_TRUST);
171         return 0;
172     }
173     *t = trust;
174     return 1;
175 }
176
177 int X509_TRUST_add(int id, int flags, int (*ck) (X509_TRUST *, X509 *, int),
178                    char *name, int arg1, void *arg2)
179 {
180     int idx;
181     X509_TRUST *trtmp;
182     /*
183      * This is set according to what we change: application can't set it
184      */
185     flags &= ~X509_TRUST_DYNAMIC;
186     /* This will always be set for application modified trust entries */
187     flags |= X509_TRUST_DYNAMIC_NAME;
188     /* Get existing entry if any */
189     idx = X509_TRUST_get_by_id(id);
190     /* Need a new entry */
191     if (idx == -1) {
192         if ((trtmp = OPENSSL_malloc(sizeof(*trtmp))) == NULL) {
193             X509err(X509_F_X509_TRUST_ADD, ERR_R_MALLOC_FAILURE);
194             return 0;
195         }
196         trtmp->flags = X509_TRUST_DYNAMIC;
197     } else
198         trtmp = X509_TRUST_get0(idx);
199
200     /* OPENSSL_free existing name if dynamic */
201     if (trtmp->flags & X509_TRUST_DYNAMIC_NAME)
202         OPENSSL_free(trtmp->name);
203     /* dup supplied name */
204     if ((trtmp->name = BUF_strdup(name)) == NULL) {
205         X509err(X509_F_X509_TRUST_ADD, ERR_R_MALLOC_FAILURE);
206         return 0;
207     }
208     /* Keep the dynamic flag of existing entry */
209     trtmp->flags &= X509_TRUST_DYNAMIC;
210     /* Set all other flags */
211     trtmp->flags |= flags;
212
213     trtmp->trust = id;
214     trtmp->check_trust = ck;
215     trtmp->arg1 = arg1;
216     trtmp->arg2 = arg2;
217
218     /* If its a new entry manage the dynamic table */
219     if (idx == -1) {
220         if (trtable == NULL
221             && (trtable = sk_X509_TRUST_new(tr_cmp)) == NULL) {
222             X509err(X509_F_X509_TRUST_ADD, ERR_R_MALLOC_FAILURE);
223             return 0;
224         }
225         if (!sk_X509_TRUST_push(trtable, trtmp)) {
226             X509err(X509_F_X509_TRUST_ADD, ERR_R_MALLOC_FAILURE);
227             return 0;
228         }
229     }
230     return 1;
231 }
232
233 static void trtable_free(X509_TRUST *p)
234 {
235     if (!p)
236         return;
237     if (p->flags & X509_TRUST_DYNAMIC) {
238         if (p->flags & X509_TRUST_DYNAMIC_NAME)
239             OPENSSL_free(p->name);
240         OPENSSL_free(p);
241     }
242 }
243
244 void X509_TRUST_cleanup(void)
245 {
246     unsigned int i;
247     for (i = 0; i < X509_TRUST_COUNT; i++)
248         trtable_free(trstandard + i);
249     sk_X509_TRUST_pop_free(trtable, trtable_free);
250     trtable = NULL;
251 }
252
253 int X509_TRUST_get_flags(X509_TRUST *xp)
254 {
255     return xp->flags;
256 }
257
258 char *X509_TRUST_get0_name(X509_TRUST *xp)
259 {
260     return xp->name;
261 }
262
263 int X509_TRUST_get_trust(X509_TRUST *xp)
264 {
265     return xp->trust;
266 }
267
268 static int trust_1oidany(X509_TRUST *trust, X509 *x, int flags)
269 {
270     if (x->aux && (x->aux->trust || x->aux->reject))
271         return obj_trust(trust->arg1, x, flags);
272     /*
273      * we don't have any trust settings: for compatibility we return trusted
274      * if it is self signed
275      */
276     return trust_compat(trust, x, flags);
277 }
278
279 static int trust_1oid(X509_TRUST *trust, X509 *x, int flags)
280 {
281     if (x->aux)
282         return obj_trust(trust->arg1, x, flags);
283     return X509_TRUST_UNTRUSTED;
284 }
285
286 static int trust_compat(X509_TRUST *trust, X509 *x, int flags)
287 {
288     X509_check_purpose(x, -1, 0);
289     if (x->ex_flags & EXFLAG_SS)
290         return X509_TRUST_TRUSTED;
291     else
292         return X509_TRUST_UNTRUSTED;
293 }
294
295 static int obj_trust(int id, X509 *x, int flags)
296 {
297     ASN1_OBJECT *obj;
298     int i;
299     X509_CERT_AUX *ax;
300     ax = x->aux;
301     if (!ax)
302         return X509_TRUST_UNTRUSTED;
303     if (ax->reject) {
304         for (i = 0; i < sk_ASN1_OBJECT_num(ax->reject); i++) {
305             obj = sk_ASN1_OBJECT_value(ax->reject, i);
306             if (OBJ_obj2nid(obj) == id)
307                 return X509_TRUST_REJECTED;
308         }
309     }
310     if (ax->trust) {
311         for (i = 0; i < sk_ASN1_OBJECT_num(ax->trust); i++) {
312             obj = sk_ASN1_OBJECT_value(ax->trust, i);
313             if (OBJ_obj2nid(obj) == id)
314                 return X509_TRUST_TRUSTED;
315         }
316     }
317     return X509_TRUST_UNTRUSTED;
318 }