Debian Codegraph @

tests/cert-basic.c

raw
1 /* cert-basic.c - basic test for the certificate management.
2 * Copyright (C) 2001, 2002, 2004, 2005 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 <errno.h>
25
26 #include "../src/ksba.h"
27 #define _KSBA_VISIBILITY_DEFAULT /* */
28 #include "../src/keyinfo.h"
29
30 #include "oidtranstbl.h"
31 #include "t-common.h"
32
33 #define digitp(p) (*(p) >= '0' && *(p) <= '9')
34
35 #define fail_if_err(a) do { if(a) { \
36 fprintf (stderr, "%s:%d: KSBA error: %s\n", \
37 __FILE__, __LINE__, gpg_strerror(a)); \
38 exit (1); } \
39 } while(0)
40
41
42 #define fail_if_err2(f, a) do { if(a) {\
43 fprintf (stderr, "%s:%d: KSBA error on file `%s': %s\n", \
44 __FILE__, __LINE__, (f), gpg_strerror(a)); \
45 exit (1); } \
46 } while(0)
47
48 #define xfree(a) ksba_free (a)
49
50 static int quiet;
51 static int verbose;
52 static int errorcount;
53
54
55 static void
56 print_names (int indent, ksba_name_t name)
57 {
58 int idx;
59 const char *s;
60 int indent_all;
61
62 if ((indent_all = (indent < 0)))
63 indent = - indent;
64
65 if (!name)
66 {
67 if (!quiet)
68 fputs ("none\n", stdout);
69 return;
70 }
71
72 for (idx=0; (s = ksba_name_enum (name, idx)); idx++)
73 {
74 char *p = ksba_name_get_uri (name, idx);
75 if (!quiet)
76 printf ("%*s%s\n", idx||indent_all?indent:0, "", p?p:s);
77 xfree (p);
78 }
79 }
80
81
82 /* Return the description for OID; if no description is available
83 NULL is returned. */
84 static const char *
85 get_oid_desc (const char *oid)
86 {
87 int i;
88
89 if (oid)
90 for (i=0; oidtranstbl[i].oid; i++)
91 if (!strcmp (oidtranstbl[i].oid, oid))
92 return oidtranstbl[i].desc;
93 return NULL;
94 }
95
96
97 static void
98 print_oid_and_desc (const char *oid, int with_lf)
99 {
100 const char *s = get_oid_desc (oid);
101 printf ("%s%s%s%s",
102 oid, s?" (":"", s?s:"", s?")":"");
103 if (with_lf)
104 putchar ('\n');
105 }
106
107
108 static void
109 print_oid_list (int indent, char *list)
110 {
111 char *lf;
112 int indent_all, c;
113 size_t n;
114
115 if ((indent_all = (indent < 0)))
116 indent = - indent;
117
118 while (*list)
119 {
120 printf ("%*s", indent_all?indent:0, "");
121 indent_all = 1;
122
123 if (!(lf = strchr (list, '\n')))
124 lf = list + strlen (list);
125
126 n = strspn (list, "0123456789.");
127 c = list[n];
128 list[n] = 0;
129 print_oid_and_desc (list, 0);
130 list[n] = c;
131
132 c = *lf;
133 *lf = 0;
134 printf (" %s\n", list+n);
135 *lf = c;
136 list = *lf? (lf+1):lf;
137 }
138 }
139
140
141
142
143 static void
144 list_extensions (ksba_cert_t cert)
145 {
146 gpg_error_t err;
147 const char *oid;
148 int idx, crit, is_ca, pathlen;
149 size_t off, len;
150 unsigned int usage, reason;
151 char *string, *p;
152 ksba_name_t name1, name2;
153 ksba_sexp_t serial;
154 ksba_sexp_t keyid;
155
156 for (idx=0; !(err=ksba_cert_get_extension (cert, idx,
157 &oid, &crit, &off, &len));idx++)
158 {
159 const char *s = get_oid_desc (oid);
160 if (!quiet)
161 printf ("Extn: %s%s%s%s at %d with length %d %s\n",
162 oid, s?" (":"", s?s:"", s?")":"",
163 (int)off, (int)len, crit? "(critical)":"");
164 }
165 if (err && gpg_err_code (err) != GPG_ERR_EOF )
166 {
167 fprintf (stderr,
168 "%s:%d: enumerating extensions failed: %s\n",
169 __FILE__, __LINE__, gpg_strerror (err));
170 errorcount++;
171 }
172
173 /* subjectKeyIdentifier */
174 err = ksba_cert_get_subj_key_id (cert, NULL, &keyid);
175 if (!err || gpg_err_code (err) == GPG_ERR_NO_DATA)
176 {
177 if (!quiet)
178 fputs ("SubjectKeyIdentifier: ", stdout);
179 if (gpg_err_code (err) == GPG_ERR_NO_DATA)
180 {
181 if (!quiet)
182 fputs ("none\n", stdout);
183 }
184 else
185 {
186 if (!quiet)
187 {
188 print_sexp (keyid);
189 putchar ('\n');
190 }
191 }
192 ksba_free (keyid);
193 }
194
195
196 /* authorityKeyIdentifier */
197 err = ksba_cert_get_auth_key_id (cert, &keyid, &name1, &serial);
198 if (!err || gpg_err_code (err) == GPG_ERR_NO_DATA)
199 {
200 if (!quiet)
201 fputs ("AuthorityKeyIdentifier: ", stdout);
202 if (gpg_err_code (err) == GPG_ERR_NO_DATA)
203 {
204 if (!quiet)
205 fputs ("none\n", stdout);
206 }
207 else
208 {
209 if (name1)
210 {
211 print_names (24, name1);
212 ksba_name_release (name1);
213 if (!quiet)
214 {
215 fputs (" serial: ", stdout);
216 print_sexp (serial);
217 }
218 ksba_free (serial);
219 }
220 if (!quiet)
221 putchar ('\n');
222 if (keyid)
223 {
224 if (!quiet)
225 {
226 fputs (" keyIdentifier: ", stdout);
227 print_sexp (keyid);
228 putchar ('\n');
229 }
230 ksba_free (keyid);
231 }
232 }
233 }
234 else
235 {
236 fprintf (stderr, "%s:%d: ksba_cert_get_auth_key_id: %s\n",
237 __FILE__, __LINE__, gpg_strerror (err));
238 errorcount++;
239 }
240
241 err = ksba_cert_is_ca (cert, &is_ca, &pathlen);
242 if (err)
243 {
244 fprintf (stderr, "%s:%d: ksba_cert_is_ca failed: %s\n",
245 __FILE__, __LINE__, gpg_strerror (err));
246 errorcount++;
247 }
248 else if (is_ca)
249 {
250 if (!quiet)
251 printf ("This is a CA certificate with a path length of %d\n", pathlen);
252 }
253
254 err = ksba_cert_get_key_usage (cert, &usage);
255 if (gpg_err_code (err) == GPG_ERR_NO_DATA)
256 {
257 if (!quiet)
258 printf ("KeyUsage: Not specified\n");
259 }
260 else if (err)
261 {
262 fprintf (stderr, "%s:%d: ksba_cert_get_key_usage failed: %s\n",
263 __FILE__, __LINE__, gpg_strerror (err));
264 errorcount++;
265 }
266 else if (!quiet)
267 {
268 fputs ("KeyUsage:", stdout);
269 if ( (usage & KSBA_KEYUSAGE_DIGITAL_SIGNATURE))
270 fputs (" digitalSignature", stdout);
271 if ( (usage & KSBA_KEYUSAGE_NON_REPUDIATION))
272 fputs (" nonRepudiation", stdout);
273 if ( (usage & KSBA_KEYUSAGE_KEY_ENCIPHERMENT))
274 fputs (" keyEncipherment", stdout);
275 if ( (usage & KSBA_KEYUSAGE_DATA_ENCIPHERMENT))
276 fputs (" dataEncripherment", stdout);
277 if ( (usage & KSBA_KEYUSAGE_KEY_AGREEMENT))
278 fputs (" keyAgreement", stdout);
279 if ( (usage & KSBA_KEYUSAGE_KEY_CERT_SIGN))
280 fputs (" certSign", stdout);
281 if ( (usage & KSBA_KEYUSAGE_CRL_SIGN))
282 fputs (" crlSign", stdout);
283 if ( (usage & KSBA_KEYUSAGE_ENCIPHER_ONLY))
284 fputs (" encipherOnly", stdout);
285 if ( (usage & KSBA_KEYUSAGE_DECIPHER_ONLY))
286 fputs (" decipherOnly", stdout);
287 putchar ('\n');
288 }
289 err = ksba_cert_get_ext_key_usages (cert, &string);
290 if (gpg_err_code (err) == GPG_ERR_NO_DATA)
291 {
292 if (!quiet)
293 printf ("ExtKeyUsages: none\n");
294 }
295 else if (err)
296 {
297 fprintf (stderr, "%s:%d: ksba_cert_ext_key_usages failed: %s\n",
298 __FILE__, __LINE__, gpg_strerror (err));
299 errorcount++;
300 }
301 else
302 {
303 if (!quiet)
304 {
305 fputs ("ExtKeyUsages: ", stdout);
306 print_oid_list (14, string);
307 }
308 xfree (string);
309 }
310
311
312 err = ksba_cert_get_cert_policies (cert, &string);
313 if (gpg_err_code (err) == GPG_ERR_NO_DATA)
314 {
315 if (!quiet)
316 printf ("CertificatePolicies: none\n");
317 }
318 else if (err)
319 {
320 fprintf (stderr, "%s:%d: ksba_cert_get_cert_policies failed: %s\n",
321 __FILE__, __LINE__, gpg_strerror (err));
322 errorcount++;
323 }
324 else
325 {
326 if (!quiet)
327 {
328 /* for display purposes we replace the linefeeds by commas */
329 for (p=string; *p; p++)
330 {
331 if (*p == '\n')
332 *p = ',';
333 }
334 fputs ("CertificatePolicies: ", stdout);
335 print_oid_list (21, string);
336 }
337 xfree (string);
338 }
339
340 /* CRL distribution point */
341 for (idx=0; !(err=ksba_cert_get_crl_dist_point (cert, idx,
342 &name1, &name2,
343 &reason));idx++)
344 {
345 if (!quiet)
346 fputs ("CRLDistPoint: ", stdout);
347 print_names (14, name1);
348 if (!quiet)
349 {
350 fputs (" reasons:", stdout);
351 if ( !reason )
352 fputs (" none", stdout);
353 if ( (reason & KSBA_CRLREASON_UNSPECIFIED))
354 fputs (" unused", stdout);
355 if ( (reason & KSBA_CRLREASON_KEY_COMPROMISE))
356 fputs (" keyCompromise", stdout);
357 if ( (reason & KSBA_CRLREASON_CA_COMPROMISE))
358 fputs (" caCompromise", stdout);
359 if ( (reason & KSBA_CRLREASON_AFFILIATION_CHANGED))
360 fputs (" affiliationChanged", stdout);
361 if ( (reason & KSBA_CRLREASON_SUPERSEDED))
362 fputs (" superseded", stdout);
363 if ( (reason & KSBA_CRLREASON_CESSATION_OF_OPERATION))
364 fputs (" cessationOfOperation", stdout);
365 if ( (reason & KSBA_CRLREASON_CERTIFICATE_HOLD))
366 fputs (" certificateHold", stdout);
367 putchar ('\n');
368 fputs (" issuer: ", stdout);
369 }
370 print_names (14, name2);
371 ksba_name_release (name1);
372 ksba_name_release (name2);
373 }
374 if (err && gpg_err_code (err) != GPG_ERR_EOF)
375 {
376 fprintf (stderr, "%s:%d: ksba_cert_get_crl_dist_point failed: %s\n",
377 __FILE__, __LINE__, gpg_strerror (err));
378 errorcount++;
379 }
380
381 /* authorityInfoAccess. */
382 for (idx=0; !(err=ksba_cert_get_authority_info_access (cert, idx,
383 &string, &name1))
384 ; idx++)
385 {
386 if (!quiet)
387 {
388 fputs ("authorityInfoAccess: ", stdout);
389 print_oid_and_desc (string, 1);
390 }
391 print_names (-21, name1);
392 ksba_name_release (name1);
393 ksba_free (string);
394 }
395 if (err && gpg_err_code (err) != GPG_ERR_EOF)
396 {
397 fprintf (stderr, "%s:%d: "
398 "ksba_cert_get_authority_info_access failed: %s\n",
399 __FILE__, __LINE__, gpg_strerror (err));
400 errorcount++;
401 }
402
403 /* subjectInfoAccess. */
404 for (idx=0; !(err=ksba_cert_get_subject_info_access (cert, idx,
405 &string, &name1))
406 ; idx++)
407 {
408 if (!quiet)
409 {
410 fputs ("subjectInfoAccess: ", stdout);
411 print_oid_and_desc (string, 1);
412 }
413 print_names (-19, name1);
414 ksba_name_release (name1);
415 ksba_free (string);
416 }
417 if (err && gpg_err_code (err) != GPG_ERR_EOF)
418 {
419 fprintf (stderr, "%s:%d: "
420 "ksba_cert_get_subject_info_access failed: %s\n",
421 __FILE__, __LINE__, gpg_strerror (err));
422 errorcount++;
423 }
424
425 }
426
427
428 static void
429 one_file (const char *fname)
430 {
431 gpg_error_t err;
432 FILE *fp;
433 ksba_reader_t r;
434 ksba_cert_t cert;
435 char *dn;
436 ksba_isotime_t t;
437 int idx;
438 ksba_sexp_t sexp;
439 const char *oid, *s;
440
441 fp = fopen (fname, "rb");
442 if (!fp)
443 {
444 fprintf (stderr, "%s:%d: can't open `%s': %s\n",
445 __FILE__, __LINE__, fname, strerror (errno));
446 exit (1);
447 }
448
449 err = ksba_reader_new (&r);
450 if (err)
451 fail_if_err (err);
452 err = ksba_reader_set_file (r, fp);
453 fail_if_err (err);
454
455 err = ksba_cert_new (&cert);
456 if (err)
457 fail_if_err (err);
458
459 err = ksba_cert_read_der (cert, r);
460 fail_if_err2 (fname, err);
461
462 if (!quiet)
463 printf ("Certificate in `%s':\n", fname);
464
465 sexp = ksba_cert_get_serial (cert);
466 if (!quiet)
467 {
468 fputs (" serial....: ", stdout);
469 print_sexp (sexp);
470 putchar ('\n');
471 }
472 ksba_free (sexp);
473
474 for (idx=0;(dn = ksba_cert_get_issuer (cert, idx));idx++)
475 {
476 if (!quiet)
477 {
478 fputs (idx?" aka: ":" issuer....: ", stdout);
479 print_dn (dn);
480 putchar ('\n');
481 }
482 ksba_free (dn);
483 }
484
485 for (idx=0;(dn = ksba_cert_get_subject (cert, idx));idx++)
486 {
487 if (!quiet)
488 {
489 fputs (idx?" aka: ":" subject...: ", stdout);
490 print_dn (dn);
491 putchar ('\n');
492 }
493 ksba_free (dn);
494 }
495
496 ksba_cert_get_validity (cert, 0, t);
497 if (!quiet)
498 {
499 fputs (" notBefore.: ", stdout);
500 print_time (t);
501 putchar ('\n');
502 }
503 ksba_cert_get_validity (cert, 1, t);
504 if (!quiet)
505 {
506 fputs (" notAfter..: ", stdout);
507 print_time (t);
508 putchar ('\n');
509 }
510 oid = ksba_cert_get_digest_algo (cert);
511 s = get_oid_desc (oid);
512 if (!quiet)
513 printf (" hash algo.: %s%s%s%s\n",
514 oid?oid:"(null)", s?" (":"",s?s:"",s?")":"");
515
516 /* Under Windows the _ksba_keyinfo_from_sexp are not exported. */
517 #ifndef __WIN32
518 /* check that the sexp to keyinfo conversion works */
519 {
520 ksba_sexp_t public;
521
522 public = ksba_cert_get_public_key (cert);
523 if (!public)
524 {
525 fprintf (stderr, "%s:%d: public key not found\n",
526 __FILE__, __LINE__);
527 errorcount++;
528 }
529 else
530 {
531 unsigned char *der;
532 size_t derlen;
533
534 if (verbose)
535 {
536 fputs (" pubkey....: ", stdout);
537 print_sexp (public);
538 putchar ('\n');
539 }
540
541 err = _ksba_keyinfo_from_sexp (public, 0, &der, &derlen);
542 if (err)
543 {
544 fprintf (stderr, "%s:%d: converting public key failed: %s\n",
545 __FILE__, __LINE__, gpg_strerror (err));
546 errorcount++;
547 }
548 else
549 {
550 ksba_sexp_t tmp;
551
552 if (verbose)
553 {
554 fputs (" pubkey-DER: ", stdout);
555 print_hex (der, derlen, 0);
556 putchar ('\n');
557 }
558 err = _ksba_keyinfo_to_sexp (der, derlen, &tmp);
559 if (err)
560 {
561 fprintf (stderr,
562 "%s:%d: re-converting public key failed: %s\n",
563 __FILE__, __LINE__, gpg_strerror (err));
564 errorcount++;
565 }
566 else
567 {
568 unsigned char *der2;
569 size_t derlen2;
570
571 err = _ksba_keyinfo_from_sexp (tmp, 0, &der2, &derlen2);
572 if (err)
573 {
574 fprintf (stderr, "%s:%d: re-re-converting "
575 "public key failed: %s\n",
576 __FILE__, __LINE__, gpg_strerror (err));
577 errorcount++;
578 }
579 else if (derlen != derlen2 || memcmp (der, der2, derlen))
580 {
581 fprintf (stderr, "%s:%d: mismatch after "
582 "re-re-converting public key\n",
583 __FILE__, __LINE__);
584 errorcount++;
585 xfree (der2);
586 }
587 else
588 {
589 /* Don't leak memory if everything is ok. */
590 xfree (der2);
591 }
592 xfree (tmp);
593 }
594 xfree (der);
595 }
596 ksba_free (public);
597 }
598 }
599 #endif
600
601 if (verbose)
602 {
603 sexp = ksba_cert_get_sig_val (cert);
604 fputs (" sigval....: ", stdout);
605 print_sexp (sexp);
606 putchar ('\n');
607 ksba_free (sexp);
608 }
609
610 list_extensions (cert);
611
612 ksba_cert_release (cert);
613 err = ksba_cert_new (&cert);
614 if (err)
615 fail_if_err (err);
616
617 err = ksba_cert_read_der (cert, r);
618 if (err && gpg_err_code (err) != GPG_ERR_EOF)
619 {
620 fprintf (stderr, "%s:%d: expected EOF but got: %s\n",
621 __FILE__, __LINE__, gpg_strerror (err));
622 errorcount++;
623 }
624
625 if (!quiet)
626 putchar ('\n');
627 ksba_cert_release (cert);
628 ksba_reader_release (r);
629 fclose (fp);
630 }
631
632
633
634
635 int
636 main (int argc, char **argv)
637 {
638 const char *srcdir = getenv ("srcdir");
639
640 if (!srcdir)
641 srcdir = ".";
642
643 if (argc)
644 {
645 argc--; argv++;
646 }
647
648 if (argc && !strcmp (*argv, "--verbose"))
649 {
650 verbose = 1;
651 argc--; argv++;
652 }
653
654
655 if (argc)
656 {
657 for (; argc; argc--, argv++)
658 one_file (*argv);
659 }
660 else
661 {
662 const char *files[] = {
663 "cert_dfn_pca01.der",
664 "cert_dfn_pca15.der",
665 "cert_g10code_test1.der",
666 "authority.crt",
667 "betsy.crt",
668 "bull.crt",
669 "ov-ocsp-server.crt",
670 "ov-userrev.crt",
671 "ov-root-ca-cert.crt",
672 "ov-serverrev.crt",
673 "ov-user.crt",
674 "ov-server.crt",
675 "ov2-root-ca-cert.crt",
676 "ov2-ocsp-server.crt",
677 "ov2-user.crt",
678 "ov2-userrev.crt",
679 "secp256r1-sha384_cert.crt",
680 "secp256r1-sha512_cert.crt",
681 "secp384r1-sha512_cert.crt",
682 "openssl-secp256r1ca.cert.crt",
683 "ed25519-rfc8410.crt",
684 "ed25519-ossl-1.crt",
685 "ed448-ossl-1.crt",
686 NULL
687 };
688 int idx;
689
690 if (!verbose)
691 quiet = 1;
692
693 for (idx=0; files[idx]; idx++)
694 {
695 char *fname;
696
697 fname = xmalloc (strlen (srcdir) + 10 + strlen (files[idx]) + 1);
698 strcpy (fname, srcdir);
699 strcat (fname, "/samples/");
700 strcat (fname, files[idx]);
701 one_file (fname);
702 ksba_free (fname);
703 }
704 }
705
706 return !!errorcount;
707 }