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