Debian Codegraph @

src/ocsp.c

raw
1 /* ocsp.c - OCSP (rfc2560)
2 * Copyright (C) 2003, 2004, 2005, 2006, 2012 g10 Code GmbH
3 *
4 * This file is part of KSBA.
5 *
6 * KSBA is free software; you can redistribute it and/or modify
7 * it under the terms of either
8 *
9 * - the GNU Lesser General Public License as published by the Free
10 * Software Foundation; either version 3 of the License, or (at
11 * your option) any later version.
12 *
13 * or
14 *
15 * - the GNU General Public License as published by the Free
16 * Software Foundation; either version 2 of the License, or (at
17 * your option) any later version.
18 *
19 * or both in parallel, as here.
20 *
21 * KSBA is distributed in the hope that it will be useful, but WITHOUT
22 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
23 * or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public
24 * License for more details.
25 *
26 * You should have received a copies of the GNU General Public License
27 * and the GNU Lesser General Public License along with this program;
28 * if not, see <http://www.gnu.org/licenses/>.
29 */
30
31 #include <config.h>
32 #include <stdio.h>
33 #include <stdlib.h>
34 #include <string.h>
35 #include <assert.h>
36
37 #include "util.h"
38
39 #include "cert.h"
40 #include "convert.h"
41 #include "keyinfo.h"
42 #include "der-encoder.h"
43 #include "ber-help.h"
44 #include "ocsp.h"
45
46
47 static const char oidstr_sha1[] = "1.3.14.3.2.26";
48 static const char oidstr_sha256[] = "2.16.840.1.101.3.4.2.1";
49 static const char oidstr_ocsp_basic[] = "1.3.6.1.5.5.7.48.1.1";
50 static const char oidstr_ocsp_nonce[] = "1.3.6.1.5.5.7.48.1.2";
51
52
53 #if 0
54 static void
55 dump_hex (const unsigned char *p, size_t n)
56 {
57 if (!p)
58 fputs ("none", stderr);
59 else
60 {
61 for (; n; n--, p++)
62 fprintf (stderr, " %02X", *p);
63 }
64 }
65 #endif
66
67
68 /* Create a new OCSP object and retrun it in R_OCSP. Return 0 on
69 success or an error code.
70 */
71 gpg_error_t
72 ksba_ocsp_new (ksba_ocsp_t *r_ocsp)
73 {
74 *r_ocsp = xtrycalloc (1, sizeof **r_ocsp);
75 if (!*r_ocsp)
76 return gpg_error_from_syserror ();
77 return 0;
78 }
79
80
81 static void
82 release_ocsp_certlist (struct ocsp_certlist_s *cl)
83 {
84 while (cl)
85 {
86 struct ocsp_certlist_s *tmp = cl->next;
87 ksba_cert_release (cl->cert);
88 xfree (cl);
89 cl = tmp;
90 }
91 }
92
93
94 static void
95 release_ocsp_extensions (struct ocsp_extension_s *ex)
96 {
97 while (ex)
98 {
99 struct ocsp_extension_s *tmp = ex->next;
100 xfree (ex);
101 ex = tmp;
102 }
103 }
104
105
106 /* Release the OCSP object and all its resources. Passing NULL for
107 OCSP is a valid nop. */
108 void
109 ksba_ocsp_release (ksba_ocsp_t ocsp)
110 {
111 struct ocsp_reqitem_s *ri;
112
113 if (!ocsp)
114 return;
115 xfree (ocsp->digest_oid);
116 xfree (ocsp->request_buffer);
117 for (; (ri=ocsp->requestlist); ri = ocsp->requestlist )
118 {
119 ocsp->requestlist = ri->next;
120 ksba_cert_release (ri->cert);
121 ksba_cert_release (ri->issuer_cert);
122 release_ocsp_extensions (ri->single_extensions);
123 xfree (ri->serialno);
124 }
125 xfree (ocsp->sigval);
126 xfree (ocsp->responder_id.name);
127 xfree (ocsp->responder_id.keyid);
128 release_ocsp_certlist (ocsp->received_certs);
129 release_ocsp_extensions (ocsp->response_extensions);
130 xfree (ocsp);
131 }
132
133
134
135 /* Set the hash algorithm to be used for signing the request to OID.
136 Using this function will force the creation of a signed
137 request. */
138 gpg_error_t
139 ksba_ocsp_set_digest_algo (ksba_ocsp_t ocsp, const char *oid)
140 {
141 if (!ocsp || !oid || !*oid)
142 return gpg_error (GPG_ERR_INV_VALUE);
143 if (ocsp->digest_oid)
144 xfree (ocsp->digest_oid);
145 ocsp->digest_oid = xtrystrdup (oid);
146 if (!ocsp->digest_oid)
147 return gpg_error_from_syserror ();
148 return 0;
149 }
150
151
152 gpg_error_t
153 ksba_ocsp_set_requestor (ksba_ocsp_t ocsp, ksba_cert_t cert)
154 {
155 (void)ocsp;
156 (void)cert;
157 return gpg_error (GPG_ERR_NOT_IMPLEMENTED);
158 }
159
160
161 /* Add the certificate CERT for which the status is to be requested
162 and it's issuer certificate ISSUER_CERT to the context. This
163 function may be called multiple time to create a list of targets to
164 get combined into one actual request. */
165 gpg_error_t
166 ksba_ocsp_add_target (ksba_ocsp_t ocsp,
167 ksba_cert_t cert, ksba_cert_t issuer_cert)
168 {
169 struct ocsp_reqitem_s *ri;
170
171 if (!ocsp || !cert || !issuer_cert)
172 return gpg_error (GPG_ERR_INV_VALUE);
173
174 ri = xtrycalloc (1, sizeof *ri);
175 if (!ri)
176 return gpg_error_from_syserror ();
177 ksba_cert_ref (cert);
178 ri->cert = cert;
179 ksba_cert_ref (issuer_cert);
180 ri->issuer_cert = issuer_cert;
181
182 ri->next = ocsp->requestlist;
183 ocsp->requestlist = ri;
184
185 return 0;
186 }
187
188
189 /* Set the nonce to be used for the request to the content of the
190 buffer NONCE of size NONCELEN. Libksba may have an upper limit of
191 the allowed size of the nonce; if the supplied nonce is larger it
192 will be truncated and the actual used length of the nonce returned.
193 To detect the implementation limit (which should be considered as a
194 good suggestion), the function may be called with NULL for NONCE,
195 in which case the maximal usable noncelength is returned. The
196 function returns the length of the nonce which will be used.
197
198 If NONCE is NULL _and_ NONCELEN is 32, the request will use SHA256
199 for hashing of the CertID. IF NONCELEN is 20 the request will use
200 the default of SHA1. If NONCELEN is zero nothing will be changed.
201 */
202 size_t
203 ksba_ocsp_set_nonce (ksba_ocsp_t ocsp, unsigned char *nonce, size_t noncelen)
204 {
205 if (!ocsp)
206 return 0;
207 if (!nonce)
208 {
209 if (noncelen == 32)
210 ocsp->sha256_certid = 1;
211 else if (noncelen == 20)
212 ocsp->sha256_certid = 0;
213
214 return sizeof ocsp->nonce;
215 }
216 if (noncelen > sizeof ocsp->nonce)
217 noncelen = sizeof ocsp->nonce;
218 if (noncelen)
219 {
220 memcpy (ocsp->nonce, nonce, noncelen);
221 }
222 ocsp->noncelen = noncelen;
223 return noncelen;
224 }
225
226
227 /* Compute the SHA-1 nameHash for the certificate CERT and put it in
228 the buffer SHA_BUFFER which must have been allocated to at least
229 32 bytes. */
230 static gpg_error_t
231 issuer_name_hash (ksba_cert_t cert, unsigned char *sha_buffer, int use_sha256)
232 {
233 gpg_error_t err;
234 const unsigned char *ptr;
235 size_t length, dummy;
236
237 err = _ksba_cert_get_subject_dn_ptr (cert, &ptr, &length);
238 if (!err && use_sha256)
239 {
240 err = _ksba_hash_buffer (oidstr_sha256, ptr, length,
241 32, sha_buffer, &dummy);
242 if (!err && dummy != 32)
243 err = gpg_error (GPG_ERR_BUG);
244 }
245 else if (!err)
246 {
247 err = _ksba_hash_buffer (NULL, ptr, length, 20, sha_buffer, &dummy);
248 if (!err && dummy != 20)
249 err = gpg_error (GPG_ERR_BUG);
250 }
251 return err;
252 }
253
254 /* Compute the SHA-1 or SHA-256 hash of the public key of CERT and put
255 it in the buffer SHA_BUFFER which must have been allocated with at
256 least 32 bytes (or 20 for sha1). */
257 static gpg_error_t
258 issuer_key_hash (ksba_cert_t cert, unsigned char *sha_buffer, int use_sha256)
259 {
260 gpg_error_t err;
261 const unsigned char *ptr;
262 size_t length, dummy;
263
264 err = _ksba_cert_get_public_key_ptr (cert, &ptr, &length);
265 if (!err && use_sha256)
266 {
267 err = _ksba_hash_buffer (oidstr_sha256, ptr, length,
268 32, sha_buffer, &dummy);
269 if (!err && dummy != 32)
270 err = gpg_error (GPG_ERR_BUG);
271 }
272 else if (!err)
273 {
274 err = _ksba_hash_buffer (NULL, ptr, length, 20, sha_buffer, &dummy);
275 if (!err && dummy != 20)
276 err = gpg_error (GPG_ERR_BUG);
277 }
278 return err;
279 }
280
281
282 /* Write the extensions for a request to WOUT. */
283 static gpg_error_t
284 write_request_extensions (ksba_ocsp_t ocsp, ksba_writer_t wout)
285 {
286 gpg_error_t err;
287 unsigned char *buf;
288 size_t buflen;
289 unsigned char *p;
290 size_t derlen;
291 ksba_writer_t w1 = NULL;
292 ksba_writer_t w2 = NULL;
293
294 if (!ocsp->noncelen)
295 return 0; /* We do only support the nonce extension. */
296
297 /* Create writer objects for construction of the extension. */
298 err = ksba_writer_new (&w2);
299 if (!err)
300 err = ksba_writer_set_mem (w2, 256);
301 if (!err)
302 err = ksba_writer_new (&w1);
303 if (!err)
304 err = ksba_writer_set_mem (w1, 256);
305 if (err)
306 goto leave;
307
308 /* Write OID and nonce. */
309 err = ksba_oid_from_str (oidstr_ocsp_nonce, &buf, &buflen);
310 if (err)
311 goto leave;
312 err = _ksba_ber_write_tl (w1, TYPE_OBJECT_ID, CLASS_UNIVERSAL, 0, buflen);
313 if (!err)
314 err = ksba_writer_write (w1, buf, buflen);
315 xfree (buf); buf = NULL;
316 /* We known that the nonce is short enough to put the tag into 2 bytes, thus
317 we write the encapsulating octet string directly with a fixed length. */
318 if (!err)
319 err = _ksba_ber_write_tl (w1, TYPE_OCTET_STRING, CLASS_UNIVERSAL, 0,
320 2+ocsp->noncelen);
321 if (!err)
322 err = _ksba_ber_write_tl (w1, TYPE_OCTET_STRING, CLASS_UNIVERSAL, 0,
323 ocsp->noncelen);
324 if (!err)
325 err = ksba_writer_write (w1, ocsp->nonce, ocsp->noncelen);
326
327 /* Put a sequence around. */
328 p = ksba_writer_snatch_mem (w1, &derlen);
329 if (!p)
330 {
331 err = ksba_writer_error (w1);
332 goto leave;
333 }
334 err = _ksba_ber_write_tl (w2, TYPE_SEQUENCE, CLASS_UNIVERSAL, 1, derlen);
335 if (!err)
336 err = ksba_writer_write (w2, p, derlen);
337 xfree (p); p = NULL;
338
339 /* Put the sequence around all extensions. */
340 err = ksba_writer_set_mem (w1, 256);
341 if (err)
342 goto leave;
343 p = ksba_writer_snatch_mem (w2, &derlen);
344 if (!p)
345 {
346 err = ksba_writer_error (w2);
347 goto leave;
348 }
349 err = _ksba_ber_write_tl (w1, TYPE_SEQUENCE, CLASS_UNIVERSAL, 1, derlen);
350 if (!err)
351 err = ksba_writer_write (w1, p, derlen);
352 xfree (p); p = NULL;
353
354 /* And put a context tag around everything. */
355 p = ksba_writer_snatch_mem (w1, &derlen);
356 if (!p)
357 {
358 err = ksba_writer_error (w1);
359 goto leave;
360 }
361 err = _ksba_ber_write_tl (wout, 2, CLASS_CONTEXT, 1, derlen);
362 if (!err)
363 err = ksba_writer_write (wout, p, derlen);
364 xfree (p); p = NULL;
365
366
367 leave:
368 ksba_writer_release (w2);
369 ksba_writer_release (w1);
370 return err;
371 }
372
373
374 /* Build a request from the current context. The function checks that
375 all necessary information have been set and stores the prepared
376 request in the context. A subsequent ksba_ocsp_build_request may
377 then be used to retrieve this request. Optional the requestmay be
378 signed beofre calling ksba_ocsp_build_request.
379 */
380 gpg_error_t
381 ksba_ocsp_prepare_request (ksba_ocsp_t ocsp)
382 {
383 gpg_error_t err;
384 struct ocsp_reqitem_s *ri;
385 unsigned char *p;
386 const unsigned char *der;
387 size_t derlen;
388 struct tag_info ti;
389 ksba_writer_t w1 = NULL;
390 ksba_writer_t w2 = NULL;
391 ksba_writer_t w3 = NULL;
392 ksba_writer_t w4, w5, w6, w7; /* Used as aliases. */
393 unsigned int hashlen;
394
395 if (!ocsp)
396 return gpg_error (GPG_ERR_INV_VALUE);
397
398 xfree (ocsp->request_buffer);
399 ocsp->request_buffer = NULL;
400 ocsp->request_buflen = 0;
401
402 hashlen = ocsp->sha256_certid ? 32 : 20;
403
404 if (!ocsp->requestlist)
405 return gpg_error (GPG_ERR_MISSING_ACTION);
406
407 /* Create three writer objects for construction of the request. */
408 err = ksba_writer_new (&w3);
409 if (!err)
410 err = ksba_writer_set_mem (w3, 2048);
411 if (!err)
412 err = ksba_writer_new (&w2);
413 if (!err)
414 err = ksba_writer_new (&w1);
415 if (err)
416 goto leave;
417
418
419 /* Loop over all single requests. */
420 for (ri=ocsp->requestlist; ri; ri = ri->next)
421 {
422 err = ksba_writer_set_mem (w2, 256);
423 if (!err)
424 err = ksba_writer_set_mem (w1, 256);
425 if (err)
426 goto leave;
427
428 /* Write the AlgorithmIdentifier. */
429 err = _ksba_der_write_algorithm_identifier (w1,
430 ocsp->sha256_certid?
431 oidstr_sha256 : oidstr_sha1,
432 NULL, 0);
433 if (err)
434 goto leave;
435
436 /* Compute the issuerNameHash and write it into the CertID object. */
437 err = issuer_name_hash (ri->issuer_cert, ri->issuer_name_hash,
438 ocsp->sha256_certid);
439 if (!err)
440 err = _ksba_ber_write_tl (w1, TYPE_OCTET_STRING, CLASS_UNIVERSAL,
441 0, hashlen);
442 if (!err)
443 err = ksba_writer_write (w1, ri->issuer_name_hash, hashlen);
444 if(err)
445 goto leave;
446
447 /* Compute the issuerKeyHash and write it. */
448 err = issuer_key_hash (ri->issuer_cert, ri->issuer_key_hash,
449 ocsp->sha256_certid);
450 if (!err)
451 err = _ksba_ber_write_tl (w1, TYPE_OCTET_STRING, CLASS_UNIVERSAL,
452 0, hashlen);
453 if (!err)
454 err = ksba_writer_write (w1, ri->issuer_key_hash, hashlen);
455 if (err)
456 goto leave;
457
458 /* Write the serialNumber of the certificate to be checked. */
459 err = _ksba_cert_get_serial_ptr (ri->cert, &der, &derlen);
460 if (!err)
461 err = ksba_writer_write (w1, der, derlen);
462 if (err)
463 goto leave;
464 /* Store the integer value. */
465 {
466 const unsigned char *tmpder = der;
467 size_t tmpderlen = derlen;
468
469 err = parse_integer (&tmpder, &tmpderlen, &ti);
470 if (err)
471 goto leave;
472 xfree (ri->serialno);
473 ri->serialno = xtrymalloc (tmpderlen);
474 if (!ri->serialno)
475 {
476 err = gpg_error_from_syserror ();
477 goto leave;
478 }
479 memcpy (ri->serialno, tmpder, tmpderlen);
480 ri->serialnolen = tmpderlen;
481 }
482
483 /* Now write it out as a sequence to the outer certID object. */
484 p = ksba_writer_snatch_mem (w1, &derlen);
485 if (!p)
486 {
487 err = ksba_writer_error (w1);
488 goto leave;
489 }
490 err = _ksba_ber_write_tl (w2, TYPE_SEQUENCE, CLASS_UNIVERSAL,
491 1, derlen);
492 if (!err)
493 err = ksba_writer_write (w2, p, derlen);
494 xfree (p); p = NULL;
495 if (err)
496 goto leave;
497
498 /* Here we would write singleRequestExtensions. */
499
500 /* Now write it out as a sequence to the outer Request object. */
501 p = ksba_writer_snatch_mem (w2, &derlen);
502 if (!p)
503 {
504 err = ksba_writer_error (w2);
505 goto leave;
506 }
507 err = _ksba_ber_write_tl (w3, TYPE_SEQUENCE, CLASS_UNIVERSAL,
508 1, derlen);
509 if (!err)
510 err = ksba_writer_write (w3, p, derlen);
511 xfree (p); p = NULL;
512 if (err)
513 goto leave;
514
515 } /* End of looping over single requests. */
516
517 /* Reuse writers; for clarity, use new names. */
518 w4 = w1;
519 w5 = w2;
520 err = ksba_writer_set_mem (w4, 2048);
521 if (!err)
522 err = ksba_writer_set_mem (w5, 2048);
523 if (err)
524 goto leave;
525
526 /* Put a sequence tag before the requestList. */
527 p = ksba_writer_snatch_mem (w3, &derlen);
528 if (!p)
529 {
530 err = ksba_writer_error (w3);
531 goto leave;
532 }
533 err = _ksba_ber_write_tl (w4, TYPE_SEQUENCE, CLASS_UNIVERSAL,
534 1, derlen);
535 if (!err)
536 err = ksba_writer_write (w4, p, derlen);
537 xfree (p); p = NULL;
538 if (err)
539 goto leave;
540
541 /* The requestExtensions go here. */
542 err = write_request_extensions (ocsp, w4);
543
544 /* Write the tbsRequest. */
545
546 /* The version is default, thus we don't write it. */
547
548 /* The requesterName would go here. */
549
550 /* Write the requestList. */
551 p = ksba_writer_snatch_mem (w4, &derlen);
552 if (!p)
553 {
554 err = ksba_writer_error (w4);
555 goto leave;
556 }
557 err = _ksba_ber_write_tl (w5, TYPE_SEQUENCE, CLASS_UNIVERSAL,
558 1, derlen);
559 if (!err)
560 err = ksba_writer_write (w5, p, derlen);
561 xfree (p); p = NULL;
562 if (err)
563 goto leave;
564
565 /* Reuse writers; for clarity, use new names. */
566 w6 = w3;
567 w7 = w4;
568 err = ksba_writer_set_mem (w6, 2048);
569 if (!err)
570 err = ksba_writer_set_mem (w7, 2048);
571 if (err)
572 goto leave;
573
574 /* Prepend a sequence tag. */
575 p = ksba_writer_snatch_mem (w5, &derlen);
576 if (!p)
577 {
578 err = ksba_writer_error (w5);
579 goto leave;
580 }
581 err = _ksba_ber_write_tl (w6, TYPE_SEQUENCE, CLASS_UNIVERSAL,
582 1, derlen);
583 if (!err)
584 err = ksba_writer_write (w6, p, derlen);
585 xfree (p); p = NULL;
586 if (err)
587 goto leave;
588
589 /* Write the ocspRequest. */
590
591 /* Note that we do not support the optional signature, because this
592 saves us one writer object. */
593
594 /* Prepend a sequence tag. */
595 /* p = ksba_writer_snatch_mem (w6, &derlen); */
596 /* if (!p) */
597 /* { */
598 /* err = ksba_writer_error (w6); */
599 /* goto leave; */
600 /* } */
601 /* err = _ksba_ber_write_tl (w7, TYPE_SEQUENCE, CLASS_UNIVERSAL, */
602 /* 1, derlen); */
603 /* if (!err) */
604 /* err = ksba_writer_write (w7, p, derlen); */
605 /* xfree (p); p = NULL; */
606 /* if (err) */
607 /* goto leave; */
608
609
610 /* Read out the entire request. */
611 p = ksba_writer_snatch_mem (w6, &derlen);
612 if (!p)
613 {
614 err = ksba_writer_error (w6);
615 goto leave;
616 }
617 ocsp->request_buffer = p;
618 ocsp->request_buflen = derlen;
619 /* Ready. */
620
621 leave:
622 ksba_writer_release (w3);
623 ksba_writer_release (w2);
624 ksba_writer_release (w1);
625 return err;
626 }
627
628
629 gpg_error_t
630 ksba_ocsp_hash_request (ksba_ocsp_t ocsp,
631 void (*hasher)(void *, const void *,
632 size_t length),
633 void *hasher_arg)
634 {
635 (void)ocsp;
636 (void)hasher;
637 (void)hasher_arg;
638 return gpg_error (GPG_ERR_NOT_IMPLEMENTED);
639 }
640
641
642 gpg_error_t
643 ksba_ocsp_set_sig_val (ksba_ocsp_t ocsp,
644 ksba_const_sexp_t sigval)
645 {
646 (void)ocsp;
647 (void)sigval;
648 return gpg_error (GPG_ERR_NOT_IMPLEMENTED);
649 }
650
651
652 gpg_error_t
653 ksba_ocsp_add_cert (ksba_ocsp_t ocsp, ksba_cert_t cert)
654 {
655 (void)ocsp;
656 (void)cert;
657 return gpg_error (GPG_ERR_NOT_IMPLEMENTED);
658 }
659
660
661
662 /* Build a request from the current context. The function checks that
663 all necessary information have been set and then returns an
664 allocated buffer with the resulting request.
665 */
666 gpg_error_t
667 ksba_ocsp_build_request (ksba_ocsp_t ocsp,
668 unsigned char **r_buffer, size_t *r_buflen)
669 {
670 gpg_error_t err;
671
672 if (!ocsp || !r_buffer || !r_buflen)
673 return gpg_error (GPG_ERR_INV_VALUE);
674 *r_buffer = NULL;
675 *r_buflen = 0;
676
677 if (!ocsp->requestlist)
678 return gpg_error (GPG_ERR_MISSING_ACTION);
679 if (!ocsp->request_buffer)
680 {
681 /* No prepare done, do it now. */
682 err = ksba_ocsp_prepare_request (ocsp);
683 if (err)
684 return err;
685 assert (ocsp->request_buffer);
686 }
687 *r_buffer = ocsp->request_buffer;
688 *r_buflen = ocsp->request_buflen;
689 ocsp->request_buffer = NULL;
690 ocsp->request_buflen = 0;
691 return 0;
692 }
693
694
695
696 /*
697 Parse the response extensions and store them aways. While doing
698 this we also check the nonce extension. A typical data ASN.1 blob
699 with only the nonce extension as passed to this function is:
700
701 SEQUENCE {
702 SEQUENCE {
703 OBJECT IDENTIFIER ocspNonce (1 3 6 1 5 5 7 48 1 2)
704 OCTET STRING, encapsulates {
705 INTEGER
706 41 42 43 44 45 46 47 48 49 4A 4B 4C 4D 4E 4F 50
707 }
708 }
709 }
710 */
711
712 static int
713 parse_response_extensions (ksba_ocsp_t ocsp,
714 const unsigned char *data, size_t datalen)
715 {
716 gpg_error_t err;
717 struct tag_info ti;
718 size_t length;
719 char *oid = NULL;
720
721 assert (!ocsp->response_extensions);
722 err = parse_sequence (&data, &datalen, &ti);
723 if (err)
724 goto leave;
725 length = ti.length;
726 while (length)
727 {
728 struct ocsp_extension_s *ex;
729 int is_crit;
730
731 err = parse_sequence (&data, &datalen, &ti);
732 if (err)
733 goto leave;
734 if (length < ti.nhdr + ti.length)
735 {
736 err = gpg_error (GPG_ERR_BAD_BER);
737 goto leave;
738 }
739 length -= ti.nhdr + ti.length;
740
741 xfree (oid);
742 err = parse_object_id_into_str (&data, &datalen, &oid);
743 if (err)
744 goto leave;
745 is_crit = 0;
746 err = parse_optional_boolean (&data, &datalen, &is_crit);
747 if (err)
748 goto leave;
749 err = parse_octet_string (&data, &datalen, &ti);
750 if (err)
751 goto leave;
752 if (!strcmp (oid, oidstr_ocsp_nonce))
753 {
754 err = parse_octet_string (&data, &datalen, &ti);
755 if (err)
756 goto leave;
757 if (ocsp->noncelen != ti.length
758 || memcmp (ocsp->nonce, data, ti.length))
759 ocsp->bad_nonce = 1;
760 }
761 if (ti.length > (1<<24))
762 {
763 /* Bail out on much too large objects. */
764 err = gpg_error (GPG_ERR_BAD_BER);
765 goto leave;
766 }
767 ex = xtrymalloc (sizeof *ex + strlen (oid) + ti.length);
768 if (!ex)
769 {
770 err = gpg_error_from_syserror ();
771 goto leave;
772 }
773 ex->crit = is_crit;
774 strcpy (ex->data, oid);
775 ex->data[strlen (oid)] = 0;
776 ex->off = strlen (oid) + 1;
777 ex->len = ti.length;
778 memcpy (ex->data + ex->off, data, ti.length);
779 ex->next = ocsp->response_extensions;
780 ocsp->response_extensions = ex;
781
782 parse_skip (&data, &datalen, &ti); /* Skip the octet string / integer. */
783 }
784
785 leave:
786 xfree (oid);
787 return err;
788 }
789
790
791 /*
792 Parse single extensions and store them away.
793 */
794 static int
795 parse_single_extensions (struct ocsp_reqitem_s *ri,
796 const unsigned char *data, size_t datalen)
797 {
798 gpg_error_t err;
799 struct tag_info ti;
800 size_t length;
801 char *oid = NULL;
802
803 assert (ri && !ri->single_extensions);
804 err = parse_sequence (&data, &datalen, &ti);
805 if (err)
806 goto leave;
807 length = ti.length;
808 while (length)
809 {
810 struct ocsp_extension_s *ex;
811 int is_crit;
812
813 err = parse_sequence (&data, &datalen, &ti);
814 if (err)
815 goto leave;
816 if (length < ti.nhdr + ti.length)
817 {
818 err = gpg_error (GPG_ERR_BAD_BER);
819 goto leave;
820 }
821 length -= ti.nhdr + ti.length;
822
823 xfree (oid);
824 err = parse_object_id_into_str (&data, &datalen, &oid);
825 if (err)
826 goto leave;
827 is_crit = 0;
828 err = parse_optional_boolean (&data, &datalen, &is_crit);
829 if (err)
830 goto leave;
831 err = parse_octet_string (&data, &datalen, &ti);
832 if (err)
833 goto leave;
834 if (ti.length > (1<<24))
835 {
836 /* Bail out on much too large objects. */
837 err = gpg_error (GPG_ERR_BAD_BER);
838 goto leave;
839 }
840 ex = xtrymalloc (sizeof *ex + strlen (oid) + ti.length);
841 if (!ex)
842 {
843 err = gpg_error_from_syserror ();
844 goto leave;
845 }
846 ex->crit = is_crit;
847 strcpy (ex->data, oid);
848 ex->data[strlen (oid)] = 0;
849 ex->off = strlen (oid) + 1;
850 ex->len = ti.length;
851 memcpy (ex->data + ex->off, data, ti.length);
852 ex->next = ri->single_extensions;
853 ri->single_extensions = ex;
854
855 parse_skip (&data, &datalen, &ti); /* Skip the octet string / integer. */
856 }
857
858 leave:
859 xfree (oid);
860 return err;
861 }
862
863
864 /* Parse the first part of a response:
865
866 OCSPResponse ::= SEQUENCE {
867 responseStatus OCSPResponseStatus,
868 responseBytes [0] EXPLICIT ResponseBytes OPTIONAL }
869
870 OCSPResponseStatus ::= ENUMERATED {
871 successful (0), --Response has valid confirmations
872 malformedRequest (1), --Illegal confirmation request
873 internalError (2), --Internal error in issuer
874 tryLater (3), --Try again later
875 --(4) is not used
876 sigRequired (5), --Must sign the request
877 unauthorized (6) --Request unauthorized
878 }
879
880 ResponseBytes ::= SEQUENCE {
881 responseType OBJECT IDENTIFIER,
882 response OCTET STRING }
883
884 On success the RESPONSE_STATUS field of OCSP will be set to the
885 response status and DATA will now point to the first byte in the
886 octet string of the response; RLEN will be set to the length of
887 this octet string. Note thate DATALEN is also updated but might
888 point to a value larger than RLEN points to, if the provided data
889 is a part of a larger image. */
890 static gpg_error_t
891 parse_response_status (ksba_ocsp_t ocsp,
892 unsigned char const **data, size_t *datalen,
893 size_t *rlength)
894 {
895 gpg_error_t err;
896 struct tag_info ti;
897 char *oid;
898
899 *rlength = 0;
900 /* Parse the OCSPResponse sequence. */
901 err = parse_sequence (data, datalen, &ti);
902 if (err)
903 return err;
904 /* Parse the OCSPResponseStatus. */
905 err = parse_enumerated (data, datalen, &ti, 1);
906 if (err)
907 return err;
908 switch (**data)
909 {
910 case 0: ocsp->response_status = KSBA_OCSP_RSPSTATUS_SUCCESS; break;
911 case 1: ocsp->response_status = KSBA_OCSP_RSPSTATUS_MALFORMED; break;
912 case 2: ocsp->response_status = KSBA_OCSP_RSPSTATUS_INTERNAL; break;
913 case 3: ocsp->response_status = KSBA_OCSP_RSPSTATUS_TRYLATER; break;
914 case 5: ocsp->response_status = KSBA_OCSP_RSPSTATUS_SIGREQUIRED; break;
915 case 6: ocsp->response_status = KSBA_OCSP_RSPSTATUS_UNAUTHORIZED; break;
916 default: ocsp->response_status = KSBA_OCSP_RSPSTATUS_OTHER; break;
917 }
918 parse_skip (data, datalen, &ti);
919
920 if (ocsp->response_status)
921 return 0; /* This is an error reponse; we have to stop here. */
922
923 /* We have a successful reponse status, thus we check that
924 ResponseBytes are actually available. */
925 err = parse_context_tag (data, datalen, &ti, 0);
926 if (err)
927 return err;
928 err = parse_sequence (data, datalen, &ti);
929 if (err)
930 return err;
931 err = parse_object_id_into_str (data, datalen, &oid);
932 if (err)
933 return err;
934 if (strcmp (oid, oidstr_ocsp_basic))
935 {
936 xfree (oid);
937 return gpg_error (GPG_ERR_UNSUPPORTED_PROTOCOL);
938 }
939 xfree (oid);
940
941 /* Check that the next field is an octet string. */
942 err = parse_octet_string (data, datalen, &ti);
943 if (err)
944 return err;
945 *rlength = ti.length;
946 return 0;
947 }
948
949 /* Parse the object:
950
951 SingleResponse ::= SEQUENCE {
952 certID CertID,
953 certStatus CertStatus,
954 thisUpdate GeneralizedTime,
955 nextUpdate [0] EXPLICIT GeneralizedTime OPTIONAL,
956 singleExtensions [1] EXPLICIT Extensions OPTIONAL }
957
958 CertStatus ::= CHOICE {
959 good [0] IMPLICIT NULL,
960 revoked [1] IMPLICIT RevokedInfo,
961 unknown [2] IMPLICIT UnknownInfo }
962
963 RevokedInfo ::= SEQUENCE {
964 revocationTime GeneralizedTime,
965 revocationReason [0] EXPLICIT CRLReason OPTIONAL }
966
967 UnknownInfo ::= NULL -- this can be replaced with an enumeration
968
969 */
970
971 static gpg_error_t
972 parse_single_response (ksba_ocsp_t ocsp,
973 unsigned char const **data, size_t *datalen)
974 {
975 gpg_error_t err;
976 struct tag_info ti;
977 const unsigned char *savedata;
978 const unsigned char *endptr;
979 size_t savedatalen;
980 size_t n;
981 char *oid;
982 ksba_isotime_t this_update, next_update, revocation_time;
983 int look_for_request;
984 const unsigned char *name_hash;
985 const unsigned char *key_hash;
986 const unsigned char *serialno;
987 size_t serialnolen;
988 struct ocsp_reqitem_s *request_item = NULL;
989 unsigned int hashlen;
990
991 /* The SingeResponse sequence. */
992 err = parse_sequence (data, datalen, &ti);
993 if (err)
994 return err;
995 endptr = *data + ti.length;
996
997 /* The CertID is
998 SEQUENCE {
999 hashAlgorithm AlgorithmIdentifier,
1000 issuerNameHash OCTET STRING, -- Hash of Issuer's DN
1001 issuerKeyHash OCTET STRING, -- Hash of Issuers public key
1002 serialNumber CertificateSerialNumber }
1003 */
1004 err = parse_sequence (data, datalen, &ti);
1005 if (err)
1006 return err;
1007 err = _ksba_parse_algorithm_identifier (*data, *datalen, &n, &oid);
1008 if (err)
1009 return err;
1010 assert (n <= *datalen);
1011 *data += n;
1012 *datalen -= n;
1013 /* gpgrt_log_debug ("algorithmIdentifier is `%s'\n", oid); */
1014 look_for_request = !strcmp (oid, oidstr_sha1);
1015 xfree (oid);
1016
1017 err = parse_octet_string (data, datalen, &ti);
1018 if (err)
1019 return err;
1020 name_hash = *data;
1021 /* fprintf (stderr, "issuerNameHash="); */
1022 /* dump_hex (*data, ti.length); */
1023 /* putc ('\n', stderr); */
1024 if (ti.length == 20)
1025 hashlen = 20;
1026 else if (ti.length == 32)
1027 hashlen = 32;
1028 else
1029 {
1030 hashlen = 0;
1031 look_for_request = 0; /* Can't be a SHA-1 or SHA-256 digest. */
1032 }
1033 parse_skip (data, datalen, &ti);
1034
1035 err = parse_octet_string (data, datalen, &ti);
1036 if (err)
1037 return err;
1038 key_hash = *data;
1039 /* fprintf (stderr, "issuerKeyHash="); */
1040 /* dump_hex (*data, ti.length); */
1041 /* putc ('\n', stderr); */
1042 if (ti.length != hashlen)
1043 look_for_request = 0; /* Does not match the issueNameHash length. */
1044 parse_skip (data, datalen, &ti);
1045
1046 err= parse_integer (data, datalen, &ti);
1047 if (err)
1048 return err;
1049 serialno = *data;
1050 serialnolen = ti.length;
1051 /* fprintf (stderr, "serialNumber="); */
1052 /* dump_hex (*data, ti.length); */
1053 /* putc ('\n', stderr); */
1054 parse_skip (data, datalen, &ti);
1055
1056 if (look_for_request)
1057 {
1058 for (request_item = ocsp->requestlist;
1059 request_item; request_item = request_item->next)
1060 if (!memcmp (request_item->issuer_name_hash, name_hash, hashlen)
1061 && !memcmp (request_item->issuer_key_hash, key_hash,hashlen)
1062 && request_item->serialnolen == serialnolen
1063 && !memcmp (request_item->serialno, serialno, serialnolen))
1064 break; /* Got it. */
1065 }
1066
1067
1068 /*
1069 CertStatus ::= CHOICE {
1070 good [0] IMPLICIT NULL,
1071 revoked [1] IMPLICIT RevokedInfo,
1072 unknown [2] IMPLICIT UnknownInfo }
1073 */
1074 *revocation_time = 0;
1075 err = _ksba_ber_parse_tl (data, datalen, &ti);
1076 if (err)
1077 return err;
1078 if (ti.length > *datalen)
1079 return gpg_error (GPG_ERR_BAD_BER);
1080 else if (ti.class == CLASS_CONTEXT && ti.tag == 0 && !ti.is_constructed)
1081 { /* good */
1082 if (!ti.length)
1083 ; /* Cope with zero length objects. */
1084 else if (*datalen && !**data)
1085 { /* Skip the NULL. */
1086 (*datalen)--;
1087 (*data)++;
1088 }
1089 else
1090 return gpg_error (GPG_ERR_INV_OBJ);
1091
1092 if (request_item)
1093 request_item->status = KSBA_STATUS_GOOD;
1094 }
1095 else if (ti.class == CLASS_CONTEXT && ti.tag == 1 && ti.is_constructed)
1096 { /* revoked */
1097 ksba_crl_reason_t reason = KSBA_CRLREASON_UNSPECIFIED;
1098
1099 err = parse_asntime_into_isotime (data, datalen, revocation_time);
1100 if (err)
1101 return err;
1102 /* fprintf (stderr, "revocationTime=%s\n", revocation_time); */
1103 savedata = *data;
1104 savedatalen = *datalen;
1105 err = parse_context_tag (data, datalen, &ti, 0);
1106 if (err)
1107 {
1108 *data = savedata;
1109 *datalen = savedatalen;
1110 }
1111 else
1112 { /* Got a revocationReason. */
1113 err = parse_enumerated (data, datalen, &ti, 1);
1114 if (err)
1115 return err;
1116 switch (**data)
1117 {
1118 case 0: reason = KSBA_CRLREASON_UNSPECIFIED; break;
1119 case 1: reason = KSBA_CRLREASON_KEY_COMPROMISE; break;
1120 case 2: reason = KSBA_CRLREASON_CA_COMPROMISE; break;
1121 case 3: reason = KSBA_CRLREASON_AFFILIATION_CHANGED; break;
1122 case 4: reason = KSBA_CRLREASON_SUPERSEDED; break;
1123 case 5: reason = KSBA_CRLREASON_CESSATION_OF_OPERATION; break;
1124 case 6: reason = KSBA_CRLREASON_CERTIFICATE_HOLD; break;
1125 case 8: reason = KSBA_CRLREASON_REMOVE_FROM_CRL; break;
1126 case 9: reason = KSBA_CRLREASON_PRIVILEGE_WITHDRAWN; break;
1127 case 10: reason = KSBA_CRLREASON_AA_COMPROMISE; break;
1128 default: reason = KSBA_CRLREASON_OTHER; break;
1129 }
1130 parse_skip (data, datalen, &ti);
1131 }
1132 /* fprintf (stderr, "revocationReason=%04x\n", reason); */
1133 if (request_item)
1134 {
1135 request_item->status = KSBA_STATUS_REVOKED;
1136 _ksba_copy_time (request_item->revocation_time, revocation_time);
1137 request_item->revocation_reason = reason;
1138 }
1139 }
1140 else if (ti.class == CLASS_CONTEXT && ti.tag == 2 && !ti.is_constructed
1141 && *datalen)
1142 { /* unknown */
1143 if (!ti.length)
1144 ; /* Cope with zero length objects. */
1145 else if (!**data)
1146 { /* Skip the NULL. */
1147 (*datalen)--;
1148 (*data)++;
1149 }
1150 else /* The comment indicates that an enumeration may come here. */
1151 {
1152 err = parse_enumerated (data, datalen, &ti, 0);
1153 if (err)
1154 return err;
1155 fprintf (stderr, "libksba: unknownReason with an enum of "
1156 "length %u detected\n",
1157 (unsigned int)ti.length);
1158 parse_skip (data, datalen, &ti);
1159 }
1160 if (request_item)
1161 request_item->status = KSBA_STATUS_UNKNOWN;
1162 }
1163 else
1164 err = gpg_error (GPG_ERR_INV_OBJ);
1165
1166 /* thisUpdate. */
1167 err = parse_asntime_into_isotime (data, datalen, this_update);
1168 if (err)
1169 return err;
1170 if (request_item)
1171 _ksba_copy_time (request_item->this_update, this_update);
1172
1173 /* nextUpdate is optional. */
1174 if (*data >= endptr)
1175 return 0;
1176 *next_update = 0;
1177 err = _ksba_ber_parse_tl (data, datalen, &ti);
1178 if (err)
1179 return err;
1180 if (ti.length > *datalen)
1181 return gpg_error (GPG_ERR_BAD_BER);
1182 else if (ti.class == CLASS_CONTEXT && ti.tag == 0 && ti.is_constructed)
1183 { /* have nextUpdate */
1184 err = parse_asntime_into_isotime (data, datalen, next_update);
1185 if (err)
1186 return err;
1187 if (request_item)
1188 _ksba_copy_time (request_item->next_update, next_update);
1189 }
1190 else if (ti.class == CLASS_CONTEXT && ti.tag == 1 && ti.is_constructed)
1191 { /* Undo that read. */
1192 *data -= ti.nhdr;
1193 *datalen += ti.nhdr;
1194 }
1195 else
1196 err = gpg_error (GPG_ERR_INV_OBJ);
1197
1198 /* singleExtensions is optional */
1199 if (*data >= endptr)
1200 return 0;
1201 err = _ksba_ber_parse_tl (data, datalen, &ti);
1202 if (err)
1203 return err;
1204 if (ti.length > *datalen)
1205 return gpg_error (GPG_ERR_BAD_BER);
1206 if (ti.class == CLASS_CONTEXT && ti.tag == 1 && ti.is_constructed)
1207 {
1208 if (request_item)
1209 {
1210 err = parse_single_extensions (request_item, *data, ti.length);
1211 if (err)
1212 return err;
1213 }
1214 parse_skip (data, datalen, &ti);
1215 }
1216 else
1217 err = gpg_error (GPG_ERR_INV_OBJ);
1218
1219 return 0;
1220 }
1221
1222 /* Parse the object:
1223
1224 ResponseData ::= SEQUENCE {
1225 version [0] EXPLICIT Version DEFAULT v1,
1226 responderID ResponderID,
1227 producedAt GeneralizedTime,
1228 responses SEQUENCE OF SingleResponse,
1229 responseExtensions [1] EXPLICIT Extensions OPTIONAL }
1230
1231 ResponderID ::= CHOICE {
1232 byName [1] Name,
1233 byKey [2] KeyHash }
1234
1235
1236 */
1237 static gpg_error_t
1238 parse_response_data (ksba_ocsp_t ocsp,
1239 unsigned char const **data, size_t *datalen)
1240 {
1241 gpg_error_t err;
1242 struct tag_info ti;
1243 const unsigned char *savedata;
1244 size_t savedatalen;
1245 size_t responses_length;
1246
1247 /* The out er sequence. */
1248 err = parse_sequence (data, datalen, &ti);
1249 if (err)
1250 return err;
1251
1252 /* The optional version field. */
1253 savedata = *data;
1254 savedatalen = *datalen;
1255 err = parse_context_tag (data, datalen, &ti, 0);
1256 if (err)
1257 {
1258 *data = savedata;
1259 *datalen = savedatalen;
1260 }
1261 else
1262 {
1263 /* FIXME: check that the version matches. */
1264 parse_skip (data, datalen, &ti);
1265 }
1266
1267 /* The responderID field. */
1268 assert (!ocsp->responder_id.name);
1269 assert (!ocsp->responder_id.keyid);
1270 err = _ksba_ber_parse_tl (data, datalen, &ti);
1271 if (err)
1272 return err;
1273 if (ti.length > *datalen)
1274 return gpg_error (GPG_ERR_BAD_BER);
1275 else if (ti.class == CLASS_CONTEXT && ti.tag == 1 && ti.is_constructed)
1276 { /* byName. */
1277 err = _ksba_derdn_to_str (*data, ti.length, &ocsp->responder_id.name);
1278 if (err)
1279 return err;
1280 parse_skip (data, datalen, &ti);
1281 }
1282 else if (ti.class == CLASS_CONTEXT && ti.tag == 2 && ti.is_constructed)
1283 { /* byKey. */
1284 err = parse_octet_string (data, datalen, &ti);
1285 if (err)
1286 return err;
1287 if (!ti.length)
1288 return gpg_error (GPG_ERR_INV_OBJ); /* Zero length key id. */
1289 ocsp->responder_id.keyid = xtrymalloc (ti.length);
1290 if (!ocsp->responder_id.keyid)
1291 return gpg_error_from_syserror ();
1292 memcpy (ocsp->responder_id.keyid, *data, ti.length);
1293 ocsp->responder_id.keyidlen = ti.length;
1294 parse_skip (data, datalen, &ti);
1295 }
1296 else
1297 err = gpg_error (GPG_ERR_INV_OBJ);
1298
1299 /* The producedAt field. */
1300 err = parse_asntime_into_isotime (data, datalen, ocsp->produced_at);
1301 if (err)
1302 return err;
1303
1304 /* The responses field set. */
1305 err = parse_sequence (data, datalen, &ti);
1306 if (err )
1307 return err;
1308 responses_length = ti.length;
1309 while (responses_length)
1310 {
1311 savedatalen = *datalen;
1312 err = parse_single_response (ocsp, data, datalen);
1313 if (err)
1314 return err;
1315 assert (responses_length >= savedatalen - *datalen);
1316 responses_length -= savedatalen - *datalen;
1317 }
1318
1319 /* The optional responseExtensions set. */
1320 savedata = *data;
1321 savedatalen = *datalen;
1322 err = parse_context_tag (data, datalen, &ti, 1);
1323 if (!err)
1324 {
1325 err = parse_response_extensions (ocsp, *data, ti.length);
1326 if (err)
1327 return err;
1328 parse_skip (data, datalen, &ti);
1329 }
1330 else if (gpg_err_code (err) == GPG_ERR_INV_OBJ)
1331 {
1332 *data = savedata;
1333 *datalen = savedatalen;
1334 }
1335 else
1336 return err;
1337
1338 return 0;
1339 }
1340
1341
1342 /* Parse the entire response message pointed to by MSG of length
1343 MSGLEN. */
1344 static gpg_error_t
1345 parse_response (ksba_ocsp_t ocsp, const unsigned char *msg, size_t msglen)
1346 {
1347 gpg_error_t err;
1348 struct tag_info ti;
1349 const unsigned char *msgstart;
1350 const unsigned char *endptr;
1351 const char *s;
1352 size_t len;
1353
1354
1355 msgstart = msg;
1356 err = parse_response_status (ocsp, &msg, &msglen, &len);
1357 if (err)
1358 return err;
1359 msglen = len; /* We don't care about any extra bytes provided to us. */
1360 if (ocsp->response_status)
1361 {
1362 /* fprintf (stderr,"response status found to be %d - stop\n", */
1363 /* ocsp->response_status); */
1364 return 0;
1365 }
1366
1367 /* Now that we are sure that it is a BasicOCSPResponse, we can parse
1368 the really important things:
1369
1370 BasicOCSPResponse ::= SEQUENCE {
1371 tbsResponseData ResponseData,
1372 signatureAlgorithm AlgorithmIdentifier,
1373 signature BIT STRING,
1374 certs [0] EXPLICIT SEQUENCE OF Certificate OPTIONAL }
1375 */
1376 err = parse_sequence (&msg, &msglen, &ti);
1377 if (err)
1378 return err;
1379 endptr = msg + ti.length;
1380
1381 ocsp->hash_offset = msg - msgstart;
1382 err = parse_response_data (ocsp, &msg, &msglen);
1383 if (err)
1384 return err;
1385 ocsp->hash_length = msg - msgstart - ocsp->hash_offset;
1386
1387 /* The signatureAlgorithm and the signature. We only need to get the
1388 length of both objects and let a specialized function do the
1389 actual parsing. */
1390 s = msg;
1391 len = msglen;
1392 err = parse_sequence (&msg, &msglen, &ti);
1393 if (err)
1394 return err;
1395 parse_skip (&msg, &msglen, &ti);
1396 err= _ksba_ber_parse_tl (&msg, &msglen, &ti);
1397 if (err)
1398 return err;
1399 if (!(ti.class == CLASS_UNIVERSAL && ti.tag == TYPE_BIT_STRING
1400 && !ti.is_constructed) )
1401 err = gpg_error (GPG_ERR_INV_OBJ);
1402 else if (!ti.length)
1403 err = gpg_error (GPG_ERR_TOO_SHORT);
1404 else if (ti.length > msglen)
1405 err = gpg_error (GPG_ERR_BAD_BER);
1406
1407 if (err)
1408 return err;
1409
1410 parse_skip (&msg, &msglen, &ti);
1411 len = len - msglen;
1412 xfree (ocsp->sigval); ocsp->sigval = NULL;
1413 err = _ksba_sigval_to_sexp (s, len, &ocsp->sigval);
1414 if (err)
1415 return err;
1416
1417 /* Parse the optional sequence of certificates. */
1418 if (msg >= endptr)
1419 return 0; /* It's optional, so stop now. */
1420 err = parse_context_tag (&msg, &msglen, &ti, 0);
1421 if (gpg_err_code (err) == GPG_ERR_INV_OBJ)
1422 return 0; /* Not the right tag. Stop here. */
1423 if (err)
1424 return err;
1425 err = parse_sequence (&msg, &msglen, &ti);
1426 if (err)
1427 return err;
1428 if (ti.ndef)
1429 return gpg_error (GPG_ERR_UNSUPPORTED_ENCODING);
1430
1431 {
1432 ksba_cert_t cert;
1433 struct ocsp_certlist_s *cl, **cl_tail;
1434
1435 assert (!ocsp->received_certs);
1436 cl_tail = &ocsp->received_certs;
1437 endptr = msg + ti.length;
1438 while (msg < endptr)
1439 {
1440 /* Find the length of the certificate. */
1441 s = msg;
1442 err = parse_sequence (&msg, &msglen, &ti);
1443 if (err)
1444 return err;
1445 err = ksba_cert_new (&cert);
1446 if (err)
1447 return err;
1448 err = ksba_cert_init_from_mem (cert, msg - ti.nhdr,
1449 ti.nhdr + ti.length);
1450 if (err)
1451 {
1452 ksba_cert_release (cert);
1453 return err;
1454 }
1455 parse_skip (&msg, &msglen, &ti);
1456 cl = xtrycalloc (1, sizeof *cl);
1457 if (!cl)
1458 {
1459 err = gpg_error_from_syserror ();
1460 ksba_cert_release (cert);
1461 return err;
1462 }
1463
1464 cl->cert = cert;
1465
1466 *cl_tail = cl;
1467 cl_tail = &cl->next;
1468 }
1469 }
1470
1471 return 0;
1472 }
1473
1474
1475 /* Given the OCSP context and a binary reponse message of MSGLEN bytes
1476 in MSG, this fucntion parses the response and prepares it for
1477 signature verification. The status from the server is returned in
1478 RESPONSE_STATUS and must be checked even if the function returns
1479 without an error. */
1480 gpg_error_t
1481 ksba_ocsp_parse_response (ksba_ocsp_t ocsp,
1482 const unsigned char *msg, size_t msglen,
1483 ksba_ocsp_response_status_t *response_status)
1484 {
1485 gpg_error_t err;
1486 struct ocsp_reqitem_s *ri;
1487
1488 if (!ocsp || !msg || !msglen || !response_status)
1489 return gpg_error (GPG_ERR_INV_VALUE);
1490
1491 if (!ocsp->requestlist)
1492 return gpg_error (GPG_ERR_MISSING_ACTION);
1493
1494 /* Reset the fields used to track the response. This is so that we
1495 can use the parse function a second time for the same
1496 request. This is useful in case of a TryLater response status. */
1497 ocsp->response_status = KSBA_OCSP_RSPSTATUS_NONE;
1498 release_ocsp_certlist (ocsp->received_certs);
1499 release_ocsp_extensions (ocsp->response_extensions);
1500 ocsp->received_certs = NULL;
1501 ocsp->hash_length = 0;
1502 ocsp->bad_nonce = 0;
1503 xfree (ocsp->responder_id.name);
1504 ocsp->responder_id.name = NULL;
1505 xfree (ocsp->responder_id.keyid);
1506 ocsp->responder_id.keyid = NULL;
1507 for (ri=ocsp->requestlist; ri; ri = ri->next)
1508 {
1509 ri->status = KSBA_STATUS_NONE;
1510 *ri->this_update = 0;
1511 *ri->next_update = 0;
1512 *ri->revocation_time = 0;
1513 ri->revocation_reason = 0;
1514 release_ocsp_extensions (ri->single_extensions);
1515 }
1516
1517 /* Run the actual parser. */
1518 err = parse_response (ocsp, msg, msglen);
1519 *response_status = ocsp->response_status;
1520
1521 /* FIXME: find duplicates in the request list and set them to the
1522 same status. */
1523
1524 /* We used to assume that the server needs to return a nonce, but
1525 * that is not true (see for example RFC-8954). Thus we do not
1526 * check the former good_nonce flag anymore. */
1527 if (*response_status == KSBA_OCSP_RSPSTATUS_SUCCESS
1528 && ocsp->bad_nonce)
1529 *response_status = KSBA_OCSP_RSPSTATUS_REPLAYED;
1530
1531 return err;
1532 }
1533
1534
1535 /* Return the digest algorithm to be used for the signature or NULL in
1536 case of an error. The returned pointer is valid as long as the
1537 context is valid and no other ksba_ocsp_parse_response or
1538 ksba_ocsp_build_request has been used. */
1539 const char *
1540 ksba_ocsp_get_digest_algo (ksba_ocsp_t ocsp)
1541 {
1542 return ocsp? ocsp->digest_oid : NULL;
1543 }
1544
1545
1546 /* Hash the data of the response using the hash function HASHER which
1547 will be passed HASHER_ARG as its first argument and a pointer and a
1548 length of the data to be hashed. This hash function might be called
1549 several times and should update the hash context. The algorithm to
1550 be used for the hashing can be retrieved using
1551 ksba_ocsp_get_digest_algo. Note that MSG and MSGLEN should be
1552 indentical to the values passed to ksba_ocsp_parse_response. */
1553 gpg_error_t
1554 ksba_ocsp_hash_response (ksba_ocsp_t ocsp,
1555 const unsigned char *msg, size_t msglen,
1556 void (*hasher)(void *, const void *, size_t length),
1557 void *hasher_arg)
1558
1559 {
1560 if (!ocsp || !msg || !hasher)
1561 return gpg_error (GPG_ERR_INV_VALUE);
1562 if (!ocsp->hash_length)
1563 return gpg_error (GPG_ERR_MISSING_ACTION);
1564 if (ocsp->hash_offset + ocsp->hash_length >= msglen)
1565 return gpg_error (GPG_ERR_CONFLICT);
1566
1567 hasher (hasher_arg, msg + ocsp->hash_offset, ocsp->hash_length);
1568 return 0;
1569 }
1570
1571
1572 /* Return the actual signature in a format suitable to be used as
1573 input to Libgcrypt's verification function. The caller must free
1574 the returned string and that function may be called only once after
1575 a successful ksba_ocsp_parse_response. Returns NULL for an invalid
1576 handle or if no signature is available. If PRODUCED_AT is not NULL,
1577 it will receive the time the response was signed. */
1578 ksba_sexp_t
1579 ksba_ocsp_get_sig_val (ksba_ocsp_t ocsp, ksba_isotime_t produced_at)
1580 {
1581 ksba_sexp_t p;
1582
1583 if (produced_at)
1584 *produced_at = 0;
1585 if (!ocsp || !ocsp->sigval )
1586 return NULL;
1587
1588 if (produced_at)
1589 _ksba_copy_time (produced_at, ocsp->produced_at);
1590
1591 p = ocsp->sigval;
1592 ocsp->sigval = NULL;
1593 return p;
1594 }
1595
1596
1597 /* Return the responder ID for the current response into R_NAME or
1598 into R_KEYID. On sucess either R_NAME or R_KEYID will receive an
1599 allocated object. If R_NAME or R_KEYID has been passed as NULL but
1600 a value is available the errorcode GPG_ERR_NO_DATA is returned.
1601 Caller must release the values stored at R_NAME or R_KEYID; the
1602 function stores NULL tehre in case of an error. */
1603 gpg_error_t
1604 ksba_ocsp_get_responder_id (ksba_ocsp_t ocsp,
1605 char **r_name, ksba_sexp_t *r_keyid)
1606 {
1607 if (r_name)
1608 *r_name = NULL;
1609 if (r_keyid)
1610 *r_keyid = NULL;
1611
1612 if (!ocsp)
1613 return gpg_error (GPG_ERR_INV_VALUE);
1614
1615 if (ocsp->responder_id.name && r_name)
1616 {
1617 *r_name = xtrystrdup (ocsp->responder_id.name);
1618 if (!*r_name)
1619 return gpg_error_from_syserror ();
1620 }
1621 else if (ocsp->responder_id.keyid && r_keyid)
1622 {
1623 char numbuf[50];
1624 size_t numbuflen;
1625
1626 if (ocsp->responder_id.keyidlen > MAX_KEYID_DER_LENGTH)
1627 return gpg_error (GPG_ERR_TOO_LARGE);
1628 sprintf (numbuf,"(%lu:", (unsigned long)ocsp->responder_id.keyidlen);
1629 numbuflen = strlen (numbuf);
1630 *r_keyid = xtrymalloc (numbuflen + ocsp->responder_id.keyidlen + 2);
1631 if (!*r_keyid)
1632 return gpg_error_from_syserror ();
1633 strcpy (*r_keyid, numbuf);
1634 memcpy (*r_keyid+numbuflen,
1635 ocsp->responder_id.keyid, ocsp->responder_id.keyidlen);
1636 (*r_keyid)[numbuflen + ocsp->responder_id.keyidlen] = ')';
1637 (*r_keyid)[numbuflen + ocsp->responder_id.keyidlen + 1] = 0;
1638 }
1639 else
1640 return gpg_error (GPG_ERR_NO_DATA);
1641
1642 return 0;
1643 }
1644
1645
1646 /* Get optional certificates out of a response. The caller may use
1647 * this in a loop to get all certificates. The returned certificate
1648 * is a shallow copy of the original one; the caller must still use
1649 * ksba_cert_release() to free it. Returns: A certificate object or
1650 * NULL for end of list or error. */
1651 ksba_cert_t
1652 ksba_ocsp_get_cert (ksba_ocsp_t ocsp, int idx)
1653 {
1654 struct ocsp_certlist_s *cl;
1655
1656 if (!ocsp || idx < 0)
1657 return NULL;
1658
1659 for (cl=ocsp->received_certs; cl && idx; cl = cl->next, idx--)
1660 ;
1661 if (!cl)
1662 return NULL;
1663 ksba_cert_ref (cl->cert);
1664 return cl->cert;
1665 }
1666
1667
1668
1669
1670 /* Return the status of the certificate CERT for the last response
1671 done on the context OCSP. CERT must be the same certificate as
1672 used for the request; only a shallow compare is done (i.e. the
1673 pointers are compared). R_STATUS returns the status value,
1674 R_THIS_UPDATE and R_NEXT_UPDATE are the corresponding OCSP response
1675 values, R_REVOCATION_TIME is only set to the revocation time if the
1676 indicated status is revoked, R_REASON will be set to the reason
1677 given for a revocation. All the R_* arguments may be given as NULL
1678 if the value is not required. The function return 0 on success,
1679 GPG_ERR_NOT_FOUND if CERT was not used in the request or any other
1680 error code. Note that the caller should have checked the signature
1681 of the entire reponse to be good before using the stati retruned by
1682 this function. */
1683 gpg_error_t
1684 ksba_ocsp_get_status (ksba_ocsp_t ocsp, ksba_cert_t cert,
1685 ksba_status_t *r_status,
1686 ksba_isotime_t r_this_update,
1687 ksba_isotime_t r_next_update,
1688 ksba_isotime_t r_revocation_time,
1689 ksba_crl_reason_t *r_reason)
1690 {
1691 struct ocsp_reqitem_s *ri;
1692
1693 if (!ocsp || !cert || !r_status)
1694 return gpg_error (GPG_ERR_INV_VALUE);
1695 if (!ocsp->requestlist)
1696 return gpg_error (GPG_ERR_MISSING_ACTION);
1697
1698 /* Find the certificate. We don't care about the issuer certificate
1699 and stop at the first match. The implementation may be optimized
1700 by keeping track of the last certificate found to start with the
1701 next one then. Given that a usual request consists only of a few
1702 certificates, this does not make much sense in reality. */
1703 for (ri=ocsp->requestlist; ri; ri = ri->next)
1704 if (ri->cert == cert)
1705 break;
1706 if (!ri)
1707 return gpg_error (GPG_ERR_NOT_FOUND);
1708 if (r_status)
1709 *r_status = ri->status;
1710 if (r_this_update)
1711 _ksba_copy_time (r_this_update, ri->this_update);
1712 if (r_next_update)
1713 _ksba_copy_time (r_next_update, ri->next_update);
1714 if (r_revocation_time)
1715 _ksba_copy_time (r_revocation_time, ri->revocation_time);
1716 if (r_reason)
1717 *r_reason = ri->revocation_reason;
1718 return 0;
1719 }
1720
1721
1722 /* WARNING: The returned values ares only valid as long as no other
1723 ocsp function is called on the same context. */
1724 gpg_error_t
1725 ksba_ocsp_get_extension (ksba_ocsp_t ocsp, ksba_cert_t cert, int idx,
1726 char const **r_oid, int *r_crit,
1727 unsigned char const **r_der, size_t *r_derlen)
1728 {
1729 struct ocsp_extension_s *ex;
1730
1731 if (!ocsp)
1732 return gpg_error (GPG_ERR_INV_VALUE);
1733 if (!ocsp->requestlist)
1734 return gpg_error (GPG_ERR_MISSING_ACTION);
1735 if (idx < 0)
1736 return gpg_error (GPG_ERR_INV_INDEX);
1737
1738 if (cert)
1739 {
1740 /* Return extensions for the certificate (singleExtensions). */
1741 struct ocsp_reqitem_s *ri;
1742
1743 for (ri=ocsp->requestlist; ri; ri = ri->next)
1744 if (ri->cert == cert)
1745 break;
1746 if (!ri)
1747 return gpg_error (GPG_ERR_NOT_FOUND);
1748
1749 for (ex=ri->single_extensions; ex && idx; ex = ex->next, idx--)
1750 ;
1751 if (!ex)
1752 return gpg_error (GPG_ERR_EOF); /* No more extensions. */
1753 }
1754 else
1755 {
1756 /* Return extensions for the response (responseExtensions). */
1757 for (ex=ocsp->response_extensions; ex && idx; ex = ex->next, idx--)
1758 ;
1759 if (!ex)
1760 return gpg_error (GPG_ERR_EOF); /* No more extensions. */
1761 }
1762
1763 if (r_oid)
1764 *r_oid = ex->data;
1765 if (r_crit)
1766 *r_crit = ex->crit;
1767 if (r_der)
1768 *r_der = ex->data + ex->off;
1769 if (r_derlen)
1770 *r_derlen = ex->len;
1771
1772 return 0;
1773 }