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