dirmngr: Load all system provided certificates.
[gnupg.git] / dirmngr / validate.c
1 /* validate.c - Validate a certificate chain.
2  * Copyright (C) 2001, 2003, 2004, 2008 Free Software Foundation, Inc.
3  * Copyright (C) 2004, 2006, 2008 g10 Code GmbH
4  *
5  * This file is part of DirMngr.
6  *
7  * DirMngr is free software; you can redistribute it and/or modify
8  * it under the terms of the GNU General Public License as published by
9  * the Free Software Foundation; either version 2 of the License, or
10  * (at your option) any later version.
11  *
12  * DirMngr is distributed in the hope that it will be useful,
13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15  * GNU General Public License for more details.
16  *
17  * You should have received a copy of the GNU General Public License
18  * along with this program; if not, write to the Free Software
19  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
20  */
21
22 #include <config.h>
23
24 #include <stdio.h>
25 #include <stdlib.h>
26 #include <errno.h>
27 #include <assert.h>
28 #include <ctype.h>
29
30 #include "dirmngr.h"
31 #include "certcache.h"
32 #include "crlcache.h"
33 #include "validate.h"
34 #include "misc.h"
35
36 /* While running the validation function we need to keep track of the
37    certificates and the validation outcome of each.  We use this type
38    for it.  */
39 struct chain_item_s
40 {
41   struct chain_item_s *next;
42   ksba_cert_t cert;      /* The certificate.  */
43   unsigned char fpr[20]; /* Fingerprint of the certificate.  */
44   int is_self_signed;    /* This certificate is self-signed.  */
45   int is_valid;          /* The certifiate is valid except for revocations.  */
46 };
47 typedef struct chain_item_s *chain_item_t;
48
49
50 /* A couple of constants with Object Identifiers.  */
51 static const char oid_kp_serverAuth[]     = "1.3.6.1.5.5.7.3.1";
52 static const char oid_kp_clientAuth[]     = "1.3.6.1.5.5.7.3.2";
53 static const char oid_kp_codeSigning[]    = "1.3.6.1.5.5.7.3.3";
54 static const char oid_kp_emailProtection[]= "1.3.6.1.5.5.7.3.4";
55 static const char oid_kp_timeStamping[]   = "1.3.6.1.5.5.7.3.8";
56 static const char oid_kp_ocspSigning[]    = "1.3.6.1.5.5.7.3.9";
57
58
59 /* Prototypes.  */
60 static gpg_error_t check_cert_sig (ksba_cert_t issuer_cert, ksba_cert_t cert);
61
62
63
64
65 /* Check whether CERT contains critical extensions we don't know
66    about.  */
67 static gpg_error_t
68 unknown_criticals (ksba_cert_t cert)
69 {
70   static const char *known[] = {
71     "2.5.29.15", /* keyUsage */
72     "2.5.29.19", /* basic Constraints */
73     "2.5.29.32", /* certificatePolicies */
74     "2.5.29.37", /* extendedKeyUsage */
75     NULL
76   };
77   int i, idx, crit;
78   const char *oid;
79   int unsupported;
80   strlist_t sl;
81   gpg_error_t err, rc;
82
83   rc = 0;
84   for (idx=0; !(err=ksba_cert_get_extension (cert, idx,
85                                              &oid, &crit, NULL, NULL));idx++)
86     {
87       if (!crit)
88         continue;
89       for (i=0; known[i] && strcmp (known[i],oid); i++)
90         ;
91       unsupported = !known[i];
92
93       /* If this critical extension is not supported, check the list
94          of to be ignored extensions to see whether we claim that it
95          is supported.  */
96       if (unsupported && opt.ignored_cert_extensions)
97         {
98           for (sl=opt.ignored_cert_extensions;
99                sl && strcmp (sl->d, oid); sl = sl->next)
100             ;
101           if (sl)
102             unsupported = 0;
103         }
104
105       if (unsupported)
106         {
107           log_error (_("critical certificate extension %s is not supported"),
108                      oid);
109           rc = gpg_error (GPG_ERR_UNSUPPORTED_CERT);
110         }
111     }
112   if (err && gpg_err_code (err) != GPG_ERR_EOF)
113     rc = err; /* Such an error takes precendence.  */
114
115   return rc;
116 }
117
118
119 /* Basic check for supported policies.  */
120 static gpg_error_t
121 check_cert_policy (ksba_cert_t cert)
122 {
123   static const char *allowed[] = {
124     "2.289.9.9",
125     NULL
126   };
127   gpg_error_t err;
128   int idx;
129   char *p, *haystack;
130   char *policies;
131   int any_critical;
132
133   err = ksba_cert_get_cert_policies (cert, &policies);
134   if (gpg_err_code (err) == GPG_ERR_NO_DATA)
135     return 0; /* No policy given. */
136   if (err)
137     return err;
138
139   /* STRING is a line delimited list of certifiate policies as stored
140      in the certificate.  The line itself is colon delimited where the
141      first field is the OID of the policy and the second field either
142      N or C for normal or critical extension */
143   if (opt.verbose > 1)
144     log_info ("certificate's policy list: %s\n", policies);
145
146   /* The check is very minimal but won't give false positives */
147   any_critical = !!strstr (policies, ":C");
148
149   /* See whether we find ALLOWED (which is an OID) in POLICIES */
150   for (idx=0; allowed[idx]; idx++)
151     {
152       for (haystack=policies; (p=strstr (haystack, allowed[idx]));
153            haystack = p+1)
154         {
155           if ( !(p == policies || p[-1] == '\n') )
156             continue; /* Does not match the begin of a line. */
157           if (p[strlen (allowed[idx])] != ':')
158             continue; /* The length does not match. */
159           /* Yep - it does match: Return okay. */
160           ksba_free (policies);
161           return 0;
162         }
163     }
164
165   if (!any_critical)
166     {
167       log_info (_("Note: non-critical certificate policy not allowed"));
168       err = 0;
169     }
170   else
171     {
172       log_info (_("certificate policy not allowed"));
173       err = gpg_error (GPG_ERR_NO_POLICY_MATCH);
174     }
175
176   ksba_free (policies);
177   return err;
178 }
179
180
181 static gpg_error_t
182 allowed_ca (ksba_cert_t cert, int *chainlen)
183 {
184   gpg_error_t err;
185   int flag;
186
187   err = ksba_cert_is_ca (cert, &flag, chainlen);
188   if (err)
189     return err;
190   if (!flag)
191     {
192       if (!is_trusted_cert (cert, 0))
193         {
194           /* The German SigG Root CA's certificate does not flag
195              itself as a CA; thus we relax this requirement if we
196              trust a root CA.  I think this is reasonable.  Note, that
197              gpgsm implements a far stricter scheme here. */
198           if (chainlen)
199             *chainlen = 3; /* That is what the SigG implements. */
200           if (opt.verbose)
201             log_info (_("accepting root CA not marked as a CA"));
202         }
203       else
204         {
205           log_error (_("issuer certificate is not marked as a CA"));
206           return gpg_error (GPG_ERR_BAD_CA_CERT);
207         }
208     }
209   return 0;
210 }
211
212 /* Helper for validate_cert_chain.  */
213 static gpg_error_t
214 check_revocations (ctrl_t ctrl, chain_item_t chain)
215 {
216   gpg_error_t err = 0;
217   int any_revoked = 0;
218   int any_no_crl = 0;
219   int any_crl_too_old = 0;
220   chain_item_t ci;
221
222   assert (ctrl->check_revocations_nest_level >= 0);
223   assert (chain);
224
225   if (ctrl->check_revocations_nest_level > 10)
226     {
227       log_error (_("CRL checking too deeply nested\n"));
228       return gpg_error(GPG_ERR_BAD_CERT_CHAIN);
229     }
230   ctrl->check_revocations_nest_level++;
231
232
233   for (ci=chain; ci; ci = ci->next)
234     {
235       assert (ci->cert);
236       if (ci == chain)
237         {
238           /* It does not make sense to check the root certificate for
239              revocations.  In almost all cases this will lead to a
240              catch-22 as the root certificate is the final trust
241              anchor for the certificates and the CRLs.  We expect the
242              user to remove root certificates from the list of trusted
243              certificates in case they have been revoked. */
244           if (opt.verbose)
245             cert_log_name (_("not checking CRL for"), ci->cert);
246           continue;
247         }
248
249       if (opt.verbose)
250         cert_log_name (_("checking CRL for"), ci->cert);
251       err = crl_cache_cert_isvalid (ctrl, ci->cert, 0);
252       if (gpg_err_code (err) == GPG_ERR_NO_CRL_KNOWN)
253         {
254           err = crl_cache_reload_crl (ctrl, ci->cert);
255           if (!err)
256             err = crl_cache_cert_isvalid (ctrl, ci->cert, 0);
257         }
258       switch (gpg_err_code (err))
259         {
260         case 0: err = 0; break;
261         case GPG_ERR_CERT_REVOKED: any_revoked = 1; err = 0; break;
262         case GPG_ERR_NO_CRL_KNOWN: any_no_crl = 1; err = 0; break;
263         case GPG_ERR_CRL_TOO_OLD: any_crl_too_old = 1; err = 0; break;
264         default: break;
265         }
266     }
267   ctrl->check_revocations_nest_level--;
268
269
270   if (err)
271     ;
272   else if (any_revoked)
273     err = gpg_error (GPG_ERR_CERT_REVOKED);
274   else if (any_no_crl)
275     err = gpg_error (GPG_ERR_NO_CRL_KNOWN);
276   else if (any_crl_too_old)
277     err = gpg_error (GPG_ERR_CRL_TOO_OLD);
278   else
279     err = 0;
280   return err;
281 }
282
283
284 /* Check whether CERT is a root certificate.  ISSUERDN and SUBJECTDN
285    are the DNs already extracted by the caller from CERT.  Returns
286    True if this is the case. */
287 static int
288 is_root_cert (ksba_cert_t cert, const char *issuerdn, const char *subjectdn)
289 {
290   gpg_error_t err;
291   int result = 0;
292   ksba_sexp_t serialno;
293   ksba_sexp_t ak_keyid;
294   ksba_name_t ak_name;
295   ksba_sexp_t ak_sn;
296   const char *ak_name_str;
297   ksba_sexp_t subj_keyid = NULL;
298
299   if (!issuerdn || !subjectdn)
300     return 0;  /* No.  */
301
302   if (strcmp (issuerdn, subjectdn))
303     return 0;  /* No.  */
304
305   err = ksba_cert_get_auth_key_id (cert, &ak_keyid, &ak_name, &ak_sn);
306   if (err)
307     {
308       if (gpg_err_code (err) == GPG_ERR_NO_DATA)
309         return 1; /* Yes. Without a authorityKeyIdentifier this needs
310                      to be the Root certifcate (our trust anchor).  */
311       log_error ("error getting authorityKeyIdentifier: %s\n",
312                  gpg_strerror (err));
313       return 0; /* Well, it is broken anyway.  Return No. */
314     }
315
316   serialno = ksba_cert_get_serial (cert);
317   if (!serialno)
318     {
319       log_error ("error getting serialno: %s\n", gpg_strerror (err));
320       goto leave;
321     }
322
323   /* Check whether the auth name's matches the issuer name+sn.  If
324      that is the case this is a root certificate.  */
325   ak_name_str = ksba_name_enum (ak_name, 0);
326   if (ak_name_str
327       && !strcmp (ak_name_str, issuerdn)
328       && !cmp_simple_canon_sexp (ak_sn, serialno))
329     {
330       result = 1;  /* Right, CERT is self-signed.  */
331       goto leave;
332     }
333
334   /* Similar for the ak_keyid. */
335   if (ak_keyid && !ksba_cert_get_subj_key_id (cert, NULL, &subj_keyid)
336       && !cmp_simple_canon_sexp (ak_keyid, subj_keyid))
337     {
338       result = 1;  /* Right, CERT is self-signed.  */
339       goto leave;
340     }
341
342
343  leave:
344   ksba_free (subj_keyid);
345   ksba_free (ak_keyid);
346   ksba_name_release (ak_name);
347   ksba_free (ak_sn);
348   ksba_free (serialno);
349   return result;
350 }
351
352
353 /* Validate the certificate CHAIN up to the trust anchor. Optionally
354    return the closest expiration time in R_EXPTIME (this is useful for
355    caching issues).  MODE is one of the VALIDATE_MODE_* constants.
356
357    Note that VALIDATE_MODE_OCSP is not used due to the removal of the
358    system service in 2.1.15.  Instead only the callback to gpgsm to
359    validate a certificate is used.
360
361    If R_TRUST_ANCHOR is not NULL and the validation would fail only
362    because the root certificate is not trusted, the hexified
363    fingerprint of that root certificate is stored at R_TRUST_ANCHOR
364    and success is returned.  The caller needs to free the value at
365    R_TRUST_ANCHOR; in all other cases NULL is stored there.  */
366 gpg_error_t
367 validate_cert_chain (ctrl_t ctrl, ksba_cert_t cert, ksba_isotime_t r_exptime,
368                      int mode, char **r_trust_anchor)
369 {
370   gpg_error_t err = 0;
371   int depth, maxdepth;
372   char *issuer = NULL;
373   char *subject = NULL;
374   ksba_cert_t subject_cert = NULL;
375   ksba_cert_t issuer_cert = NULL;
376   ksba_isotime_t current_time;
377   ksba_isotime_t exptime;
378   int any_expired = 0;
379   int any_no_policy_match = 0;
380   chain_item_t chain;
381
382
383   if (r_exptime)
384     *r_exptime = 0;
385   *exptime = 0;
386
387   if (r_trust_anchor)
388     *r_trust_anchor = NULL;
389
390   if (DBG_X509)
391     dump_cert ("subject", cert);
392
393   /* May the target certificate be used for this purpose?  */
394   switch (mode)
395     {
396     case VALIDATE_MODE_OCSP:
397       err = cert_use_ocsp_p (cert);
398       break;
399     case VALIDATE_MODE_CRL:
400     case VALIDATE_MODE_CRL_RECURSIVE:
401       err = cert_use_crl_p (cert);
402       break;
403     default:
404       err = 0;
405       break;
406     }
407   if (err)
408     return err;
409
410   /* If we already validated the certificate not too long ago, we can
411      avoid the excessive computations and lookups unless the caller
412      asked for the expiration time.  */
413   if (!r_exptime)
414     {
415       size_t buflen;
416       time_t validated_at;
417
418       err = ksba_cert_get_user_data (cert, "validated_at",
419                                      &validated_at, sizeof (validated_at),
420                                      &buflen);
421       if (err || buflen != sizeof (validated_at) || !validated_at)
422         err = 0; /* Not available or other error. */
423       else
424         {
425           /* If the validation is not older than 30 minutes we are ready. */
426           if (validated_at < gnupg_get_time () + (30*60))
427             {
428               if (opt.verbose)
429                 log_info ("certificate is good (cached)\n");
430               /* Note, that we can't jump to leave here as this would
431                  falsely updated the validation timestamp.  */
432               return 0;
433             }
434         }
435     }
436
437   /* Get the current time. */
438   gnupg_get_isotime (current_time);
439
440   /* We walk up the chain until we find a trust anchor. */
441   subject_cert = cert;
442   maxdepth = 10;  /* Sensible limit on the length of the chain.  */
443   chain = NULL;
444   depth = 0;
445   for (;;)
446     {
447       /* Get the subject and issuer name from the current
448          certificate.  */
449       ksba_free (issuer);
450       ksba_free (subject);
451       issuer = ksba_cert_get_issuer (subject_cert, 0);
452       subject = ksba_cert_get_subject (subject_cert, 0);
453
454       if (!issuer)
455         {
456           log_error (_("no issuer found in certificate\n"));
457           err = gpg_error (GPG_ERR_BAD_CERT);
458           goto leave;
459         }
460
461       /* Handle the notBefore and notAfter timestamps.  */
462       {
463         ksba_isotime_t not_before, not_after;
464
465         err = ksba_cert_get_validity (subject_cert, 0, not_before);
466         if (!err)
467           err = ksba_cert_get_validity (subject_cert, 1, not_after);
468         if (err)
469           {
470             log_error (_("certificate with invalid validity: %s"),
471                        gpg_strerror (err));
472             err = gpg_error (GPG_ERR_BAD_CERT);
473             goto leave;
474           }
475
476         /* Keep track of the nearest expiration time in EXPTIME.  */
477         if (*not_after)
478           {
479             if (!*exptime)
480               gnupg_copy_time (exptime, not_after);
481             else if (strcmp (not_after, exptime) < 0 )
482               gnupg_copy_time (exptime, not_after);
483           }
484
485         /* Check whether the certificate is already valid.  */
486         if (*not_before && strcmp (current_time, not_before) < 0 )
487           {
488             log_error (_("certificate not yet valid"));
489             log_info ("(valid from ");
490             dump_isotime (not_before);
491             log_printf (")\n");
492             err = gpg_error (GPG_ERR_CERT_TOO_YOUNG);
493             goto leave;
494           }
495
496         /* Now check whether the certificate has expired.  */
497         if (*not_after && strcmp (current_time, not_after) > 0 )
498           {
499             log_error (_("certificate has expired"));
500             log_info ("(expired at ");
501             dump_isotime (not_after);
502             log_printf (")\n");
503             any_expired = 1;
504           }
505       }
506
507       /* Do we have any critical extensions in the certificate we
508          can't handle? */
509       err = unknown_criticals (subject_cert);
510       if (err)
511         goto leave; /* yes. */
512
513       /* Check that given policies are allowed.  */
514       err = check_cert_policy (subject_cert);
515       if (gpg_err_code (err) == GPG_ERR_NO_POLICY_MATCH)
516         {
517           any_no_policy_match = 1;
518           err = 0;
519         }
520       else if (err)
521         goto leave;
522
523       /* Is this a self-signed certificate? */
524       if (is_root_cert (subject_cert, issuer, subject))
525         {
526           /* Yes, this is our trust anchor.  */
527           if (check_cert_sig (subject_cert, subject_cert) )
528             {
529               log_error (_("selfsigned certificate has a BAD signature"));
530               err = gpg_error (depth? GPG_ERR_BAD_CERT_CHAIN
531                                     : GPG_ERR_BAD_CERT);
532               goto leave;
533             }
534
535           /* Is this certificate allowed to act as a CA.  */
536           err = allowed_ca (subject_cert, NULL);
537           if (err)
538             goto leave;  /* No. */
539
540           err = is_trusted_cert (subject_cert, 0);
541           if (!err)
542             ; /* Yes we trust this cert.  */
543           else if (gpg_err_code (err) == GPG_ERR_NOT_TRUSTED)
544             {
545               char *fpr;
546
547               log_error (_("root certificate is not marked trusted"));
548               fpr = get_fingerprint_hexstring (subject_cert);
549               log_info (_("fingerprint=%s\n"), fpr? fpr : "?");
550               dump_cert ("issuer", subject_cert);
551               if (r_trust_anchor)
552                 {
553                   /* Caller wants to do another trustiness check.  */
554                   *r_trust_anchor = fpr;
555                   err = 0;
556                 }
557               else
558                 xfree (fpr);
559             }
560           else
561             {
562               log_error (_("checking trustworthiness of "
563                            "root certificate failed: %s\n"),
564                          gpg_strerror (err));
565             }
566           if (err)
567             goto leave;
568
569           /* Prepend the certificate to our list.  */
570           {
571             chain_item_t ci;
572
573             ci = xtrycalloc (1, sizeof *ci);
574             if (!ci)
575               {
576                 err = gpg_error_from_errno (errno);
577                 goto leave;
578               }
579             ksba_cert_ref (subject_cert);
580             ci->cert = subject_cert;
581             cert_compute_fpr (subject_cert, ci->fpr);
582             ci->next = chain;
583             chain = ci;
584           }
585
586           if (opt.verbose)
587             {
588               if (r_trust_anchor && *r_trust_anchor)
589                 log_info ("root certificate is good but not trusted\n");
590               else
591                 log_info ("root certificate is good and trusted\n");
592             }
593
594           break;  /* Okay: a self-signed certicate is an end-point. */
595         }
596
597       /* To avoid loops, we use an arbitrary limit on the length of
598          the chain. */
599       depth++;
600       if (depth > maxdepth)
601         {
602           log_error (_("certificate chain too long\n"));
603           err = gpg_error (GPG_ERR_BAD_CERT_CHAIN);
604           goto leave;
605         }
606
607       /* Find the next cert up the tree. */
608       ksba_cert_release (issuer_cert); issuer_cert = NULL;
609       err = find_issuing_cert (ctrl, subject_cert, &issuer_cert);
610       if (err)
611         {
612           if (gpg_err_code (err) == GPG_ERR_NOT_FOUND)
613             {
614               log_error (_("issuer certificate not found"));
615               log_info ("issuer certificate: #/");
616               dump_string (issuer);
617               log_printf ("\n");
618             }
619           else
620             log_error (_("issuer certificate not found: %s\n"),
621                          gpg_strerror (err));
622           /* Use a better understandable error code.  */
623           err = gpg_error (GPG_ERR_MISSING_ISSUER_CERT);
624           goto leave;
625         }
626
627 /*     try_another_cert: */
628       if (DBG_X509)
629         {
630           log_debug ("got issuer's certificate:\n");
631           dump_cert ("issuer", issuer_cert);
632         }
633
634       /* Now check the signature of the certificate.  FIXME: we should
635        * delay this until later so that faked certificates can't be
636        * turned into a DoS easily.  */
637       err = check_cert_sig (issuer_cert, subject_cert);
638       if (err)
639         {
640           log_error (_("certificate has a BAD signature"));
641 #if 0
642           if (gpg_err_code (err) == GPG_ERR_BAD_SIGNATURE)
643             {
644               /* We now try to find other issuer certificates which
645                  might have been used.  This is required because some
646                  CAs are reusing the issuer and subject DN for new
647                  root certificates without using a  authorityKeyIdentifier. */
648               rc = find_up (kh, subject_cert, issuer, 1);
649               if (!rc)
650                 {
651                   ksba_cert_t tmp_cert;
652
653                   rc = keydb_get_cert (kh, &tmp_cert);
654                   if (rc || !compare_certs (issuer_cert, tmp_cert))
655                     {
656                       /* The find next did not work or returned an
657                          identical certificate.  We better stop here
658                          to avoid infinite checks. */
659                       rc = gpg_error (GPG_ERR_BAD_SIGNATURE);
660                       ksba_cert_release (tmp_cert);
661                     }
662                   else
663                     {
664                       do_list (0, lm, fp, _("found another possible matching "
665                                             "CA certificate - trying again"));
666                       ksba_cert_release (issuer_cert);
667                       issuer_cert = tmp_cert;
668                       goto try_another_cert;
669                     }
670                 }
671             }
672 #endif
673           /* Return a more descriptive error code than the one
674            * returned from the signature checking.  */
675           err = gpg_error (GPG_ERR_BAD_CERT_CHAIN);
676           goto leave;
677         }
678
679       /* Check that the length of the chain is not longer than allowed
680        * by the CA.  */
681       {
682         int chainlen;
683
684         err = allowed_ca (issuer_cert, &chainlen);
685         if (err)
686           goto leave;
687         if (chainlen >= 0 && (depth - 1) > chainlen)
688           {
689             log_error (_("certificate chain longer than allowed by CA (%d)"),
690                        chainlen);
691             err = gpg_error (GPG_ERR_BAD_CERT_CHAIN);
692             goto leave;
693           }
694       }
695
696       /* May that certificate be used for certification? */
697       err = cert_use_cert_p (issuer_cert);
698       if (err)
699         goto leave;  /* No.  */
700
701       /* Prepend the certificate to our list.  */
702       {
703         chain_item_t ci;
704
705         ci = xtrycalloc (1, sizeof *ci);
706         if (!ci)
707           {
708             err = gpg_error_from_errno (errno);
709             goto leave;
710           }
711         ksba_cert_ref (subject_cert);
712         ci->cert = subject_cert;
713         cert_compute_fpr (subject_cert, ci->fpr);
714         ci->next = chain;
715         chain = ci;
716       }
717
718       if (opt.verbose)
719         log_info (_("certificate is good\n"));
720
721       /* Now to the next level up.  */
722       subject_cert = issuer_cert;
723       issuer_cert = NULL;
724     }
725
726   /* Even if we have no error here we need to check whether we
727    * encountered an error somewhere during the checks.  Set the error
728    * code to the most critical one.  */
729   if (!err)
730     {
731       if (any_expired)
732         err = gpg_error (GPG_ERR_CERT_EXPIRED);
733       else if (any_no_policy_match)
734         err = gpg_error (GPG_ERR_NO_POLICY_MATCH);
735     }
736
737   if (!err && opt.verbose)
738     {
739       chain_item_t citem;
740
741       log_info (_("certificate chain is good\n"));
742       for (citem = chain; citem; citem = citem->next)
743         cert_log_name ("  certificate", citem->cert);
744     }
745
746   if (!err && mode != VALIDATE_MODE_CRL)
747     { /* Now that everything is fine, walk the chain and check each
748        * certificate for revocations.
749        *
750        * 1. item in the chain  - The root certificate.
751        * 2. item               - the CA below the root
752        * last item             - the target certificate.
753        *
754        * Now for each certificate in the chain check whether it has
755        * been included in a CRL and thus be revoked.  We don't do OCSP
756        * here because this does not seem to make much sense.  This
757        * might become a recursive process and we should better cache
758        * our validity results to avoid double work.  Far worse a
759        * catch-22 may happen for an improper setup hierarchy and we
760        * need a way to break up such a deadlock.  */
761       err = check_revocations (ctrl, chain);
762     }
763
764   if (!err && opt.verbose)
765     {
766       if (r_trust_anchor && *r_trust_anchor)
767         log_info ("target certificate may be valid\n");
768       else
769         log_info ("target certificate is valid\n");
770     }
771   else if (err && opt.verbose)
772     log_info ("target certificate is NOT valid\n");
773
774
775  leave:
776   if (!err && !(r_trust_anchor && *r_trust_anchor))
777     {
778       /* With no error we can update the validation cache.  We do this
779        * for all certificates in the chain.  Note that we can't use
780        * the cache if the caller requested to check the trustiness of
781        * the root certificate himself.  Adding such a feature would
782        * require us to also store the fingerprint of root
783        * certificate.  */
784       chain_item_t citem;
785       time_t validated_at = gnupg_get_time ();
786
787       for (citem = chain; citem; citem = citem->next)
788         {
789           err = ksba_cert_set_user_data (citem->cert, "validated_at",
790                                          &validated_at, sizeof (validated_at));
791           if (err)
792             {
793               log_error ("set_user_data(validated_at) failed: %s\n",
794                          gpg_strerror (err));
795               err = 0;
796             }
797         }
798     }
799
800   if (r_exptime)
801     gnupg_copy_time (r_exptime, exptime);
802   ksba_free (issuer);
803   ksba_free (subject);
804   ksba_cert_release (issuer_cert);
805   if (subject_cert != cert)
806     ksba_cert_release (subject_cert);
807   while (chain)
808     {
809       chain_item_t ci_next = chain->next;
810       if (chain->cert)
811         ksba_cert_release (chain->cert);
812       xfree (chain);
813       chain = ci_next;
814     }
815   if (err && r_trust_anchor && *r_trust_anchor)
816     {
817       xfree (*r_trust_anchor);
818       *r_trust_anchor = NULL;
819     }
820   return err;
821 }
822
823
824 \f
825 /* Return the public key algorithm id from the S-expression PKEY.
826    FIXME: libgcrypt should provide such a function.  Note that this
827    implementation uses the names as used by libksba.  */
828 static int
829 pk_algo_from_sexp (gcry_sexp_t pkey)
830 {
831   gcry_sexp_t l1, l2;
832   const char *name;
833   size_t n;
834   int algo;
835
836   l1 = gcry_sexp_find_token (pkey, "public-key", 0);
837   if (!l1)
838     return 0; /* Not found.  */
839   l2 = gcry_sexp_cadr (l1);
840   gcry_sexp_release (l1);
841
842   name = gcry_sexp_nth_data (l2, 0, &n);
843   if (!name)
844     algo = 0; /* Not found. */
845   else if (n==3 && !memcmp (name, "rsa", 3))
846     algo = GCRY_PK_RSA;
847   else if (n==3 && !memcmp (name, "dsa", 3))
848     algo = GCRY_PK_DSA;
849   else if (n==13 && !memcmp (name, "ambiguous-rsa", 13))
850     algo = GCRY_PK_RSA;
851   else
852     algo = 0;
853   gcry_sexp_release (l2);
854   return algo;
855 }
856
857
858 /* Check the signature on CERT using the ISSUER_CERT.  This function
859  * does only test the cryptographic signature and nothing else.  It is
860  * assumed that the ISSUER_CERT is valid.  */
861 static gpg_error_t
862 check_cert_sig (ksba_cert_t issuer_cert, ksba_cert_t cert)
863 {
864   gpg_error_t err;
865   const char *algoid;
866   gcry_md_hd_t md;
867   int i, algo;
868   ksba_sexp_t p;
869   size_t n;
870   gcry_sexp_t s_sig, s_hash, s_pkey;
871   const char *s;
872   char algo_name[16+1]; /* hash algorithm name converted to lower case. */
873   int digestlen;
874   unsigned char *digest;
875
876   /* Hash the target certificate using the algorithm from that certificate.  */
877   algoid = ksba_cert_get_digest_algo (cert);
878   algo = gcry_md_map_name (algoid);
879   if (!algo)
880     {
881       log_error (_("unknown hash algorithm '%s'\n"), algoid? algoid:"?");
882       return gpg_error (GPG_ERR_GENERAL);
883     }
884   s = gcry_md_algo_name (algo);
885   for (i=0; *s && i < sizeof algo_name - 1; s++, i++)
886     algo_name[i] = tolower (*s);
887   algo_name[i] = 0;
888
889   err = gcry_md_open (&md, algo, 0);
890   if (err)
891     {
892       log_error ("md_open failed: %s\n", gpg_strerror (err));
893       return err;
894     }
895   if (DBG_HASHING)
896     gcry_md_debug (md, "hash.cert");
897
898   err = ksba_cert_hash (cert, 1, HASH_FNC, md);
899   if (err)
900     {
901       log_error ("ksba_cert_hash failed: %s\n", gpg_strerror (err));
902       gcry_md_close (md);
903       return err;
904     }
905   gcry_md_final (md);
906
907   /* Get the signature value out of the target certificate.  */
908   p = ksba_cert_get_sig_val (cert);
909   n = gcry_sexp_canon_len (p, 0, NULL, NULL);
910   if (!n)
911     {
912       log_error ("libksba did not return a proper S-Exp\n");
913       gcry_md_close (md);
914       ksba_free (p);
915       return gpg_error (GPG_ERR_BUG);
916     }
917   if (DBG_CRYPTO)
918     {
919       int j;
920       log_debug ("signature value:");
921       for (j=0; j < n; j++)
922         log_printf (" %02X", p[j]);
923       log_printf ("\n");
924     }
925
926   err = gcry_sexp_sscan ( &s_sig, NULL, p, n);
927   ksba_free (p);
928   if (err)
929     {
930       log_error ("gcry_sexp_scan failed: %s\n", gpg_strerror (err));
931       gcry_md_close (md);
932       return err;
933     }
934
935   /* Get the public key from the issuer certificate.  */
936   p = ksba_cert_get_public_key (issuer_cert);
937   n = gcry_sexp_canon_len (p, 0, NULL, NULL);
938   if (!n)
939     {
940       log_error ("libksba did not return a proper S-Exp\n");
941       gcry_md_close (md);
942       ksba_free (p);
943       gcry_sexp_release (s_sig);
944       return gpg_error (GPG_ERR_BUG);
945     }
946   err = gcry_sexp_sscan ( &s_pkey, NULL, p, n);
947   ksba_free (p);
948   if (err)
949     {
950       log_error ("gcry_sexp_scan failed: %s\n", gpg_strerror (err));
951       gcry_md_close (md);
952       gcry_sexp_release (s_sig);
953       return err;
954     }
955
956
957   /* Prepare the values for signature verification. At this point we
958    * have these values:
959    *
960    * S_PKEY    - S-expression with the issuer's public key.
961    * S_SIG     - Signature value as given in the certificate.
962    * MD        - Finalized hash context with hash of the certificate.
963    * ALGO_NAME - Lowercase hash algorithm name
964    */
965   digestlen = gcry_md_get_algo_dlen (algo);
966   digest = gcry_md_read (md, algo);
967   if (pk_algo_from_sexp (s_pkey) == GCRY_PK_DSA)
968     {
969       /* NB.: We support only SHA-1 here because we had problems back
970        * then to get test data for DSA-2.  Meanwhile DSA has been
971        * replaced by ECDSA which we do not yet support.  */
972       if (digestlen != 20)
973         {
974           log_error ("DSA requires the use of a 160 bit hash algorithm\n");
975           gcry_md_close (md);
976           gcry_sexp_release (s_sig);
977           gcry_sexp_release (s_pkey);
978           return gpg_error (GPG_ERR_INTERNAL);
979         }
980       if ( gcry_sexp_build (&s_hash, NULL, "(data(flags raw)(value %b))",
981                             (int)digestlen, digest) )
982         BUG ();
983     }
984   else /* Not DSA - we assume RSA  */
985     {
986       if ( gcry_sexp_build (&s_hash, NULL, "(data(flags pkcs1)(hash %s %b))",
987                             algo_name, (int)digestlen, digest) )
988         BUG ();
989
990     }
991
992   err = gcry_pk_verify (s_sig, s_hash, s_pkey);
993   if (DBG_X509)
994     log_debug ("gcry_pk_verify: %s\n", gpg_strerror (err));
995   gcry_md_close (md);
996   gcry_sexp_release (s_sig);
997   gcry_sexp_release (s_hash);
998   gcry_sexp_release (s_pkey);
999   return err;
1000 }
1001
1002
1003 \f
1004 /* Return 0 if the cert is usable for encryption.  A MODE of 0 checks
1005    for signing, a MODE of 1 checks for encryption, a MODE of 2 checks
1006    for verification and a MODE of 3 for decryption (just for
1007    debugging).  MODE 4 is for certificate signing, MODE 5 for OCSP
1008    response signing, MODE 6 is for CRL signing. */
1009 static int
1010 cert_usage_p (ksba_cert_t cert, int mode)
1011 {
1012   gpg_error_t err;
1013   unsigned int use;
1014   char *extkeyusages;
1015   int have_ocsp_signing = 0;
1016
1017   err = ksba_cert_get_ext_key_usages (cert, &extkeyusages);
1018   if (gpg_err_code (err) == GPG_ERR_NO_DATA)
1019     err = 0; /* No policy given. */
1020   if (!err)
1021     {
1022       unsigned int extusemask = ~0; /* Allow all. */
1023
1024       if (extkeyusages)
1025         {
1026           char *p, *pend;
1027           int any_critical = 0;
1028
1029           extusemask = 0;
1030
1031           p = extkeyusages;
1032           while (p && (pend=strchr (p, ':')))
1033             {
1034               *pend++ = 0;
1035               /* Only care about critical flagged usages. */
1036               if ( *pend == 'C' )
1037                 {
1038                   any_critical = 1;
1039                   if ( !strcmp (p, oid_kp_serverAuth))
1040                     extusemask |= (KSBA_KEYUSAGE_DIGITAL_SIGNATURE
1041                                    | KSBA_KEYUSAGE_KEY_ENCIPHERMENT
1042                                    | KSBA_KEYUSAGE_KEY_AGREEMENT);
1043                   else if ( !strcmp (p, oid_kp_clientAuth))
1044                     extusemask |= (KSBA_KEYUSAGE_DIGITAL_SIGNATURE
1045                                    | KSBA_KEYUSAGE_KEY_AGREEMENT);
1046                   else if ( !strcmp (p, oid_kp_codeSigning))
1047                     extusemask |= (KSBA_KEYUSAGE_DIGITAL_SIGNATURE);
1048                   else if ( !strcmp (p, oid_kp_emailProtection))
1049                     extusemask |= (KSBA_KEYUSAGE_DIGITAL_SIGNATURE
1050                                    | KSBA_KEYUSAGE_NON_REPUDIATION
1051                                    | KSBA_KEYUSAGE_KEY_ENCIPHERMENT
1052                                    | KSBA_KEYUSAGE_KEY_AGREEMENT);
1053                   else if ( !strcmp (p, oid_kp_timeStamping))
1054                     extusemask |= (KSBA_KEYUSAGE_DIGITAL_SIGNATURE
1055                                    | KSBA_KEYUSAGE_NON_REPUDIATION);
1056                 }
1057
1058               /* This is a hack to cope with OCSP.  Note that we do
1059                  not yet fully comply with the requirements and that
1060                  the entire CRL/OCSP checking thing should undergo a
1061                  thorough review and probably redesign. */
1062               if ( !strcmp (p, oid_kp_ocspSigning))
1063                 have_ocsp_signing = 1;
1064
1065               if ((p = strchr (pend, '\n')))
1066                 p++;
1067             }
1068           ksba_free (extkeyusages);
1069           extkeyusages = NULL;
1070
1071           if (!any_critical)
1072             extusemask = ~0; /* Reset to the don't care mask. */
1073         }
1074
1075
1076       err = ksba_cert_get_key_usage (cert, &use);
1077       if (gpg_err_code (err) == GPG_ERR_NO_DATA)
1078         {
1079           err = 0;
1080           if (opt.verbose && mode < 2)
1081             log_info (_("no key usage specified - assuming all usages\n"));
1082           use = ~0;
1083         }
1084
1085       /* Apply extKeyUsage. */
1086       use &= extusemask;
1087
1088     }
1089   if (err)
1090     {
1091       log_error (_("error getting key usage information: %s\n"),
1092                  gpg_strerror (err));
1093       ksba_free (extkeyusages);
1094       return err;
1095     }
1096
1097   if (mode == 4)
1098     {
1099       if ((use & (KSBA_KEYUSAGE_KEY_CERT_SIGN)))
1100         return 0;
1101       log_info (_("certificate should not have "
1102                   "been used for certification\n"));
1103       return gpg_error (GPG_ERR_WRONG_KEY_USAGE);
1104     }
1105
1106   if (mode == 5)
1107     {
1108       if (use != ~0
1109           && (have_ocsp_signing
1110               || (use & (KSBA_KEYUSAGE_KEY_CERT_SIGN
1111                          |KSBA_KEYUSAGE_CRL_SIGN))))
1112         return 0;
1113       log_info (_("certificate should not have "
1114                   "been used for OCSP response signing\n"));
1115       return gpg_error (GPG_ERR_WRONG_KEY_USAGE);
1116     }
1117
1118   if (mode == 6)
1119     {
1120       if ((use & (KSBA_KEYUSAGE_CRL_SIGN)))
1121         return 0;
1122       log_info (_("certificate should not have "
1123                   "been used for CRL signing\n"));
1124       return gpg_error (GPG_ERR_WRONG_KEY_USAGE);
1125     }
1126
1127   if ((use & ((mode&1)?
1128               (KSBA_KEYUSAGE_KEY_ENCIPHERMENT|KSBA_KEYUSAGE_DATA_ENCIPHERMENT):
1129               (KSBA_KEYUSAGE_DIGITAL_SIGNATURE|KSBA_KEYUSAGE_NON_REPUDIATION)))
1130       )
1131     return 0;
1132
1133   log_info (mode==3? _("certificate should not have been used "
1134                        "for encryption\n"):
1135             mode==2? _("certificate should not have been used for signing\n"):
1136             mode==1? _("certificate is not usable for encryption\n"):
1137                      _("certificate is not usable for signing\n"));
1138   return gpg_error (GPG_ERR_WRONG_KEY_USAGE);
1139 }
1140
1141 /* Return 0 if the certificate CERT is usable for certification.  */
1142 gpg_error_t
1143 cert_use_cert_p (ksba_cert_t cert)
1144 {
1145   return cert_usage_p (cert, 4);
1146 }
1147
1148 /* Return 0 if the certificate CERT is usable for signing OCSP
1149    responses.  */
1150 gpg_error_t
1151 cert_use_ocsp_p (ksba_cert_t cert)
1152 {
1153   return cert_usage_p (cert, 5);
1154 }
1155
1156 /* Return 0 if the certificate CERT is usable for signing CRLs. */
1157 gpg_error_t
1158 cert_use_crl_p (ksba_cert_t cert)
1159 {
1160   return cert_usage_p (cert, 6);
1161 }