summaryrefslogtreecommitdiff
path: root/src/lib/libcrypto/ocsp/ocsp_vfy.c
diff options
context:
space:
mode:
Diffstat (limited to 'src/lib/libcrypto/ocsp/ocsp_vfy.c')
-rw-r--r--src/lib/libcrypto/ocsp/ocsp_vfy.c449
1 files changed, 0 insertions, 449 deletions
diff --git a/src/lib/libcrypto/ocsp/ocsp_vfy.c b/src/lib/libcrypto/ocsp/ocsp_vfy.c
deleted file mode 100644
index 91a45c9133..0000000000
--- a/src/lib/libcrypto/ocsp/ocsp_vfy.c
+++ /dev/null
@@ -1,449 +0,0 @@
1/* ocsp_vfy.c */
2/* Written by Dr Stephen N Henson (steve@openssl.org) for the OpenSSL
3 * project 2000.
4 */
5/* ====================================================================
6 * Copyright (c) 2000-2004 The OpenSSL Project. All rights reserved.
7 *
8 * Redistribution and use in source and binary forms, with or without
9 * modification, are permitted provided that the following conditions
10 * are met:
11 *
12 * 1. Redistributions of source code must retain the above copyright
13 * notice, this list of conditions and the following disclaimer.
14 *
15 * 2. Redistributions in binary form must reproduce the above copyright
16 * notice, this list of conditions and the following disclaimer in
17 * the documentation and/or other materials provided with the
18 * distribution.
19 *
20 * 3. All advertising materials mentioning features or use of this
21 * software must display the following acknowledgment:
22 * "This product includes software developed by the OpenSSL Project
23 * for use in the OpenSSL Toolkit. (http://www.OpenSSL.org/)"
24 *
25 * 4. The names "OpenSSL Toolkit" and "OpenSSL Project" must not be used to
26 * endorse or promote products derived from this software without
27 * prior written permission. For written permission, please contact
28 * licensing@OpenSSL.org.
29 *
30 * 5. Products derived from this software may not be called "OpenSSL"
31 * nor may "OpenSSL" appear in their names without prior written
32 * permission of the OpenSSL Project.
33 *
34 * 6. Redistributions of any form whatsoever must retain the following
35 * acknowledgment:
36 * "This product includes software developed by the OpenSSL Project
37 * for use in the OpenSSL Toolkit (http://www.OpenSSL.org/)"
38 *
39 * THIS SOFTWARE IS PROVIDED BY THE OpenSSL PROJECT ``AS IS'' AND ANY
40 * EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
41 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
42 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE OpenSSL PROJECT OR
43 * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
44 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
45 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
46 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
47 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
48 * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
49 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
50 * OF THE POSSIBILITY OF SUCH DAMAGE.
51 * ====================================================================
52 *
53 * This product includes cryptographic software written by Eric Young
54 * (eay@cryptsoft.com). This product includes software written by Tim
55 * Hudson (tjh@cryptsoft.com).
56 *
57 */
58
59#include <openssl/ocsp.h>
60#include <openssl/err.h>
61#include <string.h>
62
63static int ocsp_find_signer(X509 **psigner, OCSP_BASICRESP *bs, STACK_OF(X509) *certs,
64 X509_STORE *st, unsigned long flags);
65static X509 *ocsp_find_signer_sk(STACK_OF(X509) *certs, OCSP_RESPID *id);
66static int ocsp_check_issuer(OCSP_BASICRESP *bs, STACK_OF(X509) *chain, unsigned long flags);
67static int ocsp_check_ids(STACK_OF(OCSP_SINGLERESP) *sresp, OCSP_CERTID **ret);
68static int ocsp_match_issuerid(X509 *cert, OCSP_CERTID *cid, STACK_OF(OCSP_SINGLERESP) *sresp);
69static int ocsp_check_delegated(X509 *x, int flags);
70static int ocsp_req_find_signer(X509 **psigner, OCSP_REQUEST *req, X509_NAME *nm, STACK_OF(X509) *certs,
71 X509_STORE *st, unsigned long flags);
72
73/* Verify a basic response message */
74
75int OCSP_basic_verify(OCSP_BASICRESP *bs, STACK_OF(X509) *certs,
76 X509_STORE *st, unsigned long flags)
77 {
78 X509 *signer, *x;
79 STACK_OF(X509) *chain = NULL;
80 X509_STORE_CTX ctx;
81 int i, ret = 0;
82 ret = ocsp_find_signer(&signer, bs, certs, st, flags);
83 if (!ret)
84 {
85 OCSPerr(OCSP_F_OCSP_BASIC_VERIFY, OCSP_R_SIGNER_CERTIFICATE_NOT_FOUND);
86 goto end;
87 }
88 if ((ret == 2) && (flags & OCSP_TRUSTOTHER))
89 flags |= OCSP_NOVERIFY;
90 if (!(flags & OCSP_NOSIGS))
91 {
92 EVP_PKEY *skey;
93 skey = X509_get_pubkey(signer);
94 if (skey)
95 {
96 ret = OCSP_BASICRESP_verify(bs, skey, 0);
97 EVP_PKEY_free(skey);
98 }
99 if(!skey || ret <= 0)
100 {
101 OCSPerr(OCSP_F_OCSP_BASIC_VERIFY, OCSP_R_SIGNATURE_FAILURE);
102 goto end;
103 }
104 }
105 if (!(flags & OCSP_NOVERIFY))
106 {
107 int init_res;
108 if(flags & OCSP_NOCHAIN)
109 init_res = X509_STORE_CTX_init(&ctx, st, signer, NULL);
110 else
111 init_res = X509_STORE_CTX_init(&ctx, st, signer, bs->certs);
112 if(!init_res)
113 {
114 OCSPerr(OCSP_F_OCSP_BASIC_VERIFY,ERR_R_X509_LIB);
115 goto end;
116 }
117
118 X509_STORE_CTX_set_purpose(&ctx, X509_PURPOSE_OCSP_HELPER);
119 ret = X509_verify_cert(&ctx);
120 chain = X509_STORE_CTX_get1_chain(&ctx);
121 X509_STORE_CTX_cleanup(&ctx);
122 if (ret <= 0)
123 {
124 i = X509_STORE_CTX_get_error(&ctx);
125 OCSPerr(OCSP_F_OCSP_BASIC_VERIFY,OCSP_R_CERTIFICATE_VERIFY_ERROR);
126 ERR_add_error_data(2, "Verify error:",
127 X509_verify_cert_error_string(i));
128 goto end;
129 }
130 if(flags & OCSP_NOCHECKS)
131 {
132 ret = 1;
133 goto end;
134 }
135 /* At this point we have a valid certificate chain
136 * need to verify it against the OCSP issuer criteria.
137 */
138 ret = ocsp_check_issuer(bs, chain, flags);
139
140 /* If fatal error or valid match then finish */
141 if (ret != 0) goto end;
142
143 /* Easy case: explicitly trusted. Get root CA and
144 * check for explicit trust
145 */
146 if(flags & OCSP_NOEXPLICIT) goto end;
147
148 x = sk_X509_value(chain, sk_X509_num(chain) - 1);
149 if(X509_check_trust(x, NID_OCSP_sign, 0) != X509_TRUST_TRUSTED)
150 {
151 OCSPerr(OCSP_F_OCSP_BASIC_VERIFY,OCSP_R_ROOT_CA_NOT_TRUSTED);
152 goto end;
153 }
154 ret = 1;
155 }
156
157
158
159 end:
160 if(chain) sk_X509_pop_free(chain, X509_free);
161 return ret;
162 }
163
164
165static int ocsp_find_signer(X509 **psigner, OCSP_BASICRESP *bs, STACK_OF(X509) *certs,
166 X509_STORE *st, unsigned long flags)
167 {
168 X509 *signer;
169 OCSP_RESPID *rid = bs->tbsResponseData->responderId;
170 if ((signer = ocsp_find_signer_sk(certs, rid)))
171 {
172 *psigner = signer;
173 return 2;
174 }
175 if(!(flags & OCSP_NOINTERN) &&
176 (signer = ocsp_find_signer_sk(bs->certs, rid)))
177 {
178 *psigner = signer;
179 return 1;
180 }
181 /* Maybe lookup from store if by subject name */
182
183 *psigner = NULL;
184 return 0;
185 }
186
187
188static X509 *ocsp_find_signer_sk(STACK_OF(X509) *certs, OCSP_RESPID *id)
189 {
190 int i;
191 unsigned char tmphash[SHA_DIGEST_LENGTH], *keyhash;
192 X509 *x;
193
194 /* Easy if lookup by name */
195 if (id->type == V_OCSP_RESPID_NAME)
196 return X509_find_by_subject(certs, id->value.byName);
197
198 /* Lookup by key hash */
199
200 /* If key hash isn't SHA1 length then forget it */
201 if (id->value.byKey->length != SHA_DIGEST_LENGTH) return NULL;
202 keyhash = id->value.byKey->data;
203 /* Calculate hash of each key and compare */
204 for (i = 0; i < sk_X509_num(certs); i++)
205 {
206 x = sk_X509_value(certs, i);
207 X509_pubkey_digest(x, EVP_sha1(), tmphash, NULL);
208 if(!memcmp(keyhash, tmphash, SHA_DIGEST_LENGTH))
209 return x;
210 }
211 return NULL;
212 }
213
214
215static int ocsp_check_issuer(OCSP_BASICRESP *bs, STACK_OF(X509) *chain, unsigned long flags)
216 {
217 STACK_OF(OCSP_SINGLERESP) *sresp;
218 X509 *signer, *sca;
219 OCSP_CERTID *caid = NULL;
220 int i;
221 sresp = bs->tbsResponseData->responses;
222
223 if (sk_X509_num(chain) <= 0)
224 {
225 OCSPerr(OCSP_F_OCSP_CHECK_ISSUER, OCSP_R_NO_CERTIFICATES_IN_CHAIN);
226 return -1;
227 }
228
229 /* See if the issuer IDs match. */
230 i = ocsp_check_ids(sresp, &caid);
231
232 /* If ID mismatch or other error then return */
233 if (i <= 0) return i;
234
235 signer = sk_X509_value(chain, 0);
236 /* Check to see if OCSP responder CA matches request CA */
237 if (sk_X509_num(chain) > 1)
238 {
239 sca = sk_X509_value(chain, 1);
240 i = ocsp_match_issuerid(sca, caid, sresp);
241 if (i < 0) return i;
242 if (i)
243 {
244 /* We have a match, if extensions OK then success */
245 if (ocsp_check_delegated(signer, flags)) return 1;
246 return 0;
247 }
248 }
249
250 /* Otherwise check if OCSP request signed directly by request CA */
251 return ocsp_match_issuerid(signer, caid, sresp);
252 }
253
254
255/* Check the issuer certificate IDs for equality. If there is a mismatch with the same
256 * algorithm then there's no point trying to match any certificates against the issuer.
257 * If the issuer IDs all match then we just need to check equality against one of them.
258 */
259
260static int ocsp_check_ids(STACK_OF(OCSP_SINGLERESP) *sresp, OCSP_CERTID **ret)
261 {
262 OCSP_CERTID *tmpid, *cid;
263 int i, idcount;
264
265 idcount = sk_OCSP_SINGLERESP_num(sresp);
266 if (idcount <= 0)
267 {
268 OCSPerr(OCSP_F_OCSP_CHECK_IDS, OCSP_R_RESPONSE_CONTAINS_NO_REVOCATION_DATA);
269 return -1;
270 }
271
272 cid = sk_OCSP_SINGLERESP_value(sresp, 0)->certId;
273
274 *ret = NULL;
275
276 for (i = 1; i < idcount; i++)
277 {
278 tmpid = sk_OCSP_SINGLERESP_value(sresp, i)->certId;
279 /* Check to see if IDs match */
280 if (OCSP_id_issuer_cmp(cid, tmpid))
281 {
282 /* If algoritm mismatch let caller deal with it */
283 if (OBJ_cmp(tmpid->hashAlgorithm->algorithm,
284 cid->hashAlgorithm->algorithm))
285 return 2;
286 /* Else mismatch */
287 return 0;
288 }
289 }
290
291 /* All IDs match: only need to check one ID */
292 *ret = cid;
293 return 1;
294 }
295
296
297static int ocsp_match_issuerid(X509 *cert, OCSP_CERTID *cid,
298 STACK_OF(OCSP_SINGLERESP) *sresp)
299 {
300 /* If only one ID to match then do it */
301 if(cid)
302 {
303 const EVP_MD *dgst;
304 X509_NAME *iname;
305 int mdlen;
306 unsigned char md[EVP_MAX_MD_SIZE];
307 if (!(dgst = EVP_get_digestbyobj(cid->hashAlgorithm->algorithm)))
308 {
309 OCSPerr(OCSP_F_OCSP_MATCH_ISSUERID, OCSP_R_UNKNOWN_MESSAGE_DIGEST);
310 return -1;
311 }
312
313 mdlen = EVP_MD_size(dgst);
314 if (mdlen < 0)
315 return -1;
316 if ((cid->issuerNameHash->length != mdlen) ||
317 (cid->issuerKeyHash->length != mdlen))
318 return 0;
319 iname = X509_get_subject_name(cert);
320 if (!X509_NAME_digest(iname, dgst, md, NULL))
321 return -1;
322 if (memcmp(md, cid->issuerNameHash->data, mdlen))
323 return 0;
324 X509_pubkey_digest(cert, dgst, md, NULL);
325 if (memcmp(md, cid->issuerKeyHash->data, mdlen))
326 return 0;
327
328 return 1;
329
330 }
331 else
332 {
333 /* We have to match the whole lot */
334 int i, ret;
335 OCSP_CERTID *tmpid;
336 for (i = 0; i < sk_OCSP_SINGLERESP_num(sresp); i++)
337 {
338 tmpid = sk_OCSP_SINGLERESP_value(sresp, i)->certId;
339 ret = ocsp_match_issuerid(cert, tmpid, NULL);
340 if (ret <= 0) return ret;
341 }
342 return 1;
343 }
344
345 }
346
347static int ocsp_check_delegated(X509 *x, int flags)
348 {
349 X509_check_purpose(x, -1, 0);
350 if ((x->ex_flags & EXFLAG_XKUSAGE) &&
351 (x->ex_xkusage & XKU_OCSP_SIGN))
352 return 1;
353 OCSPerr(OCSP_F_OCSP_CHECK_DELEGATED, OCSP_R_MISSING_OCSPSIGNING_USAGE);
354 return 0;
355 }
356
357/* Verify an OCSP request. This is fortunately much easier than OCSP
358 * response verify. Just find the signers certificate and verify it
359 * against a given trust value.
360 */
361
362int OCSP_request_verify(OCSP_REQUEST *req, STACK_OF(X509) *certs, X509_STORE *store, unsigned long flags)
363 {
364 X509 *signer;
365 X509_NAME *nm;
366 GENERAL_NAME *gen;
367 int ret;
368 X509_STORE_CTX ctx;
369 if (!req->optionalSignature)
370 {
371 OCSPerr(OCSP_F_OCSP_REQUEST_VERIFY, OCSP_R_REQUEST_NOT_SIGNED);
372 return 0;
373 }
374 gen = req->tbsRequest->requestorName;
375 if (!gen || gen->type != GEN_DIRNAME)
376 {
377 OCSPerr(OCSP_F_OCSP_REQUEST_VERIFY, OCSP_R_UNSUPPORTED_REQUESTORNAME_TYPE);
378 return 0;
379 }
380 nm = gen->d.directoryName;
381 ret = ocsp_req_find_signer(&signer, req, nm, certs, store, flags);
382 if (ret <= 0)
383 {
384 OCSPerr(OCSP_F_OCSP_REQUEST_VERIFY, OCSP_R_SIGNER_CERTIFICATE_NOT_FOUND);
385 return 0;
386 }
387 if ((ret == 2) && (flags & OCSP_TRUSTOTHER))
388 flags |= OCSP_NOVERIFY;
389 if (!(flags & OCSP_NOSIGS))
390 {
391 EVP_PKEY *skey;
392 skey = X509_get_pubkey(signer);
393 ret = OCSP_REQUEST_verify(req, skey);
394 EVP_PKEY_free(skey);
395 if(ret <= 0)
396 {
397 OCSPerr(OCSP_F_OCSP_REQUEST_VERIFY, OCSP_R_SIGNATURE_FAILURE);
398 return 0;
399 }
400 }
401 if (!(flags & OCSP_NOVERIFY))
402 {
403 int init_res;
404 if(flags & OCSP_NOCHAIN)
405 init_res = X509_STORE_CTX_init(&ctx, store, signer, NULL);
406 else
407 init_res = X509_STORE_CTX_init(&ctx, store, signer,
408 req->optionalSignature->certs);
409 if(!init_res)
410 {
411 OCSPerr(OCSP_F_OCSP_REQUEST_VERIFY,ERR_R_X509_LIB);
412 return 0;
413 }
414
415 X509_STORE_CTX_set_purpose(&ctx, X509_PURPOSE_OCSP_HELPER);
416 X509_STORE_CTX_set_trust(&ctx, X509_TRUST_OCSP_REQUEST);
417 ret = X509_verify_cert(&ctx);
418 X509_STORE_CTX_cleanup(&ctx);
419 if (ret <= 0)
420 {
421 ret = X509_STORE_CTX_get_error(&ctx);
422 OCSPerr(OCSP_F_OCSP_REQUEST_VERIFY,OCSP_R_CERTIFICATE_VERIFY_ERROR);
423 ERR_add_error_data(2, "Verify error:",
424 X509_verify_cert_error_string(ret));
425 return 0;
426 }
427 }
428 return 1;
429 }
430
431static int ocsp_req_find_signer(X509 **psigner, OCSP_REQUEST *req, X509_NAME *nm, STACK_OF(X509) *certs,
432 X509_STORE *st, unsigned long flags)
433 {
434 X509 *signer;
435 if(!(flags & OCSP_NOINTERN))
436 {
437 signer = X509_find_by_subject(req->optionalSignature->certs, nm);
438 *psigner = signer;
439 return 1;
440 }
441
442 signer = X509_find_by_subject(certs, nm);
443 if (signer)
444 {
445 *psigner = signer;
446 return 2;
447 }
448 return 0;
449 }
generated by cgit v1.2.3-55-g6feb (git 2.39.1) at 2025-03-22 18:22:01 +0000