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