978d1f755c3e80843932d42f24867676b63d8cb7
[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_Configuration_Error;
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                   log_error (_("certificate policy not allowed\n"));
149                   /* with no critical policies this is only a warning */
150                   return any_critical? GNUPG_No_Policy_Match : 0;
151                 }
152               fclose (fp);
153               return GNUPG_Read_Error;
154             }
155       
156           if (!*line || line[strlen(line)-1] != '\n')
157             {
158               /* eat until end of line */
159               while ( (c=getc (fp)) != EOF && c != '\n')
160                 ;
161               fclose (fp);
162               xfree (policies);
163               return *line? GNUPG_Line_Too_Long: GNUPG_Incomplete_Line;
164             }
165           
166           /* Allow for empty lines and spaces */
167           for (p=line; spacep (p); p++)
168             ;
169         }
170       while (!*p || *p == '\n' || *p == '#');
171   
172       /* parse line */
173       for (allowed=line; spacep (allowed); allowed++)
174         ;
175       p = strpbrk (allowed, " :\n");
176       if (!*p || p == allowed)
177         {
178           fclose (fp);
179           xfree (policies);
180           return GNUPG_Configuration_Error;
181         }
182       *p = 0; /* strip the rest of the line */
183       /* See whether we find ALLOWED (which is an OID) in POLICIES */
184       for (haystack=policies; (p=strstr (haystack, allowed)); haystack = p+1)
185         {
186           if ( !(p == policies || p[-1] == '\n') )
187             continue; /* does not match the begin of a line */
188           if (p[strlen (allowed)] != ':')
189             continue; /* the length does not match */
190           /* Yep - it does match so return okay */
191           fclose (fp);
192           xfree (policies);
193           return 0;
194         }
195     }
196 }
197
198
199 static int
200 find_up (KEYDB_HANDLE kh, KsbaCert cert, const char *issuer)
201 {
202   KsbaName authid;
203   KsbaSexp authidno;
204   int rc = -1;
205
206   if (!ksba_cert_get_auth_key_id (cert, NULL, &authid, &authidno))
207     {
208       const char *s = ksba_name_enum (authid, 0);
209       if (s && *authidno)
210         {
211           rc = keydb_search_issuer_sn (kh, s, authidno);
212           if (rc)
213               keydb_search_reset (kh);
214         }
215       ksba_name_release (authid);
216       xfree (authidno);
217     }
218   
219   if (rc)
220     rc = keydb_search_subject (kh, issuer);
221   return rc;
222 }
223
224
225 /* Return the next certificate up in the chain starting at START.
226    Returns -1 when there are no more certificates. */
227 int
228 gpgsm_walk_cert_chain (KsbaCert start, KsbaCert *r_next)
229 {
230   int rc = 0; 
231   char *issuer = NULL;
232   char *subject = NULL;
233   KEYDB_HANDLE kh = keydb_new (0);
234
235   *r_next = NULL;
236   if (!kh)
237     {
238       log_error (_("failed to allocated keyDB handle\n"));
239       rc = GNUPG_General_Error;
240       goto leave;
241     }
242
243   issuer = ksba_cert_get_issuer (start, 0);
244   subject = ksba_cert_get_subject (start, 0);
245   if (!issuer)
246     {
247       log_error ("no issuer found in certificate\n");
248       rc = GNUPG_Bad_Certificate;
249       goto leave;
250     }
251   if (!subject)
252     {
253       log_error ("no subject found in certificate\n");
254       rc = GNUPG_Bad_Certificate;
255       goto leave;
256     }
257
258   if (!strcmp (issuer, subject))
259     {
260       rc = -1; /* we are at the root */
261       goto leave; 
262     }
263
264   rc = find_up (kh, start, issuer);
265   if (rc)
266     {
267       /* it is quite common not to have a certificate, so better don't
268          print an error here */
269       if (rc != -1 && opt.verbose > 1)
270         log_error ("failed to find issuer's certificate: rc=%d\n", rc);
271       rc = GNUPG_Missing_Certificate;
272       goto leave;
273     }
274
275   rc = keydb_get_cert (kh, r_next);
276   if (rc)
277     {
278       log_error ("failed to get cert: rc=%d\n", rc);
279       rc = GNUPG_General_Error;
280     }
281
282  leave:
283   xfree (issuer);
284   xfree (subject);
285   keydb_release (kh); 
286   return rc;
287 }
288
289
290 /* Check whether the CERT is a root certificate.  Returns True if this
291    is the case. */
292 int
293 gpgsm_is_root_cert (KsbaCert cert)
294 {
295   char *issuer;
296   char *subject;
297   int yes;
298
299   issuer = ksba_cert_get_issuer (cert, 0);
300   subject = ksba_cert_get_subject (cert, 0);
301   yes = (issuer && subject && !strcmp (issuer, subject));
302   xfree (issuer);
303   xfree (subject);
304   return yes;
305 }
306
307 \f
308 int
309 gpgsm_validate_path (KsbaCert cert)
310 {
311   int rc = 0, depth = 0, maxdepth;
312   char *issuer = NULL;
313   char *subject = NULL;
314   KEYDB_HANDLE kh = keydb_new (0);
315   KsbaCert subject_cert = NULL, issuer_cert = NULL;
316   time_t current_time = time (NULL);
317
318   if ((opt.debug & 4096))
319     {
320       log_info ("WARNING: bypassing path validation\n");
321       return 0;
322     }
323       
324
325   if (!kh)
326     {
327       log_error (_("failed to allocated keyDB handle\n"));
328       rc = GNUPG_General_Error;
329       goto leave;
330     }
331
332   if (DBG_X509)
333     gpgsm_dump_cert ("subject", cert);
334
335   subject_cert = cert;
336   maxdepth = 50;
337
338   for (;;)
339     {
340       xfree (issuer);
341       xfree (subject);
342       issuer = ksba_cert_get_issuer (subject_cert, 0);
343       subject = ksba_cert_get_subject (subject_cert, 0);
344
345       if (!issuer)
346         {
347           log_error ("no issuer found in certificate\n");
348           rc = GNUPG_Bad_Certificate;
349           goto leave;
350         }
351
352       {
353         time_t not_before, not_after;
354
355         not_before = ksba_cert_get_validity (subject_cert, 0);
356         not_after = ksba_cert_get_validity (subject_cert, 1);
357         if (not_before == (time_t)(-1) || not_after == (time_t)(-1))
358           {
359             log_error ("certificate with invalid validity\n");
360             rc = GNUPG_Bad_Certificate;
361             goto leave;
362           }
363
364         if (current_time < not_before)
365           {
366             log_error ("certificate to young; valid from ");
367             gpgsm_dump_time (not_before);
368             log_printf ("\n");
369             rc = GNUPG_Certificate_Too_Young;
370             goto leave;
371           }            
372         if (current_time > not_after)
373           {
374             log_error ("certificate has expired at ");
375             gpgsm_dump_time (not_after);
376             log_printf ("\n");
377             rc = GNUPG_Certificate_Expired;
378             goto leave;
379           }            
380       }
381
382       rc = unknown_criticals (subject_cert);
383       if (rc)
384         goto leave;
385
386       if (!opt.no_policy_check)
387         {
388           rc = check_cert_policy (subject_cert);
389           if (rc)
390             goto leave;
391         }
392
393       if (!opt.no_crl_check)
394         {
395           rc = gpgsm_dirmngr_isvalid (subject_cert);
396           if (rc)
397             {
398               switch (rc)
399                 {
400                 case GNUPG_Certificate_Revoked:
401                   log_error (_("the certificate has been revoked\n"));
402                   break;
403                 case GNUPG_No_CRL_Known:
404                   log_error (_("no CRL found for certificate\n"));
405                   break;
406                 case GNUPG_CRL_Too_Old:
407                   log_error (_("the available CRL is too old\n"));
408                   log_info (_("please make sure that the "
409                               "\"dirmngr\" is properly installed\n"));
410                   break;
411                 default:
412                   log_error (_("checking the CRL failed: %s\n"),
413                              gnupg_strerror (rc));
414                   break;
415                 }
416               goto leave;
417             }
418         }
419
420       if (subject && !strcmp (issuer, subject))
421         {
422           if (gpgsm_check_cert_sig (subject_cert, subject_cert) )
423             {
424               log_error ("selfsigned certificate has a BAD signatures\n");
425               rc = depth? GNUPG_Bad_Certificate_Path : GNUPG_Bad_Certificate;
426               goto leave;
427             }
428           rc = allowed_ca (subject_cert, NULL);
429           if (rc)
430             goto leave;
431
432           rc = gpgsm_agent_istrusted (subject_cert);
433           if (!rc)
434             ;
435           else if (rc == GNUPG_Not_Trusted)
436             {
437               int rc2;
438
439               char *fpr = gpgsm_get_fingerprint_string (subject_cert,
440                                                         GCRY_MD_SHA1);
441               log_info (_("root certificate is not marked trusted\n"));
442               log_info (_("fingerprint=%s\n"), fpr? fpr : "?");
443               xfree (fpr);
444               rc2 = gpgsm_agent_marktrusted (subject_cert);
445               if (!rc2)
446                 {
447                   log_info (_("root certificate has now"
448                               " been marked as trusted\n"));
449                   rc = 0;
450                 }
451               else 
452                 {
453                   gpgsm_dump_cert ("issuer", subject_cert);
454                   log_info ("after checking the fingerprint, you may want "
455                             "to enter it manually into "
456                             "\"~/.gnupg-test/trustlist.txt\"\n");
457                 }
458             }
459           else 
460             {
461               log_error (_("checking the trust list failed: %s\n"),
462                          gnupg_strerror (rc));
463             }
464           
465           break;  /* okay, a self-signed certicate is an end-point */
466         }
467       
468       depth++;
469       if (depth > maxdepth)
470         {
471           log_error (_("certificate path too long\n"));
472           rc = GNUPG_Bad_Certificate_Path;
473           goto leave;
474         }
475
476       /* find the next cert up the tree */
477       keydb_search_reset (kh);
478       rc = find_up (kh, subject_cert, issuer);
479       if (rc)
480         {
481           if (rc == -1)
482             {
483               log_info ("issuer certificate (");
484               gpgsm_dump_string (issuer);
485               log_printf (") not found\n");
486             }
487           else
488             log_error ("failed to find issuer's certificate: rc=%d\n", rc);
489           rc = GNUPG_Missing_Certificate;
490           goto leave;
491         }
492
493       ksba_cert_release (issuer_cert); issuer_cert = NULL;
494       rc = keydb_get_cert (kh, &issuer_cert);
495       if (rc)
496         {
497           log_error ("failed to get cert: rc=%d\n", rc);
498           rc = GNUPG_General_Error;
499           goto leave;
500         }
501
502       if (DBG_X509)
503         {
504           log_debug ("got issuer's certificate:\n");
505           gpgsm_dump_cert ("issuer", issuer_cert);
506         }
507
508       if (gpgsm_check_cert_sig (issuer_cert, subject_cert) )
509         {
510           log_error ("certificate has a BAD signatures\n");
511           rc = GNUPG_Bad_Certificate_Path;
512           goto leave;
513         }
514
515       {
516         int pathlen;
517         rc = allowed_ca (issuer_cert, &pathlen);
518         if (rc)
519           goto leave;
520         if (pathlen >= 0 && (depth - 1) > pathlen)
521           {
522             log_error (_("certificate path longer than allowed by CA (%d)\n"),
523                        pathlen);
524             rc = GNUPG_Bad_Certificate_Path;
525             goto leave;
526           }
527       }
528
529       log_info ("certificate is good\n");
530       
531       keydb_search_reset (kh);
532       subject_cert = issuer_cert;
533       issuer_cert = NULL;
534     }
535
536   if (opt.no_policy_check)
537     log_info ("policies not checked due to --disable-policy-checks option\n");
538   if (opt.no_crl_check)
539     log_info ("CRLs not checked due to --disable-crl-checks option\n");
540   
541  leave:
542   xfree (issuer);
543   keydb_release (kh); 
544   ksba_cert_release (issuer_cert);
545   if (subject_cert != cert)
546     ksba_cert_release (subject_cert);
547   return rc;
548 }
549
550
551 /* Check that the given certificate is valid but DO NOT check any
552    constraints.  We assume that the issuers certificate is already in
553    the DB and that this one is valid; which it should be because it
554    has been checked using this function. */
555 int
556 gpgsm_basic_cert_check (KsbaCert cert)
557 {
558   int rc = 0;
559   char *issuer = NULL;
560   char *subject = NULL;
561   KEYDB_HANDLE kh = keydb_new (0);
562   KsbaCert issuer_cert = NULL;
563
564   if ((opt.debug & 4096))
565     {
566       log_info ("WARNING: bypassing basic certificate checks\n");
567       return 0;
568     }
569
570   if (!kh)
571     {
572       log_error (_("failed to allocated keyDB handle\n"));
573       rc = GNUPG_General_Error;
574       goto leave;
575     }
576
577   issuer = ksba_cert_get_issuer (cert, 0);
578   subject = ksba_cert_get_subject (cert, 0);
579   if (!issuer)
580     {
581       log_error ("no issuer found in certificate\n");
582       rc = GNUPG_Bad_Certificate;
583       goto leave;
584     }
585
586   if (subject && !strcmp (issuer, subject))
587     {
588       if (gpgsm_check_cert_sig (cert, cert) )
589         {
590           log_error ("selfsigned certificate has a BAD signatures\n");
591           rc = GNUPG_Bad_Certificate;
592           goto leave;
593         }
594     }
595   else
596     {
597       /* find the next cert up the tree */
598       keydb_search_reset (kh);
599       rc = find_up (kh, cert, issuer);
600       if (rc)
601         {
602           if (rc == -1)
603             {
604               log_info ("issuer certificate (");
605               gpgsm_dump_string (issuer);
606               log_printf (") not found\n");
607             }
608           else
609             log_error ("failed to find issuer's certificate: rc=%d\n", rc);
610           rc = GNUPG_Missing_Certificate;
611           goto leave;
612         }
613       
614       ksba_cert_release (issuer_cert); issuer_cert = NULL;
615       rc = keydb_get_cert (kh, &issuer_cert);
616       if (rc)
617         {
618           log_error ("failed to get cert: rc=%d\n", rc);
619           rc = GNUPG_General_Error;
620           goto leave;
621         }
622
623       if (gpgsm_check_cert_sig (issuer_cert, cert) )
624         {
625           log_error ("certificate has a BAD signatures\n");
626           rc = GNUPG_Bad_Certificate;
627           goto leave;
628         }
629       if (opt.verbose)
630         log_info ("certificate is good\n");
631     }
632
633  leave:
634   xfree (issuer);
635   keydb_release (kh); 
636   ksba_cert_release (issuer_cert);
637   return rc;
638 }
639