gpg: Handle the agent's NEW_PASSPHRASE inquiry.
[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))
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    If R_TRUST_ANCHOR is not NULL and the validation would fail only
358    because the root certificate is not trusted, the hexified
359    fingerprint of that root certificate is stored at R_TRUST_ANCHOR
360    and success is returned.  The caller needs to free the value at
361    R_TRUST_ANCHOR; in all other cases NULL is stored there.  */
362 gpg_error_t
363 validate_cert_chain (ctrl_t ctrl, ksba_cert_t cert, ksba_isotime_t r_exptime,
364                      int mode, char **r_trust_anchor)
365 {
366   gpg_error_t err = 0;
367   int depth, maxdepth;
368   char *issuer = NULL;
369   char *subject = NULL;
370   ksba_cert_t subject_cert = NULL, issuer_cert = NULL;
371   ksba_isotime_t current_time;
372   ksba_isotime_t exptime;
373   int any_expired = 0;
374   int any_no_policy_match = 0;
375   chain_item_t chain;
376
377
378   if (r_exptime)
379     *r_exptime = 0;
380   *exptime = 0;
381
382   if (r_trust_anchor)
383     *r_trust_anchor = NULL;
384
385   if (!opt.system_daemon)
386     {
387       /* For backward compatibility we only do this in daemon mode.  */
388       log_info (_("running in compatibility mode - "
389                   "certificate chain not checked!\n"));
390       return 0; /* Okay. */
391     }
392
393   if (DBG_X509)
394     dump_cert ("subject", cert);
395
396   /* May the target certificate be used for this purpose?  */
397   switch (mode)
398     {
399     case VALIDATE_MODE_OCSP:
400       err = cert_use_ocsp_p (cert);
401       break;
402     case VALIDATE_MODE_CRL:
403     case VALIDATE_MODE_CRL_RECURSIVE:
404       err = cert_use_crl_p (cert);
405       break;
406     default:
407       err = 0;
408       break;
409     }
410   if (err)
411     return err;
412
413   /* If we already validated the certificate not too long ago, we can
414      avoid the excessive computations and lookups unless the caller
415      asked for the expiration time.  */
416   if (!r_exptime)
417     {
418       size_t buflen;
419       time_t validated_at;
420
421       err = ksba_cert_get_user_data (cert, "validated_at",
422                                      &validated_at, sizeof (validated_at),
423                                      &buflen);
424       if (err || buflen != sizeof (validated_at) || !validated_at)
425         err = 0; /* Not available or other error. */
426       else
427         {
428           /* If the validation is not older than 30 minutes we are ready. */
429           if (validated_at < gnupg_get_time () + (30*60))
430             {
431               if (opt.verbose)
432                 log_info ("certificate is good (cached)\n");
433               /* Note, that we can't jump to leave here as this would
434                  falsely updated the validation timestamp.  */
435               return 0;
436             }
437         }
438     }
439
440   /* Get the current time. */
441   gnupg_get_isotime (current_time);
442
443   /* We walk up the chain until we find a trust anchor. */
444   subject_cert = cert;
445   maxdepth = 10;
446   chain = NULL;
447   depth = 0;
448   for (;;)
449     {
450       /* Get the subject and issuer name from the current
451          certificate.  */
452       ksba_free (issuer);
453       ksba_free (subject);
454       issuer = ksba_cert_get_issuer (subject_cert, 0);
455       subject = ksba_cert_get_subject (subject_cert, 0);
456
457       if (!issuer)
458         {
459           log_error (_("no issuer found in certificate\n"));
460           err = gpg_error (GPG_ERR_BAD_CERT);
461           goto leave;
462         }
463
464       /* Handle the notBefore and notAfter timestamps.  */
465       {
466         ksba_isotime_t not_before, not_after;
467
468         err = ksba_cert_get_validity (subject_cert, 0, not_before);
469         if (!err)
470           err = ksba_cert_get_validity (subject_cert, 1, not_after);
471         if (err)
472           {
473             log_error (_("certificate with invalid validity: %s"),
474                        gpg_strerror (err));
475             err = gpg_error (GPG_ERR_BAD_CERT);
476             goto leave;
477           }
478
479         /* Keep track of the nearest expiration time in EXPTIME.  */
480         if (*not_after)
481           {
482             if (!*exptime)
483               gnupg_copy_time (exptime, not_after);
484             else if (strcmp (not_after, exptime) < 0 )
485               gnupg_copy_time (exptime, not_after);
486           }
487
488         /* Check whether the certificate is already valid.  */
489         if (*not_before && strcmp (current_time, not_before) < 0 )
490           {
491             log_error (_("certificate not yet valid"));
492             log_info ("(valid from ");
493             dump_isotime (not_before);
494             log_printf (")\n");
495             err = gpg_error (GPG_ERR_CERT_TOO_YOUNG);
496             goto leave;
497           }
498
499         /* Now check whether the certificate has expired.  */
500         if (*not_after && strcmp (current_time, not_after) > 0 )
501           {
502             log_error (_("certificate has expired"));
503             log_info ("(expired at ");
504             dump_isotime (not_after);
505             log_printf (")\n");
506             any_expired = 1;
507           }
508       }
509
510       /* Do we have any critical extensions in the certificate we
511          can't handle? */
512       err = unknown_criticals (subject_cert);
513       if (err)
514         goto leave; /* yes. */
515
516       /* Check that given policies are allowed.  */
517       err = check_cert_policy (subject_cert);
518       if (gpg_err_code (err) == GPG_ERR_NO_POLICY_MATCH)
519         {
520           any_no_policy_match = 1;
521           err = 0;
522         }
523       else if (err)
524         goto leave;
525
526       /* Is this a self-signed certificate? */
527       if (is_root_cert ( subject_cert, issuer, subject))
528         {
529           /* Yes, this is our trust anchor.  */
530           if (check_cert_sig (subject_cert, subject_cert) )
531             {
532               log_error (_("selfsigned certificate has a BAD signature"));
533               err = gpg_error (depth? GPG_ERR_BAD_CERT_CHAIN
534                                     : GPG_ERR_BAD_CERT);
535               goto leave;
536             }
537
538           /* Is this certificate allowed to act as a CA.  */
539           err = allowed_ca (subject_cert, NULL);
540           if (err)
541             goto leave;  /* No. */
542
543           err = is_trusted_cert (subject_cert);
544           if (!err)
545             ; /* Yes we trust this cert.  */
546           else if (gpg_err_code (err) == GPG_ERR_NOT_TRUSTED)
547             {
548               char *fpr;
549
550               log_error (_("root certificate is not marked trusted"));
551               fpr = get_fingerprint_hexstring (subject_cert);
552               log_info (_("fingerprint=%s\n"), fpr? fpr : "?");
553               dump_cert ("issuer", subject_cert);
554               if (r_trust_anchor)
555                 {
556                   /* Caller wants to do another trustiness check.  */
557                   *r_trust_anchor = fpr;
558                   err = 0;
559                 }
560               else
561                 xfree (fpr);
562             }
563           else
564             {
565               log_error (_("checking trustworthiness of "
566                            "root certificate failed: %s\n"),
567                          gpg_strerror (err));
568             }
569           if (err)
570             goto leave;
571
572           /* Prepend the certificate to our list.  */
573           {
574             chain_item_t ci;
575
576             ci = xtrycalloc (1, sizeof *ci);
577             if (!ci)
578               {
579                 err = gpg_error_from_errno (errno);
580                 goto leave;
581               }
582             ksba_cert_ref (subject_cert);
583             ci->cert = subject_cert;
584             cert_compute_fpr (subject_cert, ci->fpr);
585             ci->next = chain;
586             chain = ci;
587           }
588
589           if (opt.verbose)
590             {
591               if (r_trust_anchor && *r_trust_anchor)
592                 log_info ("root certificate is good but not trusted\n");
593               else
594                 log_info ("root certificate is good and trusted\n");
595             }
596
597           break;  /* Okay: a self-signed certicate is an end-point. */
598         }
599
600       /* To avoid loops, we use an arbitary limit on the length of
601          the chain. */
602       depth++;
603       if (depth > maxdepth)
604         {
605           log_error (_("certificate chain too long\n"));
606           err = gpg_error (GPG_ERR_BAD_CERT_CHAIN);
607           goto leave;
608         }
609
610       /* Find the next cert up the tree. */
611       ksba_cert_release (issuer_cert); issuer_cert = NULL;
612       err = find_issuing_cert (ctrl, subject_cert, &issuer_cert);
613       if (err)
614         {
615           if (gpg_err_code (err) == GPG_ERR_NOT_FOUND)
616             {
617               log_error (_("issuer certificate not found"));
618               log_info ("issuer certificate: #/");
619               dump_string (issuer);
620               log_printf ("\n");
621             }
622           else
623             log_error (_("issuer certificate not found: %s\n"),
624                          gpg_strerror (err));
625           /* Use a better understandable error code.  */
626           err = gpg_error (GPG_ERR_MISSING_ISSUER_CERT);
627           goto leave;
628         }
629
630 /*     try_another_cert: */
631       if (DBG_X509)
632         {
633           log_debug ("got issuer's certificate:\n");
634           dump_cert ("issuer", issuer_cert);
635         }
636
637       /* Now check the signature of the certificate.  Well, we
638          should delay this until later so that faked certificates
639          can't be turned into a DoS easily.  */
640       err = check_cert_sig (issuer_cert, subject_cert);
641       if (err)
642         {
643           log_error (_("certificate has a BAD signature"));
644 #if 0
645           if (gpg_err_code (err) == GPG_ERR_BAD_SIGNATURE)
646             {
647               /* We now try to find other issuer certificates which
648                  might have been used.  This is required because some
649                  CAs are reusing the issuer and subject DN for new
650                  root certificates without using a  authorityKeyIdentifier. */
651               rc = find_up (kh, subject_cert, issuer, 1);
652               if (!rc)
653                 {
654                   ksba_cert_t tmp_cert;
655
656                   rc = keydb_get_cert (kh, &tmp_cert);
657                   if (rc || !compare_certs (issuer_cert, tmp_cert))
658                     {
659                       /* The find next did not work or returned an
660                          identical certificate.  We better stop here
661                          to avoid infinite checks. */
662                       rc = gpg_error (GPG_ERR_BAD_SIGNATURE);
663                       ksba_cert_release (tmp_cert);
664                     }
665                   else
666                     {
667                       do_list (0, lm, fp, _("found another possible matching "
668                                             "CA certificate - trying again"));
669                       ksba_cert_release (issuer_cert);
670                       issuer_cert = tmp_cert;
671                       goto try_another_cert;
672                     }
673                 }
674             }
675 #endif
676           /* We give a more descriptive error code than the one
677              returned from the signature checking. */
678           err = gpg_error (GPG_ERR_BAD_CERT_CHAIN);
679           goto leave;
680         }
681
682       /* Check that the length of the chain is not longer than allowed
683          by the CA.  */
684       {
685         int chainlen;
686
687         err = allowed_ca (issuer_cert, &chainlen);
688         if (err)
689           goto leave;
690         if (chainlen >= 0 && (depth - 1) > chainlen)
691           {
692             log_error (_("certificate chain longer than allowed by CA (%d)"),
693                        chainlen);
694             err = gpg_error (GPG_ERR_BAD_CERT_CHAIN);
695             goto leave;
696           }
697       }
698
699       /* May that certificate be used for certification? */
700       err = cert_use_cert_p (issuer_cert);
701       if (err)
702         goto leave;  /* No.  */
703
704       /* Prepend the certificate to our list.  */
705       {
706         chain_item_t ci;
707
708         ci = xtrycalloc (1, sizeof *ci);
709         if (!ci)
710           {
711             err = gpg_error_from_errno (errno);
712             goto leave;
713           }
714         ksba_cert_ref (subject_cert);
715         ci->cert = subject_cert;
716         cert_compute_fpr (subject_cert, ci->fpr);
717         ci->next = chain;
718         chain = ci;
719       }
720
721       if (opt.verbose)
722         log_info (_("certificate is good\n"));
723
724       /* Now to the next level up.  */
725       subject_cert = issuer_cert;
726       issuer_cert = NULL;
727     }
728
729   if (!err)
730     { /* If we encountered an error somewhere during the checks, set
731          the error code to the most critical one */
732       if (any_expired)
733         err = gpg_error (GPG_ERR_CERT_EXPIRED);
734       else if (any_no_policy_match)
735         err = gpg_error (GPG_ERR_NO_POLICY_MATCH);
736     }
737
738   if (!err && opt.verbose)
739     {
740       chain_item_t citem;
741
742       log_info (_("certificate chain is good\n"));
743       for (citem = chain; citem; citem = citem->next)
744         cert_log_name ("  certificate", citem->cert);
745     }
746
747   if (!err && mode != VALIDATE_MODE_CRL)
748     { /* Now that everything is fine, walk the chain and check each
749          certificate for revocations.
750
751          1. item in the chain  - The root certificate.
752          2. item               - the CA below the root
753          last item             - the target certificate.
754
755          Now for each certificate in the chain check whether it has
756          been included in a CRL and thus be revoked.  We don't do OCSP
757          here because this does not seem to make much sense.  This
758          might become a recursive process and we should better cache
759          our validity results to avoid double work.  Far worse a
760          catch-22 may happen for an improper setup hierachy and we
761          need a way to break up such a deadlock. */
762       err = check_revocations (ctrl, chain);
763     }
764
765   if (!err && opt.verbose)
766     {
767       if (r_trust_anchor && *r_trust_anchor)
768         log_info ("target certificate may be valid\n");
769       else
770         log_info ("target certificate is valid\n");
771     }
772   else if (err && opt.verbose)
773     log_info ("target certificate is NOT valid\n");
774
775
776  leave:
777   if (!err && !(r_trust_anchor && *r_trust_anchor))
778     {
779       /* With no error we can update the validation cache.  We do this
780          for all certificates in the chain.  Note that we can't use
781          the cache if the caller requested to check the trustiness of
782          the root certificate himself.  Adding such a feature would
783          require us to also store the fingerprint of root
784          certificate.  */
785       chain_item_t citem;
786       time_t validated_at = gnupg_get_time ();
787
788       for (citem = chain; citem; citem = citem->next)
789         {
790           err = ksba_cert_set_user_data (citem->cert, "validated_at",
791                                          &validated_at, sizeof (validated_at));
792           if (err)
793             {
794               log_error ("set_user_data(validated_at) failed: %s\n",
795                          gpg_strerror (err));
796               err = 0;
797             }
798         }
799     }
800
801   if (r_exptime)
802     gnupg_copy_time (r_exptime, exptime);
803   ksba_free (issuer);
804   ksba_free (subject);
805   ksba_cert_release (issuer_cert);
806   if (subject_cert != cert)
807     ksba_cert_release (subject_cert);
808   while (chain)
809     {
810       chain_item_t ci_next = chain->next;
811       if (chain->cert)
812         ksba_cert_release (chain->cert);
813       xfree (chain);
814       chain = ci_next;
815     }
816   if (err && r_trust_anchor && *r_trust_anchor)
817     {
818       xfree (*r_trust_anchor);
819       *r_trust_anchor = NULL;
820     }
821   return err;
822 }
823
824
825 \f
826 /* Return the public key algorithm id from the S-expression PKEY.
827    FIXME: libgcrypt should provide such a function.  Note that this
828    implementation uses the names as used by libksba.  */
829 static int
830 pk_algo_from_sexp (gcry_sexp_t pkey)
831 {
832   gcry_sexp_t l1, l2;
833   const char *name;
834   size_t n;
835   int algo;
836
837   l1 = gcry_sexp_find_token (pkey, "public-key", 0);
838   if (!l1)
839     return 0; /* Not found.  */
840   l2 = gcry_sexp_cadr (l1);
841   gcry_sexp_release (l1);
842
843   name = gcry_sexp_nth_data (l2, 0, &n);
844   if (!name)
845     algo = 0; /* Not found. */
846   else if (n==3 && !memcmp (name, "rsa", 3))
847     algo = GCRY_PK_RSA;
848   else if (n==3 && !memcmp (name, "dsa", 3))
849     algo = GCRY_PK_DSA;
850   else if (n==13 && !memcmp (name, "ambiguous-rsa", 13))
851     algo = GCRY_PK_RSA;
852   else
853     algo = 0;
854   gcry_sexp_release (l2);
855   return algo;
856 }
857
858
859 /* Check the signature on CERT using the ISSUER_CERT.  This function
860    does only test the cryptographic signature and nothing else.  It is
861    assumed that the ISSUER_CERT is valid. */
862 static gpg_error_t
863 check_cert_sig (ksba_cert_t issuer_cert, ksba_cert_t cert)
864 {
865   gpg_error_t err;
866   const char *algoid;
867   gcry_md_hd_t md;
868   int i, algo;
869   ksba_sexp_t p;
870   size_t n;
871   gcry_sexp_t s_sig, s_hash, s_pkey;
872   const char *s;
873   char algo_name[16+1]; /* hash algorithm name converted to lower case. */
874   int digestlen;
875   unsigned char *digest;
876
877   /* Hash the target certificate using the algorithm from that certificate.  */
878   algoid = ksba_cert_get_digest_algo (cert);
879   algo = gcry_md_map_name (algoid);
880   if (!algo)
881     {
882       log_error (_("unknown hash algorithm '%s'\n"), algoid? algoid:"?");
883       return gpg_error (GPG_ERR_GENERAL);
884     }
885   s = gcry_md_algo_name (algo);
886   for (i=0; *s && i < sizeof algo_name - 1; s++, i++)
887     algo_name[i] = tolower (*s);
888   algo_name[i] = 0;
889
890   err = gcry_md_open (&md, algo, 0);
891   if (err)
892     {
893       log_error ("md_open failed: %s\n", gpg_strerror (err));
894       return err;
895     }
896   if (DBG_HASHING)
897     gcry_md_debug (md, "hash.cert");
898
899   err = ksba_cert_hash (cert, 1, HASH_FNC, md);
900   if (err)
901     {
902       log_error ("ksba_cert_hash failed: %s\n", gpg_strerror (err));
903       gcry_md_close (md);
904       return err;
905     }
906   gcry_md_final (md);
907
908   /* Get the signature value out of the target certificate.  */
909   p = ksba_cert_get_sig_val (cert);
910   n = gcry_sexp_canon_len (p, 0, NULL, NULL);
911   if (!n)
912     {
913       log_error ("libksba did not return a proper S-Exp\n");
914       gcry_md_close (md);
915       ksba_free (p);
916       return gpg_error (GPG_ERR_BUG);
917     }
918   if (DBG_CRYPTO)
919     {
920       int j;
921       log_debug ("signature value:");
922       for (j=0; j < n; j++)
923         log_printf (" %02X", p[j]);
924       log_printf ("\n");
925     }
926
927   err = gcry_sexp_sscan ( &s_sig, NULL, p, n);
928   ksba_free (p);
929   if (err)
930     {
931       log_error ("gcry_sexp_scan failed: %s\n", gpg_strerror (err));
932       gcry_md_close (md);
933       return err;
934     }
935
936   /* Get the public key from the issuer certificate.  */
937   p = ksba_cert_get_public_key (issuer_cert);
938   n = gcry_sexp_canon_len (p, 0, NULL, NULL);
939   if (!n)
940     {
941       log_error ("libksba did not return a proper S-Exp\n");
942       gcry_md_close (md);
943       ksba_free (p);
944       gcry_sexp_release (s_sig);
945       return gpg_error (GPG_ERR_BUG);
946     }
947   err = gcry_sexp_sscan ( &s_pkey, NULL, p, n);
948   ksba_free (p);
949   if (err)
950     {
951       log_error ("gcry_sexp_scan failed: %s\n", gpg_strerror (err));
952       gcry_md_close (md);
953       gcry_sexp_release (s_sig);
954       return err;
955     }
956
957
958   /* Prepare the values for signature verification. At this point we
959      have these values:
960
961      S_PKEY    - S-expression with the issuer's public key.
962      S_SIG     - Signature value as given in the certrificate.
963      MD        - Finalized hash context with hash of the certificate.
964      ALGO_NAME - Lowercase hash algorithm name
965    */
966   digestlen = gcry_md_get_algo_dlen (algo);
967   digest = gcry_md_read (md, algo);
968   if (pk_algo_from_sexp (s_pkey) == GCRY_PK_DSA)
969     {
970       if (digestlen != 20)
971         {
972           log_error (_("DSA requires the use of a 160 bit hash algorithm\n"));
973           gcry_md_close (md);
974           gcry_sexp_release (s_sig);
975           gcry_sexp_release (s_pkey);
976           return gpg_error (GPG_ERR_INTERNAL);
977         }
978       if ( gcry_sexp_build (&s_hash, NULL, "(data(flags raw)(value %b))",
979                             (int)digestlen, digest) )
980         BUG ();
981     }
982   else /* Not DSA.  */
983     {
984       if ( gcry_sexp_build (&s_hash, NULL, "(data(flags pkcs1)(hash %s %b))",
985                             algo_name, (int)digestlen, digest) )
986         BUG ();
987
988     }
989
990   err = gcry_pk_verify (s_sig, s_hash, s_pkey);
991   if (DBG_X509)
992     log_debug ("gcry_pk_verify: %s\n", gpg_strerror (err));
993   gcry_md_close (md);
994   gcry_sexp_release (s_sig);
995   gcry_sexp_release (s_hash);
996   gcry_sexp_release (s_pkey);
997   return err;
998 }
999
1000
1001 \f
1002 /* Return 0 if the cert is usable for encryption.  A MODE of 0 checks
1003    for signing, a MODE of 1 checks for encryption, a MODE of 2 checks
1004    for verification and a MODE of 3 for decryption (just for
1005    debugging).  MODE 4 is for certificate signing, MODE 5 for OCSP
1006    response signing, MODE 6 is for CRL signing. */
1007 static int
1008 cert_usage_p (ksba_cert_t cert, int mode)
1009 {
1010   gpg_error_t err;
1011   unsigned int use;
1012   char *extkeyusages;
1013   int have_ocsp_signing = 0;
1014
1015   err = ksba_cert_get_ext_key_usages (cert, &extkeyusages);
1016   if (gpg_err_code (err) == GPG_ERR_NO_DATA)
1017     err = 0; /* No policy given. */
1018   if (!err)
1019     {
1020       unsigned int extusemask = ~0; /* Allow all. */
1021
1022       if (extkeyusages)
1023         {
1024           char *p, *pend;
1025           int any_critical = 0;
1026
1027           extusemask = 0;
1028
1029           p = extkeyusages;
1030           while (p && (pend=strchr (p, ':')))
1031             {
1032               *pend++ = 0;
1033               /* Only care about critical flagged usages. */
1034               if ( *pend == 'C' )
1035                 {
1036                   any_critical = 1;
1037                   if ( !strcmp (p, oid_kp_serverAuth))
1038                     extusemask |= (KSBA_KEYUSAGE_DIGITAL_SIGNATURE
1039                                    | KSBA_KEYUSAGE_KEY_ENCIPHERMENT
1040                                    | KSBA_KEYUSAGE_KEY_AGREEMENT);
1041                   else if ( !strcmp (p, oid_kp_clientAuth))
1042                     extusemask |= (KSBA_KEYUSAGE_DIGITAL_SIGNATURE
1043                                    | KSBA_KEYUSAGE_KEY_AGREEMENT);
1044                   else if ( !strcmp (p, oid_kp_codeSigning))
1045                     extusemask |= (KSBA_KEYUSAGE_DIGITAL_SIGNATURE);
1046                   else if ( !strcmp (p, oid_kp_emailProtection))
1047                     extusemask |= (KSBA_KEYUSAGE_DIGITAL_SIGNATURE
1048                                    | KSBA_KEYUSAGE_NON_REPUDIATION
1049                                    | KSBA_KEYUSAGE_KEY_ENCIPHERMENT
1050                                    | KSBA_KEYUSAGE_KEY_AGREEMENT);
1051                   else if ( !strcmp (p, oid_kp_timeStamping))
1052                     extusemask |= (KSBA_KEYUSAGE_DIGITAL_SIGNATURE
1053                                    | KSBA_KEYUSAGE_NON_REPUDIATION);
1054                 }
1055
1056               /* This is a hack to cope with OCSP.  Note that we do
1057                  not yet fully comply with the requirements and that
1058                  the entire CRL/OCSP checking thing should undergo a
1059                  thorough review and probably redesign. */
1060               if ( !strcmp (p, oid_kp_ocspSigning))
1061                 have_ocsp_signing = 1;
1062
1063               if ((p = strchr (pend, '\n')))
1064                 p++;
1065             }
1066           ksba_free (extkeyusages);
1067           extkeyusages = NULL;
1068
1069           if (!any_critical)
1070             extusemask = ~0; /* Reset to the don't care mask. */
1071         }
1072
1073
1074       err = ksba_cert_get_key_usage (cert, &use);
1075       if (gpg_err_code (err) == GPG_ERR_NO_DATA)
1076         {
1077           err = 0;
1078           if (opt.verbose && mode < 2)
1079             log_info (_("no key usage specified - assuming all usages\n"));
1080           use = ~0;
1081         }
1082
1083       /* Apply extKeyUsage. */
1084       use &= extusemask;
1085
1086     }
1087   if (err)
1088     {
1089       log_error (_("error getting key usage information: %s\n"),
1090                  gpg_strerror (err));
1091       ksba_free (extkeyusages);
1092       return err;
1093     }
1094
1095   if (mode == 4)
1096     {
1097       if ((use & (KSBA_KEYUSAGE_KEY_CERT_SIGN)))
1098         return 0;
1099       log_info (_("certificate should not have "
1100                   "been used for certification\n"));
1101       return gpg_error (GPG_ERR_WRONG_KEY_USAGE);
1102     }
1103
1104   if (mode == 5)
1105     {
1106       if (use != ~0
1107           && (have_ocsp_signing
1108               || (use & (KSBA_KEYUSAGE_KEY_CERT_SIGN
1109                          |KSBA_KEYUSAGE_CRL_SIGN))))
1110         return 0;
1111       log_info (_("certificate should not have "
1112                   "been used for OCSP response signing\n"));
1113       return gpg_error (GPG_ERR_WRONG_KEY_USAGE);
1114     }
1115
1116   if (mode == 6)
1117     {
1118       if ((use & (KSBA_KEYUSAGE_CRL_SIGN)))
1119         return 0;
1120       log_info (_("certificate should not have "
1121                   "been used for CRL signing\n"));
1122       return gpg_error (GPG_ERR_WRONG_KEY_USAGE);
1123     }
1124
1125   if ((use & ((mode&1)?
1126               (KSBA_KEYUSAGE_KEY_ENCIPHERMENT|KSBA_KEYUSAGE_DATA_ENCIPHERMENT):
1127               (KSBA_KEYUSAGE_DIGITAL_SIGNATURE|KSBA_KEYUSAGE_NON_REPUDIATION)))
1128       )
1129     return 0;
1130
1131   log_info (mode==3? _("certificate should not have been used "
1132                        "for encryption\n"):
1133             mode==2? _("certificate should not have been used for signing\n"):
1134             mode==1? _("certificate is not usable for encryption\n"):
1135                      _("certificate is not usable for signing\n"));
1136   return gpg_error (GPG_ERR_WRONG_KEY_USAGE);
1137 }
1138
1139 /* Return 0 if the certificate CERT is usable for certification.  */
1140 gpg_error_t
1141 cert_use_cert_p (ksba_cert_t cert)
1142 {
1143   return cert_usage_p (cert, 4);
1144 }
1145
1146 /* Return 0 if the certificate CERT is usable for signing OCSP
1147    responses.  */
1148 gpg_error_t
1149 cert_use_ocsp_p (ksba_cert_t cert)
1150 {
1151   return cert_usage_p (cert, 5);
1152 }
1153
1154 /* Return 0 if the certificate CERT is usable for signing CRLs. */
1155 gpg_error_t
1156 cert_use_crl_p (ksba_cert_t cert)
1157 {
1158   return cert_usage_p (cert, 6);
1159 }