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