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