* options.h, keyserver.c (parse_keyserver_uri, keyserver_spawn,
[gnupg.git] / sm / certpath.c
1 /* certpath.c - path validation
2  *      Copyright (C) 2001 Free Software Foundation, Inc.
3  *
4  * This file is part of GnuPG.
5  *
6  * GnuPG is free software; you can redistribute it and/or modify
7  * it under the terms of the GNU General Public License as published by
8  * the Free Software Foundation; either version 2 of the License, or
9  * (at your option) any later version.
10  *
11  * GnuPG is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14  * GNU General Public License for more details.
15  *
16  * You should have received a copy of the GNU General Public License
17  * along with this program; if not, write to the Free Software
18  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
19  */
20
21 #include <config.h>
22 #include <stdio.h>
23 #include <stdlib.h>
24 #include <string.h>
25 #include <errno.h>
26 #include <unistd.h> 
27 #include <time.h>
28 #include <assert.h>
29
30 #include <gcrypt.h>
31 #include <ksba.h>
32
33 #include "gpgsm.h"
34 #include "keydb.h"
35 #include "i18n.h"
36
37 static int
38 unknown_criticals (KsbaCert cert)
39 {
40   static const char *known[] = {
41     "2.5.29.15", /* keyUsage */
42     "2.5.29.19", /* basic Constraints */
43     "2.5.29.32", /* certificatePolicies */
44     NULL
45   };
46   int rc = 0, i, idx, crit;
47   const char *oid;
48   KsbaError err;
49
50   for (idx=0; !(err=ksba_cert_get_extension (cert, idx,
51                                              &oid, &crit, NULL, NULL));idx++)
52     {
53       if (!crit)
54         continue;
55       for (i=0; known[i] && strcmp (known[i],oid); i++)
56         ;
57       if (!known[i])
58         {
59           log_error (_("critical certificate extension %s is not supported\n"),
60                      oid);
61           rc = GNUPG_Unsupported_Certificate;
62         }
63     }
64   if (err && err != -1)
65     rc = map_ksba_err (err);
66
67   return rc;
68 }
69
70 static int
71 allowed_ca (KsbaCert cert, int *pathlen)
72 {
73   KsbaError err;
74   int flag;
75
76   err = ksba_cert_is_ca (cert, &flag, pathlen);
77   if (err)
78     return map_ksba_err (err);
79   if (!flag)
80     {
81       log_error (_("issuer certificate is not marked as a CA\n"));
82       return GNUPG_Bad_CA_Certificate;
83     }
84   return 0;
85 }
86
87
88 static int
89 check_cert_policy (KsbaCert cert)
90 {
91   KsbaError err;
92   char *policies;
93   FILE *fp;
94   int any_critical;
95
96   err = ksba_cert_get_cert_policies (cert, &policies);
97   if (err == KSBA_No_Data)
98     return 0; /* no policy given */
99   if (err)
100     return map_ksba_err (err);
101
102   /* STRING is a line delimited list of certifiate policies as stored
103      in the certificate.  The line itself is colon delimited where the
104      first field is the OID of the policy and the second field either
105      N or C for normal or critical extension */
106
107   if (opt.verbose > 1)
108     log_info ("certificate's policy list: %s\n", policies);
109
110   /* The check is very minimal but won't give false positives */
111   any_critical = !!strstr (policies, ":C");
112
113   if (!opt.policy_file)
114     { 
115       xfree (policies);
116       if (any_critical)
117         {
118           log_error ("critical marked policy without configured policies\n");
119           return GNUPG_No_Policy_Match;
120         }
121       return 0;
122     }
123
124   fp = fopen (opt.policy_file, "r");
125   if (!fp)
126     {
127       log_error ("failed to open `%s': %s\n",
128                  opt.policy_file, strerror (errno));
129       xfree (policies);
130       return GNUPG_No_Policy_Match;
131     }
132
133   for (;;) 
134     {
135       int c;
136       char *p, line[256];
137       char *haystack, *allowed;
138
139       /* read line */
140       do
141         {
142           if (!fgets (line, DIM(line)-1, fp) )
143             {
144               xfree (policies);
145               if (feof (fp))
146                 {
147                   fclose (fp);
148                   /* with no critical policies this is only a warning */
149                   if (!any_critical)
150                     {
151                       log_info (_("note: certificate policy not allowed\n"));
152                       return 0;
153                     }
154                   log_error (_("certificate policy not allowed\n"));
155                   return GNUPG_No_Policy_Match;
156                 }
157               fclose (fp);
158               return GNUPG_Read_Error;
159             }
160       
161           if (!*line || line[strlen(line)-1] != '\n')
162             {
163               /* eat until end of line */
164               while ( (c=getc (fp)) != EOF && c != '\n')
165                 ;
166               fclose (fp);
167               xfree (policies);
168               return *line? GNUPG_Line_Too_Long: GNUPG_Incomplete_Line;
169             }
170           
171           /* Allow for empty lines and spaces */
172           for (p=line; spacep (p); p++)
173             ;
174         }
175       while (!*p || *p == '\n' || *p == '#');
176   
177       /* parse line */
178       for (allowed=line; spacep (allowed); allowed++)
179         ;
180       p = strpbrk (allowed, " :\n");
181       if (!*p || p == allowed)
182         {
183           fclose (fp);
184           xfree (policies);
185           return GNUPG_Configuration_Error;
186         }
187       *p = 0; /* strip the rest of the line */
188       /* See whether we find ALLOWED (which is an OID) in POLICIES */
189       for (haystack=policies; (p=strstr (haystack, allowed)); haystack = p+1)
190         {
191           if ( !(p == policies || p[-1] == '\n') )
192             continue; /* does not match the begin of a line */
193           if (p[strlen (allowed)] != ':')
194             continue; /* the length does not match */
195           /* Yep - it does match so return okay */
196           fclose (fp);
197           xfree (policies);
198           return 0;
199         }
200     }
201 }
202
203
204 static void
205 find_up_store_certs_cb (void *cb_value, KsbaCert cert)
206 {
207   if (keydb_store_cert (cert, 1, NULL))
208     log_error ("error storing issuer certificate as ephemeral\n");
209   ++*(int*)cb_value;
210 }
211
212
213 static int
214 find_up (KEYDB_HANDLE kh, KsbaCert cert, const char *issuer)
215 {
216   KsbaName authid;
217   KsbaSexp authidno;
218   int rc = -1;
219
220   if (!ksba_cert_get_auth_key_id (cert, NULL, &authid, &authidno))
221     {
222       const char *s = ksba_name_enum (authid, 0);
223       if (s && *authidno)
224         {
225           rc = keydb_search_issuer_sn (kh, s, authidno);
226           if (rc)
227               keydb_search_reset (kh);
228           if (rc == -1)
229             { /* And try the ephemeral DB. */
230               int old = keydb_set_ephemeral (kh, 1);
231               if (!old)
232                 {
233                   rc = keydb_search_issuer_sn (kh, s, authidno);
234                   if (rc)
235                     keydb_search_reset (kh);
236                 }
237               keydb_set_ephemeral (kh, old);
238             }
239         }
240       ksba_name_release (authid);
241       xfree (authidno);
242       /* Fixme: don't know how to do dirmngr lookup with serial+issuer. */
243     }
244   
245   if (rc) /* not found via authorithyKeyIdentifier, try regular issuer name */
246       rc = keydb_search_subject (kh, issuer);
247   if (rc == -1)
248     {
249       /* Not found, lets see whether we have one in the ephemeral key DB. */
250       int old = keydb_set_ephemeral (kh, 1);
251       if (!old)
252         {
253           keydb_search_reset (kh);
254           rc = keydb_search_subject (kh, issuer);
255         }
256       keydb_set_ephemeral (kh, old);
257     }
258
259   if (rc == -1 && opt.auto_issuer_key_retrieve)
260     {
261       STRLIST names = NULL;
262       int count = 0;
263       char *pattern;
264       const char *s;
265       
266       if (opt.verbose)
267         log_info (_("looking up issuer at external location\n"));
268       /* dirmngr is confused about unknown attributes so has a quick
269          and ugly hack we locate the CN and use this and the
270          following.  Fixme: we should have far ebtter parsing in the
271          dirmngr. */
272       s = strstr (issuer, "CN=");
273       if (!s || s == issuer || s[-1] != ',')
274         s = issuer;
275
276       pattern = xtrymalloc (strlen (s)+2);
277       if (!pattern)
278         return GNUPG_Out_Of_Core;
279       strcpy (stpcpy (pattern, "/"), s);
280       add_to_strlist (&names, pattern);
281       xfree (pattern);
282       rc = gpgsm_dirmngr_lookup (NULL, names, find_up_store_certs_cb, &count);
283       free_strlist (names);
284       if (opt.verbose)
285         log_info (_("number of issuers matching: %d\n"), count);
286       if (rc) 
287         {
288           log_error ("external key lookup failed: %s\n", gnupg_strerror (rc));
289           rc = -1;
290         }
291       else if (!count)
292         rc = -1;
293       else
294         {
295           int old;
296           /* The issuers are currently stored in the ephemeral key
297              DB, so we temporary switch to ephemeral mode. */
298           old = keydb_set_ephemeral (kh, 1);
299           keydb_search_reset (kh);
300           rc = keydb_search_subject (kh, issuer);
301           keydb_set_ephemeral (kh, old);
302         }
303     }
304   return rc;
305 }
306
307
308 /* Return the next certificate up in the chain starting at START.
309    Returns -1 when there are no more certificates. */
310 int
311 gpgsm_walk_cert_chain (KsbaCert start, KsbaCert *r_next)
312 {
313   int rc = 0; 
314   char *issuer = NULL;
315   char *subject = NULL;
316   KEYDB_HANDLE kh = keydb_new (0);
317
318   *r_next = NULL;
319   if (!kh)
320     {
321       log_error (_("failed to allocated keyDB handle\n"));
322       rc = GNUPG_General_Error;
323       goto leave;
324     }
325
326   issuer = ksba_cert_get_issuer (start, 0);
327   subject = ksba_cert_get_subject (start, 0);
328   if (!issuer)
329     {
330       log_error ("no issuer found in certificate\n");
331       rc = GNUPG_Bad_Certificate;
332       goto leave;
333     }
334   if (!subject)
335     {
336       log_error ("no subject found in certificate\n");
337       rc = GNUPG_Bad_Certificate;
338       goto leave;
339     }
340
341   if (!strcmp (issuer, subject))
342     {
343       rc = -1; /* we are at the root */
344       goto leave; 
345     }
346
347   rc = find_up (kh, start, issuer);
348   if (rc)
349     {
350       /* it is quite common not to have a certificate, so better don't
351          print an error here */
352       if (rc != -1 && opt.verbose > 1)
353         log_error ("failed to find issuer's certificate: rc=%d\n", rc);
354       rc = GNUPG_Missing_Certificate;
355       goto leave;
356     }
357
358   rc = keydb_get_cert (kh, r_next);
359   if (rc)
360     {
361       log_error ("failed to get cert: rc=%d\n", rc);
362       rc = GNUPG_General_Error;
363     }
364
365  leave:
366   xfree (issuer);
367   xfree (subject);
368   keydb_release (kh); 
369   return rc;
370 }
371
372
373 /* Check whether the CERT is a root certificate.  Returns True if this
374    is the case. */
375 int
376 gpgsm_is_root_cert (KsbaCert cert)
377 {
378   char *issuer;
379   char *subject;
380   int yes;
381
382   issuer = ksba_cert_get_issuer (cert, 0);
383   subject = ksba_cert_get_subject (cert, 0);
384   yes = (issuer && subject && !strcmp (issuer, subject));
385   xfree (issuer);
386   xfree (subject);
387   return yes;
388 }
389
390 \f
391 /* Validate a path and optionally return the nearest expiration time
392    in R_EXPTIME */
393 int
394 gpgsm_validate_path (CTRL ctrl, KsbaCert cert, time_t *r_exptime)
395 {
396   int rc = 0, depth = 0, maxdepth;
397   char *issuer = NULL;
398   char *subject = NULL;
399   KEYDB_HANDLE kh = keydb_new (0);
400   KsbaCert subject_cert = NULL, issuer_cert = NULL;
401   time_t current_time = gnupg_get_time ();
402   time_t exptime = 0;
403   int any_expired = 0;
404   int any_revoked = 0;
405   int any_no_crl = 0;
406   int any_crl_too_old = 0;
407   int any_no_policy_match = 0;
408
409   if (r_exptime)
410     *r_exptime = 0;
411
412   if (opt.no_path_validation)
413     {
414       log_info ("WARNING: bypassing path validation\n");
415       return 0;
416     }
417   
418   if (!kh)
419     {
420       log_error (_("failed to allocated keyDB handle\n"));
421       rc = GNUPG_General_Error;
422       goto leave;
423     }
424
425   if (DBG_X509)
426     gpgsm_dump_cert ("subject", cert);
427
428   subject_cert = cert;
429   maxdepth = 50;
430
431   for (;;)
432     {
433       xfree (issuer);
434       xfree (subject);
435       issuer = ksba_cert_get_issuer (subject_cert, 0);
436       subject = ksba_cert_get_subject (subject_cert, 0);
437
438       if (!issuer)
439         {
440           log_error ("no issuer found in certificate\n");
441           rc = GNUPG_Bad_Certificate;
442           goto leave;
443         }
444
445       {
446         time_t not_before, not_after;
447
448         not_before = ksba_cert_get_validity (subject_cert, 0);
449         not_after = ksba_cert_get_validity (subject_cert, 1);
450         if (not_before == (time_t)(-1) || not_after == (time_t)(-1))
451           {
452             log_error ("certificate with invalid validity\n");
453             rc = GNUPG_Bad_Certificate;
454             goto leave;
455           }
456
457         if (not_after)
458           {
459             if (!exptime)
460               exptime = not_after;
461             else if (not_after < exptime)
462               exptime = not_after;
463           }
464
465         if (not_before && current_time < not_before)
466           {
467             log_error ("certificate too young; valid from ");
468             gpgsm_dump_time (not_before);
469             log_printf ("\n");
470             rc = GNUPG_Certificate_Too_Young;
471             goto leave;
472           }            
473         if (not_after && current_time > not_after)
474           {
475             log_error ("certificate has expired at ");
476             gpgsm_dump_time (not_after);
477             log_printf ("\n");
478             any_expired = 1;
479           }            
480       }
481
482       rc = unknown_criticals (subject_cert);
483       if (rc)
484         goto leave;
485
486       if (!opt.no_policy_check)
487         {
488           rc = check_cert_policy (subject_cert);
489           if (rc == GNUPG_No_Policy_Match)
490             {
491               any_no_policy_match = 1;
492               rc = 1;
493             }
494           else if (rc)
495             goto leave;
496         }
497
498       if (!opt.no_crl_check)
499         {
500           rc = gpgsm_dirmngr_isvalid (subject_cert);
501           if (rc)
502             {
503               switch (rc)
504                 {
505                 case GNUPG_Certificate_Revoked:
506                   log_error (_("the certificate has been revoked\n"));
507                   any_revoked = 1;
508                   break;
509                 case GNUPG_No_CRL_Known:
510                   log_error (_("no CRL found for certificate\n"));
511                   any_no_crl = 1;
512                   break;
513                 case GNUPG_CRL_Too_Old:
514                   log_error (_("the available CRL is too old\n"));
515                   log_info (_("please make sure that the "
516                               "\"dirmngr\" is properly installed\n"));
517                   any_crl_too_old = 1;
518                   break;
519                 default:
520                   log_error (_("checking the CRL failed: %s\n"),
521                              gnupg_strerror (rc));
522                   goto leave;
523                 }
524               rc = 0;
525             }
526         }
527
528       if (subject && !strcmp (issuer, subject))
529         {
530           if (gpgsm_check_cert_sig (subject_cert, subject_cert) )
531             {
532               log_error ("selfsigned certificate has a BAD signatures\n");
533               rc = depth? GNUPG_Bad_Certificate_Path : GNUPG_Bad_Certificate;
534               goto leave;
535             }
536           rc = allowed_ca (subject_cert, NULL);
537           if (rc)
538             goto leave;
539
540           rc = gpgsm_agent_istrusted (subject_cert);
541           if (!rc)
542             ;
543           else if (rc == GNUPG_Not_Trusted)
544             {
545               int rc2;
546
547               char *fpr = gpgsm_get_fingerprint_string (subject_cert,
548                                                         GCRY_MD_SHA1);
549               log_info (_("root certificate is not marked trusted\n"));
550               log_info (_("fingerprint=%s\n"), fpr? fpr : "?");
551               xfree (fpr);
552               rc2 = gpgsm_agent_marktrusted (subject_cert);
553               if (!rc2)
554                 {
555                   log_info (_("root certificate has now"
556                               " been marked as trusted\n"));
557                   rc = 0;
558                 }
559               else 
560                 {
561                   gpgsm_dump_cert ("issuer", subject_cert);
562                   log_info ("after checking the fingerprint, you may want "
563                             "to enter it manually into "
564                             "\"~/.gnupg-test/trustlist.txt\"\n");
565                 }
566             }
567           else 
568             {
569               log_error (_("checking the trust list failed: %s\n"),
570                          gnupg_strerror (rc));
571             }
572           
573           break;  /* okay, a self-signed certicate is an end-point */
574         }
575       
576       depth++;
577       if (depth > maxdepth)
578         {
579           log_error (_("certificate path too long\n"));
580           rc = GNUPG_Bad_Certificate_Path;
581           goto leave;
582         }
583
584       /* find the next cert up the tree */
585       keydb_search_reset (kh);
586       rc = find_up (kh, subject_cert, issuer);
587       if (rc)
588         {
589           if (rc == -1)
590             {
591               log_info ("issuer certificate (");
592               gpgsm_dump_string (issuer);
593               log_printf (") not found\n");
594             }
595           else
596             log_error ("failed to find issuer's certificate: rc=%d\n", rc);
597           rc = GNUPG_Missing_Certificate;
598           goto leave;
599         }
600
601       ksba_cert_release (issuer_cert); issuer_cert = NULL;
602       rc = keydb_get_cert (kh, &issuer_cert);
603       if (rc)
604         {
605           log_error ("failed to get cert: rc=%d\n", rc);
606           rc = GNUPG_General_Error;
607           goto leave;
608         }
609
610       if (DBG_X509)
611         {
612           log_debug ("got issuer's certificate:\n");
613           gpgsm_dump_cert ("issuer", issuer_cert);
614         }
615
616       if (gpgsm_check_cert_sig (issuer_cert, subject_cert) )
617         {
618           log_error ("certificate has a BAD signatures\n");
619           rc = GNUPG_Bad_Certificate_Path;
620           goto leave;
621         }
622
623       {
624         int pathlen;
625         rc = allowed_ca (issuer_cert, &pathlen);
626         if (rc)
627           goto leave;
628         if (pathlen >= 0 && (depth - 1) > pathlen)
629           {
630             log_error (_("certificate path longer than allowed by CA (%d)\n"),
631                        pathlen);
632             rc = GNUPG_Bad_Certificate_Path;
633             goto leave;
634           }
635       }
636
637       rc = gpgsm_cert_use_cert_p (issuer_cert);
638       if (rc)
639         {
640           gpgsm_status2 (ctrl, STATUS_ERROR, "certpath.issuer.keyusage",
641                          gnupg_error_token (rc), NULL);
642           rc = 0;
643         }
644
645       if (opt.verbose)
646         log_info ("certificate is good\n");
647       
648       keydb_search_reset (kh);
649       subject_cert = issuer_cert;
650       issuer_cert = NULL;
651     }
652
653   if (opt.no_policy_check)
654     log_info ("policies not checked due to --disable-policy-checks option\n");
655   if (opt.no_crl_check)
656     log_info ("CRLs not checked due to --disable-crl-checks option\n");
657
658   if (!rc)
659     { /* If we encountered an error somewhere during the checks, set
660          the error code to the most critical one */
661       if (any_revoked)
662         rc = GNUPG_Certificate_Revoked;
663       else if (any_no_crl)
664         rc = GNUPG_No_CRL_Known;
665       else if (any_crl_too_old)
666         rc = GNUPG_CRL_Too_Old;
667       else if (any_no_policy_match)
668         rc = GNUPG_No_Policy_Match;
669       else if (any_expired)
670         rc = GNUPG_Certificate_Expired;
671     }
672   
673  leave:
674   if (r_exptime)
675     *r_exptime = exptime;
676   xfree (issuer);
677   keydb_release (kh); 
678   ksba_cert_release (issuer_cert);
679   if (subject_cert != cert)
680     ksba_cert_release (subject_cert);
681   return rc;
682 }
683
684
685 /* Check that the given certificate is valid but DO NOT check any
686    constraints.  We assume that the issuers certificate is already in
687    the DB and that this one is valid; which it should be because it
688    has been checked using this function. */
689 int
690 gpgsm_basic_cert_check (KsbaCert cert)
691 {
692   int rc = 0;
693   char *issuer = NULL;
694   char *subject = NULL;
695   KEYDB_HANDLE kh = keydb_new (0);
696   KsbaCert issuer_cert = NULL;
697
698   if (opt.no_path_validation)
699     {
700       log_info ("WARNING: bypassing basic certificate checks\n");
701       return 0;
702     }
703
704   if (!kh)
705     {
706       log_error (_("failed to allocated keyDB handle\n"));
707       rc = GNUPG_General_Error;
708       goto leave;
709     }
710
711   issuer = ksba_cert_get_issuer (cert, 0);
712   subject = ksba_cert_get_subject (cert, 0);
713   if (!issuer)
714     {
715       log_error ("no issuer found in certificate\n");
716       rc = GNUPG_Bad_Certificate;
717       goto leave;
718     }
719
720   if (subject && !strcmp (issuer, subject))
721     {
722       if (gpgsm_check_cert_sig (cert, cert) )
723         {
724           log_error ("selfsigned certificate has a BAD signatures\n");
725           rc = GNUPG_Bad_Certificate;
726           goto leave;
727         }
728     }
729   else
730     {
731       /* find the next cert up the tree */
732       keydb_search_reset (kh);
733       rc = find_up (kh, cert, issuer);
734       if (rc)
735         {
736           if (rc == -1)
737             {
738               log_info ("issuer certificate (");
739               gpgsm_dump_string (issuer);
740               log_printf (") not found\n");
741             }
742           else
743             log_error ("failed to find issuer's certificate: rc=%d\n", rc);
744           rc = GNUPG_Missing_Certificate;
745           goto leave;
746         }
747       
748       ksba_cert_release (issuer_cert); issuer_cert = NULL;
749       rc = keydb_get_cert (kh, &issuer_cert);
750       if (rc)
751         {
752           log_error ("failed to get cert: rc=%d\n", rc);
753           rc = GNUPG_General_Error;
754           goto leave;
755         }
756
757       if (gpgsm_check_cert_sig (issuer_cert, cert) )
758         {
759           log_error ("certificate has a BAD signatures\n");
760           rc = GNUPG_Bad_Certificate;
761           goto leave;
762         }
763       if (opt.verbose)
764         log_info ("certificate is good\n");
765     }
766
767  leave:
768   xfree (issuer);
769   keydb_release (kh); 
770   ksba_cert_release (issuer_cert);
771   return rc;
772 }
773