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