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