xref: /openssl/test/verify_extra_test.c (revision fecb3aae)
1 /*
2  * Copyright 2015-2022 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 <string.h>
12 #include <openssl/crypto.h>
13 #include <openssl/bio.h>
14 #include <openssl/x509.h>
15 #include <openssl/x509v3.h>
16 #include <openssl/pem.h>
17 #include <openssl/err.h>
18 #include "testutil.h"
19 
20 static const char *certs_dir;
21 static char *root_f = NULL;
22 static char *roots_f = NULL;
23 static char *untrusted_f = NULL;
24 static char *bad_f = NULL;
25 static char *req_f = NULL;
26 static char *sroot_cert = NULL;
27 static char *ca_cert = NULL;
28 static char *ee_cert = NULL;
29 
30 #define load_cert_from_file(file) load_cert_pem(file, NULL)
31 
32 /*-
33  * Test for CVE-2015-1793 (Alternate Chains Certificate Forgery)
34  *
35  * Chain is as follows:
36  *
37  * rootCA (self-signed)
38  *   |
39  * interCA
40  *   |
41  * subinterCA       subinterCA (self-signed)
42  *   |                   |
43  * leaf ------------------
44  *   |
45  * bad
46  *
47  * rootCA, interCA, subinterCA, subinterCA (ss) all have CA=TRUE
48  * leaf and bad have CA=FALSE
49  *
50  * subinterCA and subinterCA (ss) have the same subject name and keys
51  *
52  * interCA (but not rootCA) and subinterCA (ss) are in the trusted store
53  * (roots.pem)
54  * leaf and subinterCA are in the untrusted list (untrusted.pem)
55  * bad is the certificate being verified (bad.pem)
56  *
57  * Versions vulnerable to CVE-2015-1793 will fail to detect that leaf has
58  * CA=FALSE, and will therefore incorrectly verify bad
59  *
60  */
test_alt_chains_cert_forgery(void)61 static int test_alt_chains_cert_forgery(void)
62 {
63     int ret = 0;
64     int i;
65     X509 *x = NULL;
66     STACK_OF(X509) *untrusted = NULL;
67     X509_STORE_CTX *sctx = NULL;
68     X509_STORE *store = NULL;
69     X509_LOOKUP *lookup = NULL;
70 
71     store = X509_STORE_new();
72     if (store == NULL)
73         goto err;
74 
75     lookup = X509_STORE_add_lookup(store, X509_LOOKUP_file());
76     if (lookup == NULL)
77         goto err;
78     if (!X509_LOOKUP_load_file(lookup, roots_f, X509_FILETYPE_PEM))
79         goto err;
80 
81     untrusted = load_certs_pem(untrusted_f);
82 
83     if ((x = load_cert_from_file(bad_f)) == NULL)
84         goto err;
85 
86     sctx = X509_STORE_CTX_new();
87     if (sctx == NULL)
88         goto err;
89 
90     if (!X509_STORE_CTX_init(sctx, store, x, untrusted))
91         goto err;
92 
93     i = X509_verify_cert(sctx);
94 
95     if (i == 0 && X509_STORE_CTX_get_error(sctx) == X509_V_ERR_INVALID_CA) {
96         /* This is the result we were expecting: Test passed */
97         ret = 1;
98     }
99  err:
100     X509_STORE_CTX_free(sctx);
101     X509_free(x);
102     OSSL_STACK_OF_X509_free(untrusted);
103     X509_STORE_free(store);
104     return ret;
105 }
106 
test_distinguishing_id(void)107 static int test_distinguishing_id(void)
108 {
109     X509 *x = NULL;
110     int ret = 0;
111     ASN1_OCTET_STRING *v = NULL, *v2 = NULL;
112     char *distid = "this is an ID";
113 
114     x = load_cert_from_file(bad_f);
115     if (x == NULL)
116         goto err;
117 
118     v = ASN1_OCTET_STRING_new();
119     if (v == NULL)
120         goto err;
121 
122     if (!ASN1_OCTET_STRING_set(v, (unsigned char *)distid,
123                                (int)strlen(distid))) {
124         ASN1_OCTET_STRING_free(v);
125         goto err;
126     }
127 
128     X509_set0_distinguishing_id(x, v);
129 
130     v2 = X509_get0_distinguishing_id(x);
131     if (!TEST_ptr(v2)
132             || !TEST_int_eq(ASN1_OCTET_STRING_cmp(v, v2), 0))
133         goto err;
134 
135     ret = 1;
136  err:
137     X509_free(x);
138     return ret;
139 }
140 
test_req_distinguishing_id(void)141 static int test_req_distinguishing_id(void)
142 {
143     X509_REQ *x = NULL;
144     BIO *bio = NULL;
145     int ret = 0;
146     ASN1_OCTET_STRING *v = NULL, *v2 = NULL;
147     char *distid = "this is an ID";
148 
149     bio = BIO_new_file(req_f, "r");
150     if (bio == NULL)
151         goto err;
152 
153     x = PEM_read_bio_X509_REQ(bio, NULL, 0, NULL);
154     if (x == NULL)
155         goto err;
156 
157     v = ASN1_OCTET_STRING_new();
158     if (v == NULL)
159         goto err;
160 
161     if (!ASN1_OCTET_STRING_set(v, (unsigned char *)distid,
162                                (int)strlen(distid))) {
163         ASN1_OCTET_STRING_free(v);
164         goto err;
165     }
166 
167     X509_REQ_set0_distinguishing_id(x, v);
168 
169     v2 = X509_REQ_get0_distinguishing_id(x);
170     if (!TEST_ptr(v2)
171             || !TEST_int_eq(ASN1_OCTET_STRING_cmp(v, v2), 0))
172         goto err;
173 
174     ret = 1;
175  err:
176     X509_REQ_free(x);
177     BIO_free(bio);
178     return ret;
179 }
180 
test_self_signed(const char * filename,int use_trusted,int expected)181 static int test_self_signed(const char *filename, int use_trusted, int expected)
182 {
183     X509 *cert = load_cert_from_file(filename); /* may result in NULL */
184     STACK_OF(X509) *trusted = sk_X509_new_null();
185     X509_STORE_CTX *ctx = X509_STORE_CTX_new();
186     int ret;
187 
188     ret = TEST_int_eq(X509_self_signed(cert, 1), expected);
189 
190     if (cert != NULL) {
191         if (use_trusted)
192             ret = ret && TEST_true(sk_X509_push(trusted, cert));
193         ret = ret && TEST_true(X509_STORE_CTX_init(ctx, NULL, cert, NULL));
194         X509_STORE_CTX_set0_trusted_stack(ctx, trusted);
195         ret = ret && TEST_int_eq(X509_verify_cert(ctx), expected);
196     }
197 
198     X509_STORE_CTX_free(ctx);
199     sk_X509_free(trusted);
200     X509_free(cert);
201     return ret;
202 }
203 
test_self_signed_good(void)204 static int test_self_signed_good(void)
205 {
206     return test_self_signed(root_f, 1, 1);
207 }
208 
test_self_signed_bad(void)209 static int test_self_signed_bad(void)
210 {
211     return test_self_signed(bad_f, 1, 0);
212 }
213 
test_self_signed_error(void)214 static int test_self_signed_error(void)
215 {
216     return test_self_signed("nonexistent file name", 1, -1);
217 }
218 
test_store_ctx(void)219 static int test_store_ctx(void)
220 {
221     /* Verifying a cert where we have no trusted certs should fail */
222     return test_self_signed(bad_f, 0, 0);
223 }
224 
do_test_purpose(int purpose,int expected)225 static int do_test_purpose(int purpose, int expected)
226 {
227     X509 *eecert = load_cert_from_file(ee_cert); /* may result in NULL */
228     X509 *untrcert = load_cert_from_file(ca_cert);
229     X509 *trcert = load_cert_from_file(sroot_cert);
230     STACK_OF(X509) *trusted = sk_X509_new_null();
231     STACK_OF(X509) *untrusted = sk_X509_new_null();
232     X509_STORE_CTX *ctx = X509_STORE_CTX_new();
233     int testresult = 0;
234 
235     if (!TEST_ptr(eecert)
236             || !TEST_ptr(untrcert)
237             || !TEST_ptr(trcert)
238             || !TEST_ptr(trusted)
239             || !TEST_ptr(untrusted)
240             || !TEST_ptr(ctx))
241         goto err;
242 
243 
244     if (!TEST_true(sk_X509_push(trusted, trcert)))
245         goto err;
246     trcert = NULL;
247     if (!TEST_true(sk_X509_push(untrusted, untrcert)))
248         goto err;
249     untrcert = NULL;
250 
251     if (!TEST_true(X509_STORE_CTX_init(ctx, NULL, eecert, untrusted)))
252         goto err;
253 
254     if (!TEST_true(X509_STORE_CTX_set_purpose(ctx, purpose)))
255         goto err;
256 
257     /*
258      * X509_STORE_CTX_set0_trusted_stack() is bady named. Despite the set0 name
259      * we are still responsible for freeing trusted after we have finished with
260      * it.
261      */
262     X509_STORE_CTX_set0_trusted_stack(ctx, trusted);
263 
264     if (!TEST_int_eq(X509_verify_cert(ctx), expected))
265         goto err;
266 
267     testresult = 1;
268  err:
269     OSSL_STACK_OF_X509_free(trusted);
270     OSSL_STACK_OF_X509_free(untrusted);
271     X509_STORE_CTX_free(ctx);
272     X509_free(eecert);
273     X509_free(untrcert);
274     X509_free(trcert);
275     return testresult;
276 }
277 
test_purpose_ssl_client(void)278 static int test_purpose_ssl_client(void)
279 {
280     return do_test_purpose(X509_PURPOSE_SSL_CLIENT, 0);
281 }
282 
test_purpose_ssl_server(void)283 static int test_purpose_ssl_server(void)
284 {
285     return do_test_purpose(X509_PURPOSE_SSL_SERVER, 1);
286 }
287 
test_purpose_any(void)288 static int test_purpose_any(void)
289 {
290     return do_test_purpose(X509_PURPOSE_ANY, 1);
291 }
292 
293 OPT_TEST_DECLARE_USAGE("certs-dir\n")
294 
setup_tests(void)295 int setup_tests(void)
296 {
297     if (!test_skip_common_options()) {
298         TEST_error("Error parsing test options\n");
299         return 0;
300     }
301 
302     if (!TEST_ptr(certs_dir = test_get_argument(0)))
303         return 0;
304 
305     if (!TEST_ptr(root_f = test_mk_file_path(certs_dir, "rootCA.pem"))
306             || !TEST_ptr(roots_f = test_mk_file_path(certs_dir, "roots.pem"))
307             || !TEST_ptr(untrusted_f = test_mk_file_path(certs_dir, "untrusted.pem"))
308             || !TEST_ptr(bad_f = test_mk_file_path(certs_dir, "bad.pem"))
309             || !TEST_ptr(req_f = test_mk_file_path(certs_dir, "sm2-csr.pem"))
310             || !TEST_ptr(sroot_cert = test_mk_file_path(certs_dir, "sroot-cert.pem"))
311             || !TEST_ptr(ca_cert = test_mk_file_path(certs_dir, "ca-cert.pem"))
312             || !TEST_ptr(ee_cert = test_mk_file_path(certs_dir, "ee-cert.pem")))
313         goto err;
314 
315     ADD_TEST(test_alt_chains_cert_forgery);
316     ADD_TEST(test_store_ctx);
317     ADD_TEST(test_distinguishing_id);
318     ADD_TEST(test_req_distinguishing_id);
319     ADD_TEST(test_self_signed_good);
320     ADD_TEST(test_self_signed_bad);
321     ADD_TEST(test_self_signed_error);
322     ADD_TEST(test_purpose_ssl_client);
323     ADD_TEST(test_purpose_ssl_server);
324     ADD_TEST(test_purpose_any);
325     return 1;
326  err:
327     cleanup_tests();
328     return 0;
329 }
330 
cleanup_tests(void)331 void cleanup_tests(void)
332 {
333     OPENSSL_free(root_f);
334     OPENSSL_free(roots_f);
335     OPENSSL_free(untrusted_f);
336     OPENSSL_free(bad_f);
337     OPENSSL_free(req_f);
338     OPENSSL_free(sroot_cert);
339     OPENSSL_free(ca_cert);
340     OPENSSL_free(ee_cert);
341 }
342