5bd784fe17174224c9594c7c4bb9047da3ff3079
[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, CERTTRUST_CLASS_CONFIG))
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   log_assert (ctrl->check_revocations_nest_level >= 0);
237   log_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                      unsigned int flags, 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   if ((flags & VALIDATE_FLAG_OCSP) && (err = check_cert_use_ocsp (cert)))
409     return err;
410   if ((flags & VALIDATE_FLAG_CRL) && (err = check_cert_use_crl (cert)))
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;  /* Sensible limit on the length of the chain.  */
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
544             (subject_cert,
545              (CERTTRUST_CLASS_CONFIG
546               | (flags & VALIDATE_FLAG_SYSTRUST)? CERTTRUST_CLASS_SYSTEM : 0));
547           if (!err)
548             ; /* Yes we trust this cert.  */
549           else if (gpg_err_code (err) == GPG_ERR_NOT_TRUSTED)
550             {
551               char *fpr;
552
553               log_error (_("root certificate is not marked trusted"));
554               fpr = get_fingerprint_hexstring (subject_cert);
555               log_info (_("fingerprint=%s\n"), fpr? fpr : "?");
556               dump_cert ("issuer", subject_cert);
557               if (r_trust_anchor)
558                 {
559                   /* Caller wants to do another trustiness check.  */
560                   *r_trust_anchor = fpr;
561                   err = 0;
562                 }
563               else
564                 xfree (fpr);
565             }
566           else
567             {
568               log_error (_("checking trustworthiness of "
569                            "root certificate failed: %s\n"),
570                          gpg_strerror (err));
571             }
572           if (err)
573             goto leave;
574
575           /* Prepend the certificate to our list.  */
576           {
577             chain_item_t ci;
578
579             ci = xtrycalloc (1, sizeof *ci);
580             if (!ci)
581               {
582                 err = gpg_error_from_errno (errno);
583                 goto leave;
584               }
585             ksba_cert_ref (subject_cert);
586             ci->cert = subject_cert;
587             cert_compute_fpr (subject_cert, ci->fpr);
588             ci->next = chain;
589             chain = ci;
590           }
591
592           if (opt.verbose)
593             {
594               if (r_trust_anchor && *r_trust_anchor)
595                 log_info ("root certificate is good but not trusted\n");
596               else
597                 log_info ("root certificate is good and trusted\n");
598             }
599
600           break;  /* Okay: a self-signed certicate is an end-point. */
601         }
602
603       /* To avoid loops, we use an arbitrary limit on the length of
604          the chain. */
605       depth++;
606       if (depth > maxdepth)
607         {
608           log_error (_("certificate chain too long\n"));
609           err = gpg_error (GPG_ERR_BAD_CERT_CHAIN);
610           goto leave;
611         }
612
613       /* Find the next cert up the tree. */
614       ksba_cert_release (issuer_cert); issuer_cert = NULL;
615       err = find_issuing_cert (ctrl, subject_cert, &issuer_cert);
616       if (err)
617         {
618           if (gpg_err_code (err) == GPG_ERR_NOT_FOUND)
619             {
620               log_error (_("issuer certificate not found"));
621               log_info ("issuer certificate: #/");
622               dump_string (issuer);
623               log_printf ("\n");
624             }
625           else
626             log_error (_("issuer certificate not found: %s\n"),
627                          gpg_strerror (err));
628           /* Use a better understandable error code.  */
629           err = gpg_error (GPG_ERR_MISSING_ISSUER_CERT);
630           goto leave;
631         }
632
633 /*     try_another_cert: */
634       if (DBG_X509)
635         {
636           log_debug ("got issuer's certificate:\n");
637           dump_cert ("issuer", issuer_cert);
638         }
639
640       /* Now check the signature of the certificate.  FIXME: we should
641        * delay this until later so that faked certificates can't be
642        * turned into a DoS easily.  */
643       err = check_cert_sig (issuer_cert, subject_cert);
644       if (err)
645         {
646           log_error (_("certificate has a BAD signature"));
647 #if 0
648           if (gpg_err_code (err) == GPG_ERR_BAD_SIGNATURE)
649             {
650               /* We now try to find other issuer certificates which
651                  might have been used.  This is required because some
652                  CAs are reusing the issuer and subject DN for new
653                  root certificates without using a  authorityKeyIdentifier. */
654               rc = find_up (kh, subject_cert, issuer, 1);
655               if (!rc)
656                 {
657                   ksba_cert_t tmp_cert;
658
659                   rc = keydb_get_cert (kh, &tmp_cert);
660                   if (rc || !compare_certs (issuer_cert, tmp_cert))
661                     {
662                       /* The find next did not work or returned an
663                          identical certificate.  We better stop here
664                          to avoid infinite checks. */
665                       rc = gpg_error (GPG_ERR_BAD_SIGNATURE);
666                       ksba_cert_release (tmp_cert);
667                     }
668                   else
669                     {
670                       do_list (0, lm, fp, _("found another possible matching "
671                                             "CA certificate - trying again"));
672                       ksba_cert_release (issuer_cert);
673                       issuer_cert = tmp_cert;
674                       goto try_another_cert;
675                     }
676                 }
677             }
678 #endif
679           /* Return a more descriptive error code than the one
680            * returned from the signature checking.  */
681           err = gpg_error (GPG_ERR_BAD_CERT_CHAIN);
682           goto leave;
683         }
684
685       /* Check that the length of the chain is not longer than allowed
686        * by the CA.  */
687       {
688         int chainlen;
689
690         err = allowed_ca (issuer_cert, &chainlen);
691         if (err)
692           goto leave;
693         if (chainlen >= 0 && (depth - 1) > chainlen)
694           {
695             log_error (_("certificate chain longer than allowed by CA (%d)"),
696                        chainlen);
697             err = gpg_error (GPG_ERR_BAD_CERT_CHAIN);
698             goto leave;
699           }
700       }
701
702       /* May that certificate be used for certification? */
703       err = check_cert_use_cert (issuer_cert);
704       if (err)
705         goto leave;  /* No.  */
706
707       /* Prepend the certificate to our list.  */
708       {
709         chain_item_t ci;
710
711         ci = xtrycalloc (1, sizeof *ci);
712         if (!ci)
713           {
714             err = gpg_error_from_errno (errno);
715             goto leave;
716           }
717         ksba_cert_ref (subject_cert);
718         ci->cert = subject_cert;
719         cert_compute_fpr (subject_cert, ci->fpr);
720         ci->next = chain;
721         chain = ci;
722       }
723
724       if (opt.verbose)
725         log_info (_("certificate is good\n"));
726
727       /* Now to the next level up.  */
728       subject_cert = issuer_cert;
729       issuer_cert = NULL;
730     }
731
732   /* Even if we have no error here we need to check whether we
733    * encountered an error somewhere during the checks.  Set the error
734    * code to the most critical one.  */
735   if (!err)
736     {
737       if (any_expired)
738         err = gpg_error (GPG_ERR_CERT_EXPIRED);
739       else if (any_no_policy_match)
740         err = gpg_error (GPG_ERR_NO_POLICY_MATCH);
741     }
742
743   if (!err && opt.verbose)
744     {
745       chain_item_t citem;
746
747       log_info (_("certificate chain is good\n"));
748       for (citem = chain; citem; citem = citem->next)
749         cert_log_name ("  certificate", citem->cert);
750     }
751
752   /* Now check for revocations unless CRL checks are disabled or we
753    * are non-recursive CRL mode.  */
754   if (!err
755       && !(flags & VALIDATE_FLAG_NOCRLCHECK)
756       && !((flags & VALIDATE_FLAG_CRL)
757            && !(flags & VALIDATE_FLAG_RECURSIVE)))
758     { /* Now that everything is fine, walk the chain and check each
759        * certificate for revocations.
760        *
761        * 1. item in the chain  - The root certificate.
762        * 2. item               - the CA below the root
763        * last item             - the target certificate.
764        *
765        * Now for each certificate in the chain check whether it has
766        * been included in a CRL and thus be revoked.  We don't do OCSP
767        * here because this does not seem to make much sense.  This
768        * might become a recursive process and we should better cache
769        * our validity results to avoid double work.  Far worse a
770        * catch-22 may happen for an improper setup hierarchy and we
771        * need a way to break up such a deadlock.  */
772       err = check_revocations (ctrl, chain);
773     }
774
775   if (!err && opt.verbose)
776     {
777       if (r_trust_anchor && *r_trust_anchor)
778         log_info ("target certificate may be valid\n");
779       else
780         log_info ("target certificate is valid\n");
781     }
782   else if (err && opt.verbose)
783     log_info ("target certificate is NOT valid\n");
784
785
786  leave:
787   if (!err && !(r_trust_anchor && *r_trust_anchor))
788     {
789       /* With no error we can update the validation cache.  We do this
790        * for all certificates in the chain.  Note that we can't use
791        * the cache if the caller requested to check the trustiness of
792        * the root certificate himself.  Adding such a feature would
793        * require us to also store the fingerprint of root
794        * certificate.  */
795       chain_item_t citem;
796       time_t validated_at = gnupg_get_time ();
797
798       for (citem = chain; citem; citem = citem->next)
799         {
800           err = ksba_cert_set_user_data (citem->cert, "validated_at",
801                                          &validated_at, sizeof (validated_at));
802           if (err)
803             {
804               log_error ("set_user_data(validated_at) failed: %s\n",
805                          gpg_strerror (err));
806               err = 0;
807             }
808         }
809     }
810
811   if (r_exptime)
812     gnupg_copy_time (r_exptime, exptime);
813   ksba_free (issuer);
814   ksba_free (subject);
815   ksba_cert_release (issuer_cert);
816   if (subject_cert != cert)
817     ksba_cert_release (subject_cert);
818   while (chain)
819     {
820       chain_item_t ci_next = chain->next;
821       if (chain->cert)
822         ksba_cert_release (chain->cert);
823       xfree (chain);
824       chain = ci_next;
825     }
826   if (err && r_trust_anchor && *r_trust_anchor)
827     {
828       xfree (*r_trust_anchor);
829       *r_trust_anchor = NULL;
830     }
831   return err;
832 }
833
834
835 \f
836 /* Return the public key algorithm id from the S-expression PKEY.
837    FIXME: libgcrypt should provide such a function.  Note that this
838    implementation uses the names as used by libksba.  */
839 static int
840 pk_algo_from_sexp (gcry_sexp_t pkey)
841 {
842   gcry_sexp_t l1, l2;
843   const char *name;
844   size_t n;
845   int algo;
846
847   l1 = gcry_sexp_find_token (pkey, "public-key", 0);
848   if (!l1)
849     return 0; /* Not found.  */
850   l2 = gcry_sexp_cadr (l1);
851   gcry_sexp_release (l1);
852
853   name = gcry_sexp_nth_data (l2, 0, &n);
854   if (!name)
855     algo = 0; /* Not found. */
856   else if (n==3 && !memcmp (name, "rsa", 3))
857     algo = GCRY_PK_RSA;
858   else if (n==3 && !memcmp (name, "dsa", 3))
859     algo = GCRY_PK_DSA;
860   else if (n==13 && !memcmp (name, "ambiguous-rsa", 13))
861     algo = GCRY_PK_RSA;
862   else
863     algo = 0;
864   gcry_sexp_release (l2);
865   return algo;
866 }
867
868
869 /* Check the signature on CERT using the ISSUER_CERT.  This function
870  * does only test the cryptographic signature and nothing else.  It is
871  * assumed that the ISSUER_CERT is valid.  */
872 static gpg_error_t
873 check_cert_sig (ksba_cert_t issuer_cert, ksba_cert_t cert)
874 {
875   gpg_error_t err;
876   const char *algoid;
877   gcry_md_hd_t md;
878   int i, algo;
879   ksba_sexp_t p;
880   size_t n;
881   gcry_sexp_t s_sig, s_hash, s_pkey;
882   const char *s;
883   char algo_name[16+1]; /* hash algorithm name converted to lower case. */
884   int digestlen;
885   unsigned char *digest;
886
887   /* Hash the target certificate using the algorithm from that certificate.  */
888   algoid = ksba_cert_get_digest_algo (cert);
889   algo = gcry_md_map_name (algoid);
890   if (!algo)
891     {
892       log_error (_("unknown hash algorithm '%s'\n"), algoid? algoid:"?");
893       return gpg_error (GPG_ERR_GENERAL);
894     }
895   s = gcry_md_algo_name (algo);
896   for (i=0; *s && i < sizeof algo_name - 1; s++, i++)
897     algo_name[i] = tolower (*s);
898   algo_name[i] = 0;
899
900   err = gcry_md_open (&md, algo, 0);
901   if (err)
902     {
903       log_error ("md_open failed: %s\n", gpg_strerror (err));
904       return err;
905     }
906   if (DBG_HASHING)
907     gcry_md_debug (md, "hash.cert");
908
909   err = ksba_cert_hash (cert, 1, HASH_FNC, md);
910   if (err)
911     {
912       log_error ("ksba_cert_hash failed: %s\n", gpg_strerror (err));
913       gcry_md_close (md);
914       return err;
915     }
916   gcry_md_final (md);
917
918   /* Get the signature value out of the target certificate.  */
919   p = ksba_cert_get_sig_val (cert);
920   n = gcry_sexp_canon_len (p, 0, NULL, NULL);
921   if (!n)
922     {
923       log_error ("libksba did not return a proper S-Exp\n");
924       gcry_md_close (md);
925       ksba_free (p);
926       return gpg_error (GPG_ERR_BUG);
927     }
928   if (DBG_CRYPTO)
929     {
930       int j;
931       log_debug ("signature value:");
932       for (j=0; j < n; j++)
933         log_printf (" %02X", p[j]);
934       log_printf ("\n");
935     }
936
937   err = gcry_sexp_sscan ( &s_sig, NULL, p, n);
938   ksba_free (p);
939   if (err)
940     {
941       log_error ("gcry_sexp_scan failed: %s\n", gpg_strerror (err));
942       gcry_md_close (md);
943       return err;
944     }
945
946   /* Get the public key from the issuer certificate.  */
947   p = ksba_cert_get_public_key (issuer_cert);
948   n = gcry_sexp_canon_len (p, 0, NULL, NULL);
949   if (!n)
950     {
951       log_error ("libksba did not return a proper S-Exp\n");
952       gcry_md_close (md);
953       ksba_free (p);
954       gcry_sexp_release (s_sig);
955       return gpg_error (GPG_ERR_BUG);
956     }
957   err = gcry_sexp_sscan ( &s_pkey, NULL, p, n);
958   ksba_free (p);
959   if (err)
960     {
961       log_error ("gcry_sexp_scan failed: %s\n", gpg_strerror (err));
962       gcry_md_close (md);
963       gcry_sexp_release (s_sig);
964       return err;
965     }
966
967
968   /* Prepare the values for signature verification. At this point we
969    * have these values:
970    *
971    * S_PKEY    - S-expression with the issuer's public key.
972    * S_SIG     - Signature value as given in the certificate.
973    * MD        - Finalized hash context with hash of the certificate.
974    * ALGO_NAME - Lowercase hash algorithm name
975    */
976   digestlen = gcry_md_get_algo_dlen (algo);
977   digest = gcry_md_read (md, algo);
978   if (pk_algo_from_sexp (s_pkey) == GCRY_PK_DSA)
979     {
980       /* NB.: We support only SHA-1 here because we had problems back
981        * then to get test data for DSA-2.  Meanwhile DSA has been
982        * replaced by ECDSA which we do not yet support.  */
983       if (digestlen != 20)
984         {
985           log_error ("DSA requires the use of a 160 bit hash algorithm\n");
986           gcry_md_close (md);
987           gcry_sexp_release (s_sig);
988           gcry_sexp_release (s_pkey);
989           return gpg_error (GPG_ERR_INTERNAL);
990         }
991       if ( gcry_sexp_build (&s_hash, NULL, "(data(flags raw)(value %b))",
992                             (int)digestlen, digest) )
993         BUG ();
994     }
995   else /* Not DSA - we assume RSA  */
996     {
997       if ( gcry_sexp_build (&s_hash, NULL, "(data(flags pkcs1)(hash %s %b))",
998                             algo_name, (int)digestlen, digest) )
999         BUG ();
1000
1001     }
1002
1003   err = gcry_pk_verify (s_sig, s_hash, s_pkey);
1004   if (DBG_X509)
1005     log_debug ("gcry_pk_verify: %s\n", gpg_strerror (err));
1006   gcry_md_close (md);
1007   gcry_sexp_release (s_sig);
1008   gcry_sexp_release (s_hash);
1009   gcry_sexp_release (s_pkey);
1010   return err;
1011 }
1012
1013
1014 \f
1015 /* Return 0 if CERT is usable for MODE.  */
1016 static gpg_error_t
1017 check_cert_usage (ksba_cert_t cert, enum cert_usage_modes mode)
1018 {
1019   gpg_error_t err;
1020   unsigned int use;
1021   char *extkeyusages;
1022   int have_ocsp_signing = 0;
1023
1024   err = ksba_cert_get_ext_key_usages (cert, &extkeyusages);
1025   if (gpg_err_code (err) == GPG_ERR_NO_DATA)
1026     err = 0; /* No policy given. */
1027   if (!err)
1028     {
1029       unsigned int extusemask = ~0; /* Allow all. */
1030
1031       if (extkeyusages)
1032         {
1033           char *p, *pend;
1034           int any_critical = 0;
1035
1036           extusemask = 0;
1037
1038           p = extkeyusages;
1039           while (p && (pend=strchr (p, ':')))
1040             {
1041               *pend++ = 0;
1042               /* Only care about critical flagged usages. */
1043               if ( *pend == 'C' )
1044                 {
1045                   any_critical = 1;
1046                   if ( !strcmp (p, oid_kp_serverAuth))
1047                     extusemask |= (KSBA_KEYUSAGE_DIGITAL_SIGNATURE
1048                                    | KSBA_KEYUSAGE_KEY_ENCIPHERMENT
1049                                    | KSBA_KEYUSAGE_KEY_AGREEMENT);
1050                   else if ( !strcmp (p, oid_kp_clientAuth))
1051                     extusemask |= (KSBA_KEYUSAGE_DIGITAL_SIGNATURE
1052                                    | KSBA_KEYUSAGE_KEY_AGREEMENT);
1053                   else if ( !strcmp (p, oid_kp_codeSigning))
1054                     extusemask |= (KSBA_KEYUSAGE_DIGITAL_SIGNATURE);
1055                   else if ( !strcmp (p, oid_kp_emailProtection))
1056                     extusemask |= (KSBA_KEYUSAGE_DIGITAL_SIGNATURE
1057                                    | KSBA_KEYUSAGE_NON_REPUDIATION
1058                                    | KSBA_KEYUSAGE_KEY_ENCIPHERMENT
1059                                    | KSBA_KEYUSAGE_KEY_AGREEMENT);
1060                   else if ( !strcmp (p, oid_kp_timeStamping))
1061                     extusemask |= (KSBA_KEYUSAGE_DIGITAL_SIGNATURE
1062                                    | KSBA_KEYUSAGE_NON_REPUDIATION);
1063                 }
1064
1065               /* This is a hack to cope with OCSP.  Note that we do
1066                  not yet fully comply with the requirements and that
1067                  the entire CRL/OCSP checking thing should undergo a
1068                  thorough review and probably redesign. */
1069               if ( !strcmp (p, oid_kp_ocspSigning))
1070                 have_ocsp_signing = 1;
1071
1072               if ((p = strchr (pend, '\n')))
1073                 p++;
1074             }
1075           ksba_free (extkeyusages);
1076           extkeyusages = NULL;
1077
1078           if (!any_critical)
1079             extusemask = ~0; /* Reset to the don't care mask. */
1080         }
1081
1082
1083       err = ksba_cert_get_key_usage (cert, &use);
1084       if (gpg_err_code (err) == GPG_ERR_NO_DATA)
1085         {
1086           err = 0;
1087           if (opt.verbose && (mode == CERT_USAGE_MODE_SIGN
1088                               || mode == CERT_USAGE_MODE_ENCR))
1089             log_info (_("no key usage specified - assuming all usages\n"));
1090           use = ~0;
1091         }
1092
1093       /* Apply extKeyUsage. */
1094       use &= extusemask;
1095
1096     }
1097   if (err)
1098     {
1099       log_error (_("error getting key usage information: %s\n"),
1100                  gpg_strerror (err));
1101       ksba_free (extkeyusages);
1102       return err;
1103     }
1104
1105   switch (mode)
1106     {
1107     case CERT_USAGE_MODE_SIGN:
1108     case CERT_USAGE_MODE_VRFY:
1109       if ((use & (KSBA_KEYUSAGE_DIGITAL_SIGNATURE
1110                   | KSBA_KEYUSAGE_NON_REPUDIATION)))
1111         return 0;
1112       log_info (mode == CERT_USAGE_MODE_VRFY
1113                 ? _("certificate should not have been used for signing\n")
1114                 : _("certificate is not usable for signing\n"));
1115       break;
1116
1117     case CERT_USAGE_MODE_ENCR:
1118     case CERT_USAGE_MODE_DECR:
1119       if ((use & (KSBA_KEYUSAGE_KEY_ENCIPHERMENT
1120                   | KSBA_KEYUSAGE_DATA_ENCIPHERMENT)))
1121         return 0;
1122       log_info (mode == CERT_USAGE_MODE_DECR
1123                 ? _("certificate should not have been used for encryption\n")
1124                 : _("certificate is not usable for encryption\n"));
1125       break;
1126
1127     case CERT_USAGE_MODE_CERT:
1128       if ((use & (KSBA_KEYUSAGE_KEY_CERT_SIGN)))
1129         return 0;
1130       log_info (_("certificate should not have "
1131                   "been used for certification\n"));
1132       break;
1133
1134     case CERT_USAGE_MODE_OCSP:
1135       if (use != ~0
1136           && (have_ocsp_signing
1137               || (use & (KSBA_KEYUSAGE_KEY_CERT_SIGN
1138                          |KSBA_KEYUSAGE_CRL_SIGN))))
1139         return 0;
1140       log_info (_("certificate should not have "
1141                   "been used for OCSP response signing\n"));
1142       break;
1143
1144     case CERT_USAGE_MODE_CRL:
1145       if ((use & (KSBA_KEYUSAGE_CRL_SIGN)))
1146         return 0;
1147       log_info (_("certificate should not have "
1148                   "been used for CRL signing\n"));
1149       break;
1150     }
1151
1152   return gpg_error (GPG_ERR_WRONG_KEY_USAGE);
1153 }
1154
1155
1156 /* Return 0 if the certificate CERT is usable for certification.  */
1157 gpg_error_t
1158 check_cert_use_cert (ksba_cert_t cert)
1159 {
1160   return check_cert_usage (cert, CERT_USAGE_MODE_CERT);
1161 }
1162
1163 /* Return 0 if the certificate CERT is usable for signing OCSP
1164    responses.  */
1165 gpg_error_t
1166 check_cert_use_ocsp (ksba_cert_t cert)
1167 {
1168   return check_cert_usage (cert, CERT_USAGE_MODE_OCSP);
1169 }
1170
1171 /* Return 0 if the certificate CERT is usable for signing CRLs. */
1172 gpg_error_t
1173 check_cert_use_crl (ksba_cert_t cert)
1174 {
1175   return check_cert_usage (cert, CERT_USAGE_MODE_CRL);
1176 }