Debian Codegraph @

tests/t-ocsp.c

raw
1 /* t-ocsp.c - Basic tests for the OCSP subsystem.
2 * Copyright (C) 2003 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 the GNU General Public License as published by
8 * the Free Software Foundation; either version 3 of the License, or
9 * (at your option) any later version.
10 *
11 * KSBA is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 * GNU General Public License for more details.
15 *
16 * You should have received a copy of the GNU General Public License
17 * along with this program; if not, see <http://www.gnu.org/licenses/>.
18 */
19
20 #include <stdio.h>
21 #include <stdlib.h>
22 #include <string.h>
23 #include <assert.h>
24 #include <sys/stat.h>
25 #include <unistd.h>
26 #include <time.h>
27 #include <errno.h>
28
29 #include "../src/ksba.h"
30
31
32 #include "t-common.h"
33 #include "oidtranstbl.h"
34
35
36 int verbose;
37 int debug;
38 int no_nonce;
39 int sha256_certid;
40
41
42 /* Return the description for OID; if no description is available
43 NULL is returned. */
44 static const char *
45 get_oid_desc (const char *oid)
46 {
47 int i;
48
49 if (oid)
50 for (i=0; oidtranstbl[i].oid; i++)
51 if (!strcmp (oidtranstbl[i].oid, oid))
52 return oidtranstbl[i].desc;
53 return NULL;
54 }
55
56
57 static unsigned char *
58 read_file (const char *fname, size_t *r_length)
59 {
60 FILE *fp;
61 struct stat st;
62 char *buf;
63 size_t buflen;
64
65 fp = fopen (fname, "rb");
66 if (!fp)
67 {
68 fprintf (stderr, "can't open `%s': %s\n", fname, strerror (errno));
69 return NULL;
70 }
71
72 if (fstat (fileno(fp), &st))
73 {
74 fprintf (stderr, "can't stat `%s': %s\n", fname, strerror (errno));
75 fclose (fp);
76 return NULL;
77 }
78
79 buflen = st.st_size;
80 buf = xmalloc (buflen+1);
81 if (fread (buf, buflen, 1, fp) != 1)
82 {
83 fprintf (stderr, "error reading `%s': %s\n", fname, strerror (errno));
84 fclose (fp);
85 xfree (buf);
86 return NULL;
87 }
88 fclose (fp);
89
90 *r_length = buflen;
91 return buf;
92 }
93
94
95
96 ksba_cert_t
97 get_one_cert (const char *fname)
98 {
99 gpg_error_t err;
100 FILE *fp;
101 ksba_reader_t r;
102 ksba_cert_t cert;
103
104 fp = fopen (fname, "r");
105 if (!fp)
106 {
107 fprintf (stderr, "%s:%d: can't open `%s': %s\n",
108 __FILE__, __LINE__, fname, strerror (errno));
109 exit (1);
110 }
111
112 err = ksba_reader_new (&r);
113 if (err)
114 fail_if_err (err);
115 err = ksba_reader_set_file (r, fp);
116 fail_if_err (err);
117
118 err = ksba_cert_new (&cert);
119 if (err)
120 fail_if_err (err);
121
122 err = ksba_cert_read_der (cert, r);
123 fail_if_err2 (fname, err);
124 return cert;
125 }
126
127
128 /* Create a request for the DER encoded certificate in the file
129 CERT_FNAME and its issuer's certificate in the file
130 ISSUER_CERT_FNAME. */
131 void
132 one_request (const char *cert_fname, const char *issuer_cert_fname)
133 {
134 gpg_error_t err;
135 ksba_cert_t cert = get_one_cert (cert_fname);
136 ksba_cert_t issuer_cert = get_one_cert (issuer_cert_fname);
137 ksba_ocsp_t ocsp;
138 unsigned char *request;
139 size_t requestlen;
140
141 err = ksba_ocsp_new (&ocsp);
142 fail_if_err (err);
143
144 if (sha256_certid)
145 ksba_ocsp_set_nonce (ocsp, NULL, 32);
146
147 err = ksba_ocsp_add_target (ocsp, cert, issuer_cert);
148 fail_if_err (err);
149 ksba_cert_release (cert);
150 ksba_cert_release (issuer_cert);
151
152 if (!no_nonce)
153 ksba_ocsp_set_nonce (ocsp, "ABCDEFGHIJKLMNOP", 16);
154
155 err = ksba_ocsp_build_request (ocsp, &request, &requestlen);
156 fail_if_err (err);
157 ksba_ocsp_release (ocsp);
158
159 printf ("OCSP request of length %u created\n", (unsigned int)requestlen);
160 {
161
162 FILE *fp = fopen ("a.req", "wb");
163 if (!fp)
164 fail ("can't create output file `a.req'");
165 if (fwrite (request, requestlen, 1, fp) != 1)
166 fail ("can't write output");
167 fclose (fp);
168 }
169
170 xfree (request);
171 }
172
173
174 void
175 one_response (const char *cert_fname, const char *issuer_cert_fname,
176 char *response_fname)
177 {
178 gpg_error_t err;
179 ksba_ocsp_t ocsp;
180 unsigned char *request, *response;
181 size_t requestlen, responselen;
182 ksba_cert_t cert = get_one_cert (cert_fname);
183 ksba_cert_t issuer_cert = get_one_cert (issuer_cert_fname);
184 ksba_ocsp_response_status_t response_status;
185 const char *t;
186
187 err = ksba_ocsp_new (&ocsp);
188 fail_if_err (err);
189
190 if (sha256_certid)
191 ksba_ocsp_set_nonce (ocsp, NULL, 32);
192
193 /* We need to build a request, so that the context is properly
194 prepared for the response. */
195 err = ksba_ocsp_add_target (ocsp, cert, issuer_cert);
196 fail_if_err (err);
197 ksba_cert_release (issuer_cert);
198
199 if (!no_nonce)
200 ksba_ocsp_set_nonce (ocsp, "ABCDEFGHIJKLMNOP", 16);
201
202 err = ksba_ocsp_build_request (ocsp, &request, &requestlen);
203 fail_if_err (err);
204 xfree (request);
205
206 /* Now for the response. */
207 response = read_file (response_fname, &responselen);
208 if (!response)
209 fail ("file error");
210
211 err = ksba_ocsp_parse_response (ocsp, response, responselen,
212 &response_status);
213 fail_if_err (err);
214 switch (response_status)
215 {
216 case KSBA_OCSP_RSPSTATUS_SUCCESS: t = "success"; break;
217 case KSBA_OCSP_RSPSTATUS_MALFORMED: t = "malformed"; break;
218 case KSBA_OCSP_RSPSTATUS_INTERNAL: t = "internal error"; break;
219 case KSBA_OCSP_RSPSTATUS_TRYLATER: t = "try later"; break;
220 case KSBA_OCSP_RSPSTATUS_SIGREQUIRED: t = "must sign request"; break;
221 case KSBA_OCSP_RSPSTATUS_UNAUTHORIZED: t = "unauthorized"; break;
222 case KSBA_OCSP_RSPSTATUS_REPLAYED: t = "replay detected"; break;
223 case KSBA_OCSP_RSPSTATUS_OTHER: t = "other (unknown)"; break;
224 case KSBA_OCSP_RSPSTATUS_NONE: t = "no status"; break;
225 default: fail ("impossible response_status"); break;
226 }
227 printf ("response status ..: %s\n", t);
228
229 if (response_status == KSBA_OCSP_RSPSTATUS_SUCCESS
230 || response_status == KSBA_OCSP_RSPSTATUS_REPLAYED)
231 {
232 ksba_status_t status;
233 ksba_crl_reason_t reason;
234 ksba_isotime_t this_update, next_update, revocation_time, produced_at;
235 ksba_sexp_t sigval;
236 char *name;
237 ksba_sexp_t keyid;
238
239 err = ksba_ocsp_get_responder_id (ocsp, &name, &keyid);
240 fail_if_err (err);
241 printf ("responder id .....: ");
242 if (name)
243 printf ("`%s'", name);
244 else
245 print_sexp (keyid);
246 putchar ('\n');
247 ksba_free (name);
248 ksba_free (keyid);
249
250 sigval = ksba_ocsp_get_sig_val (ocsp, produced_at);
251 printf ("signature value ..: ");
252 print_sexp (sigval);
253 printf ("\nproduced at ......: ");
254 print_time (produced_at);
255 putchar ('\n');
256 err = ksba_ocsp_get_status (ocsp, cert,
257 &status, this_update, next_update,
258 revocation_time, &reason);
259 fail_if_err (err);
260 printf ("certificate status: %s\n",
261 status == KSBA_STATUS_GOOD? "good":
262 status == KSBA_STATUS_REVOKED? "revoked":
263 status == KSBA_STATUS_UNKNOWN? "unknown":
264 status == KSBA_STATUS_NONE? "none": "?");
265 if (status == KSBA_STATUS_REVOKED)
266 {
267 printf ("revocation time ..: ");
268 print_time (revocation_time);
269 printf ("\nrevocation reason : %s\n",
270 reason == KSBA_CRLREASON_UNSPECIFIED? "unspecified":
271 reason == KSBA_CRLREASON_KEY_COMPROMISE? "key compromise":
272 reason == KSBA_CRLREASON_CA_COMPROMISE? "CA compromise":
273 reason == KSBA_CRLREASON_AFFILIATION_CHANGED?
274 "affiliation changed":
275 reason == KSBA_CRLREASON_SUPERSEDED? "superseeded":
276 reason == KSBA_CRLREASON_CESSATION_OF_OPERATION?
277 "cessation of operation":
278 reason == KSBA_CRLREASON_CERTIFICATE_HOLD?
279 "certificate on hold":
280 reason == KSBA_CRLREASON_REMOVE_FROM_CRL? "removed from CRL":
281 reason == KSBA_CRLREASON_PRIVILEGE_WITHDRAWN?
282 "privilege withdrawn":
283 reason == KSBA_CRLREASON_AA_COMPROMISE? "AA compromise":
284 reason == KSBA_CRLREASON_OTHER? "other":"?");
285 }
286 printf ("this update ......: ");
287 print_time (this_update);
288 printf ("\nnext update ......: ");
289 print_time (next_update);
290 putchar ('\n');
291 {
292 int cert_idx;
293 ksba_cert_t acert;
294
295 for (cert_idx=0; (acert = ksba_ocsp_get_cert (ocsp, cert_idx));
296 cert_idx++)
297 ksba_cert_release (acert);
298 printf ("extra certificates: %d\n", cert_idx );
299 }
300
301 {
302 int idx, crit;
303 const char *oid;
304 const unsigned char *der;
305 size_t derlen;
306
307 for (idx=0; !(err=ksba_ocsp_get_extension (ocsp, NULL, idx,
308 &oid, &crit,
309 &der, &derlen)); idx++)
310 {
311 const char *s = get_oid_desc (oid);
312 printf ("%sresp-extn ..%s: %s%s%s%s (",
313 crit? "crit. ":"",
314 crit?"":"......",
315 s?"(":"", s?s:"", s?") ":"", oid);
316 print_hex (der, derlen, 0);
317 putchar (')');
318 putchar ('\n');
319 }
320 if (err && gpg_err_code (err) != GPG_ERR_EOF)
321 fail_if_err (err);
322
323 for (idx=0; !(err=ksba_ocsp_get_extension (ocsp, cert, idx,
324 &oid, &crit,
325 &der, &derlen)); idx++)
326 {
327 const char *s = get_oid_desc (oid);
328 printf ("%ssngl-extn ..%s: %s%s%s%s (",
329 crit? "crit. ":"",
330 crit?"":"......",
331 s?"(":"", s?s:"", s?") ":"", oid);
332 print_hex (der, derlen, 0);
333 putchar (')');
334 putchar ('\n');
335 }
336 if (err && gpg_err_code (err) != GPG_ERR_EOF)
337 fail_if_err (err);
338 }
339 }
340
341
342 ksba_cert_release (cert);
343 ksba_ocsp_release (ocsp);
344 xfree (response);
345 }
346
347
348 static gpg_error_t
349 my_hash_buffer (void *arg, const char *oid,
350 const void *buffer, size_t length, size_t resultsize,
351 unsigned char *result, size_t *resultlen)
352 {
353 (void)arg; /* Not used. */
354
355 if (!oid || !strcmp (oid, "1.3.14.3.2.26"))
356 {
357 if (resultsize < 20)
358 return gpg_error (GPG_ERR_BUFFER_TOO_SHORT);
359 sha1_hash_buffer (result, buffer, length);
360 *resultlen = 20;
361 }
362 else if (!strcmp (oid, "2.16.840.1.101.3.4.2.1"))
363 {
364 if (resultsize < 32)
365 return gpg_error (GPG_ERR_BUFFER_TOO_SHORT);
366 sha256_hash_buffer (result, buffer, length);
367 *resultlen = 32;
368 }
369 else
370 return gpg_error (GPG_ERR_NOT_SUPPORTED); /* Not SHA1 or SHA256. */
371 return 0;
372 }
373
374
375
376
377 /* ( printf "POST / HTTP/1.0\r\nContent-Type: application/ocsp-request\r\nContent-Length: `wc -c <a.req | tr -d ' '`\r\n\r\n"; cat a.req ) | nc -v ocsp.openvalidation.org 8088 | sed '1,/^\r$/d' >a.rsp
378
379 Openvalidation test reponders:
380
381 Port: 80 Standard configuration. OCSP Responder will accept
382 all proper requests and send a signed response.
383 Port: 8080 Response does not contain any attached certificates.
384 Client must accept this response
385 Port: 8081 Never replies nonce. Insecure but standard conform mode.
386 Client application should warn in case of replay-attacks.
387 Port: 8082 The OCSP Responder will sign the response with randomized
388 bytecode. Client should NOT accept this response.
389 Port: 8083 OCSP response will always be revoked.
390 Port: 8084 OCSP response will always be unknown.
391 Port: 8085 OCSP response will always be malformed.
392 Port: 8086 OCSP response will always be internal error.
393 Port: 8087 OCSP response will always be try later.
394 Port: 8088 OCSP response will always be signature required.
395 Port: 8089 OCSP response will always be unauth.
396 Port: 8090 Standard configuration with full Debuglogs. Access the
397 logs at http://www.openvalidation.org/en/test/logs.html
398
399 */
400
401 int
402 main (int argc, char **argv)
403 {
404 int last_argc = -1;
405 int response_mode = 0;
406 const char *srcdir = getenv ("srcdir");
407
408 if (!srcdir)
409 srcdir = ".";
410
411 ksba_set_hash_buffer_function (my_hash_buffer, NULL);
412
413 if (argc)
414 {
415 argc--; argv++;
416 }
417 while (argc && last_argc != argc )
418 {
419 last_argc = argc;
420 if (!strcmp (*argv, "--help"))
421 {
422 puts (
423 "usage: ./t-ocsp [options] {CERTFILE ISSUERCERTFILE}\n"
424 " ./t-ocsp [options] --response {CERTFILE ISSUERCERTFILE RESPONSEFILE}\n"
425 "\n"
426 " Options are --verbose and --debug");
427 exit (0);
428 }
429 if (!strcmp (*argv, "--verbose"))
430 {
431 verbose = 1;
432 argc--; argv++;
433 }
434 else if (!strcmp (*argv, "--debug"))
435 {
436 verbose = debug = 1;
437 argc--; argv++;
438 }
439 else if (!strcmp (*argv, "--response"))
440 {
441 response_mode = 1;
442 argc--; argv++;
443 }
444 else if (!strcmp (*argv, "--no-nonce"))
445 {
446 no_nonce = 1;
447 argc--; argv++;
448 }
449 else if (!strcmp (*argv, "--sha256"))
450 {
451 sha256_certid = 1;
452 argc--; argv++;
453 }
454 }
455
456
457 if (response_mode)
458 {
459 for ( ; argc > 2; argc -=3, argv += 3)
460 one_response (*argv, argv[1], argv[2]);
461 if (argc)
462 fputs ("warning: extra argument ignored\n", stderr);
463 }
464 else if (argc)
465 {
466 for ( ; argc > 1; argc -=2, argv += 2)
467 one_request (*argv, argv[1]);
468 if (argc)
469 fputs ("warning: extra argument ignored\n", stderr);
470 }
471 else
472 {
473 struct {
474 const char *cert_fname;
475 const char *issuer_cert_fname;
476 const char *response_fname;
477 } files[] = {
478 { "samples/ov-userrev.crt", "samples/ov-root-ca-cert.crt", NULL },
479 { NULL }
480 };
481 int idx;
482
483 for (idx=0; files[idx].cert_fname; idx++)
484 {
485 char *f1, *f2;
486
487 f1 = prepend_srcdir (files[idx].cert_fname);
488 f2 = prepend_srcdir (files[idx].issuer_cert_fname);
489 one_request (f1, f2);
490 xfree (f2);
491 xfree (f1);
492 }
493 }
494
495 return 0;
496 }