* sign.c (hash_and_copy_data): New.
[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
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 /* Validate a path and optionally return the nearest expiration time
309    in R_EXPTIME */
310 int
311 gpgsm_validate_path (KsbaCert cert, time_t *r_exptime)
312 {
313   int rc = 0, depth = 0, maxdepth;
314   char *issuer = NULL;
315   char *subject = NULL;
316   KEYDB_HANDLE kh = keydb_new (0);
317   KsbaCert subject_cert = NULL, issuer_cert = NULL;
318   time_t current_time = gnupg_get_time ();
319   time_t exptime = 0;
320   int any_expired = 0;
321   int any_revoked = 0;
322   int any_no_crl = 0;
323   int any_crl_too_old = 0;
324   int any_no_policy_match = 0;
325
326   if (r_exptime)
327     *r_exptime = 0;
328
329   if ((opt.debug & 4096))
330     {
331       log_info ("WARNING: bypassing path validation\n");
332       return 0;
333     }
334   
335   if (!kh)
336     {
337       log_error (_("failed to allocated keyDB handle\n"));
338       rc = GNUPG_General_Error;
339       goto leave;
340     }
341
342   if (DBG_X509)
343     gpgsm_dump_cert ("subject", cert);
344
345   subject_cert = cert;
346   maxdepth = 50;
347
348   for (;;)
349     {
350       xfree (issuer);
351       xfree (subject);
352       issuer = ksba_cert_get_issuer (subject_cert, 0);
353       subject = ksba_cert_get_subject (subject_cert, 0);
354
355       if (!issuer)
356         {
357           log_error ("no issuer found in certificate\n");
358           rc = GNUPG_Bad_Certificate;
359           goto leave;
360         }
361
362       {
363         time_t not_before, not_after;
364
365         not_before = ksba_cert_get_validity (subject_cert, 0);
366         not_after = ksba_cert_get_validity (subject_cert, 1);
367         if (not_before == (time_t)(-1) || not_after == (time_t)(-1))
368           {
369             log_error ("certificate with invalid validity\n");
370             rc = GNUPG_Bad_Certificate;
371             goto leave;
372           }
373
374         if (not_after)
375           {
376             if (!exptime)
377               exptime = not_after;
378             else if (not_after < exptime)
379               exptime = not_after;
380           }
381
382         if (not_before && current_time < not_before)
383           {
384             log_error ("certificate too young; valid from ");
385             gpgsm_dump_time (not_before);
386             log_printf ("\n");
387             rc = GNUPG_Certificate_Too_Young;
388             goto leave;
389           }            
390         if (not_after && current_time > not_after)
391           {
392             log_error ("certificate has expired at ");
393             gpgsm_dump_time (not_after);
394             log_printf ("\n");
395             any_expired = 1;
396           }            
397       }
398
399       rc = unknown_criticals (subject_cert);
400       if (rc)
401         goto leave;
402
403       if (!opt.no_policy_check)
404         {
405           rc = check_cert_policy (subject_cert);
406           if (rc == GNUPG_No_Policy_Match)
407             {
408               any_no_policy_match = 1;
409               rc = 1;
410             }
411           else if (rc)
412             goto leave;
413         }
414
415       if (!opt.no_crl_check)
416         {
417           rc = gpgsm_dirmngr_isvalid (subject_cert);
418           if (rc)
419             {
420               switch (rc)
421                 {
422                 case GNUPG_Certificate_Revoked:
423                   log_error (_("the certificate has been revoked\n"));
424                   any_revoked = 1;
425                   break;
426                 case GNUPG_No_CRL_Known:
427                   log_error (_("no CRL found for certificate\n"));
428                   any_no_crl = 1;
429                   break;
430                 case GNUPG_CRL_Too_Old:
431                   log_error (_("the available CRL is too old\n"));
432                   log_info (_("please make sure that the "
433                               "\"dirmngr\" is properly installed\n"));
434                   any_crl_too_old = 1;
435                   break;
436                 default:
437                   log_error (_("checking the CRL failed: %s\n"),
438                              gnupg_strerror (rc));
439                   goto leave;
440                 }
441               rc = 0;
442             }
443         }
444
445       if (subject && !strcmp (issuer, subject))
446         {
447           if (gpgsm_check_cert_sig (subject_cert, subject_cert) )
448             {
449               log_error ("selfsigned certificate has a BAD signatures\n");
450               rc = depth? GNUPG_Bad_Certificate_Path : GNUPG_Bad_Certificate;
451               goto leave;
452             }
453           rc = allowed_ca (subject_cert, NULL);
454           if (rc)
455             goto leave;
456
457           rc = gpgsm_agent_istrusted (subject_cert);
458           if (!rc)
459             ;
460           else if (rc == GNUPG_Not_Trusted)
461             {
462               int rc2;
463
464               char *fpr = gpgsm_get_fingerprint_string (subject_cert,
465                                                         GCRY_MD_SHA1);
466               log_info (_("root certificate is not marked trusted\n"));
467               log_info (_("fingerprint=%s\n"), fpr? fpr : "?");
468               xfree (fpr);
469               rc2 = gpgsm_agent_marktrusted (subject_cert);
470               if (!rc2)
471                 {
472                   log_info (_("root certificate has now"
473                               " been marked as trusted\n"));
474                   rc = 0;
475                 }
476               else 
477                 {
478                   gpgsm_dump_cert ("issuer", subject_cert);
479                   log_info ("after checking the fingerprint, you may want "
480                             "to enter it manually into "
481                             "\"~/.gnupg-test/trustlist.txt\"\n");
482                 }
483             }
484           else 
485             {
486               log_error (_("checking the trust list failed: %s\n"),
487                          gnupg_strerror (rc));
488             }
489           
490           break;  /* okay, a self-signed certicate is an end-point */
491         }
492       
493       depth++;
494       if (depth > maxdepth)
495         {
496           log_error (_("certificate path too long\n"));
497           rc = GNUPG_Bad_Certificate_Path;
498           goto leave;
499         }
500
501       /* find the next cert up the tree */
502       keydb_search_reset (kh);
503       rc = find_up (kh, subject_cert, issuer);
504       if (rc)
505         {
506           if (rc == -1)
507             {
508               log_info ("issuer certificate (");
509               gpgsm_dump_string (issuer);
510               log_printf (") not found\n");
511             }
512           else
513             log_error ("failed to find issuer's certificate: rc=%d\n", rc);
514           rc = GNUPG_Missing_Certificate;
515           goto leave;
516         }
517
518       ksba_cert_release (issuer_cert); issuer_cert = NULL;
519       rc = keydb_get_cert (kh, &issuer_cert);
520       if (rc)
521         {
522           log_error ("failed to get cert: rc=%d\n", rc);
523           rc = GNUPG_General_Error;
524           goto leave;
525         }
526
527       if (DBG_X509)
528         {
529           log_debug ("got issuer's certificate:\n");
530           gpgsm_dump_cert ("issuer", issuer_cert);
531         }
532
533       if (gpgsm_check_cert_sig (issuer_cert, subject_cert) )
534         {
535           log_error ("certificate has a BAD signatures\n");
536           rc = GNUPG_Bad_Certificate_Path;
537           goto leave;
538         }
539
540       {
541         int pathlen;
542         rc = allowed_ca (issuer_cert, &pathlen);
543         if (rc)
544           goto leave;
545         if (pathlen >= 0 && (depth - 1) > pathlen)
546           {
547             log_error (_("certificate path longer than allowed by CA (%d)\n"),
548                        pathlen);
549             rc = GNUPG_Bad_Certificate_Path;
550             goto leave;
551           }
552       }
553
554       if (opt.verbose)
555         log_info ("certificate is good\n");
556       
557       keydb_search_reset (kh);
558       subject_cert = issuer_cert;
559       issuer_cert = NULL;
560     }
561
562   if (opt.no_policy_check)
563     log_info ("policies not checked due to --disable-policy-checks option\n");
564   if (opt.no_crl_check)
565     log_info ("CRLs not checked due to --disable-crl-checks option\n");
566
567   if (!rc)
568     { /* If we encountered an error somewhere during the checks, set
569          the error code to the most critical one */
570       if (any_revoked)
571         rc = GNUPG_Certificate_Revoked;
572       else if (any_no_crl)
573         rc = GNUPG_No_CRL_Known;
574       else if (any_crl_too_old)
575         rc = GNUPG_CRL_Too_Old;
576       else if (any_no_policy_match)
577         rc = GNUPG_No_Policy_Match;
578       else if (any_expired)
579         rc = GNUPG_Certificate_Expired;
580     }
581   
582  leave:
583   if (r_exptime)
584     *r_exptime = exptime;
585   xfree (issuer);
586   keydb_release (kh); 
587   ksba_cert_release (issuer_cert);
588   if (subject_cert != cert)
589     ksba_cert_release (subject_cert);
590   return rc;
591 }
592
593
594 /* Check that the given certificate is valid but DO NOT check any
595    constraints.  We assume that the issuers certificate is already in
596    the DB and that this one is valid; which it should be because it
597    has been checked using this function. */
598 int
599 gpgsm_basic_cert_check (KsbaCert cert)
600 {
601   int rc = 0;
602   char *issuer = NULL;
603   char *subject = NULL;
604   KEYDB_HANDLE kh = keydb_new (0);
605   KsbaCert issuer_cert = NULL;
606
607   if ((opt.debug & 4096))
608     {
609       log_info ("WARNING: bypassing basic certificate checks\n");
610       return 0;
611     }
612
613   if (!kh)
614     {
615       log_error (_("failed to allocated keyDB handle\n"));
616       rc = GNUPG_General_Error;
617       goto leave;
618     }
619
620   issuer = ksba_cert_get_issuer (cert, 0);
621   subject = ksba_cert_get_subject (cert, 0);
622   if (!issuer)
623     {
624       log_error ("no issuer found in certificate\n");
625       rc = GNUPG_Bad_Certificate;
626       goto leave;
627     }
628
629   if (subject && !strcmp (issuer, subject))
630     {
631       if (gpgsm_check_cert_sig (cert, cert) )
632         {
633           log_error ("selfsigned certificate has a BAD signatures\n");
634           rc = GNUPG_Bad_Certificate;
635           goto leave;
636         }
637     }
638   else
639     {
640       /* find the next cert up the tree */
641       keydb_search_reset (kh);
642       rc = find_up (kh, cert, issuer);
643       if (rc)
644         {
645           if (rc == -1)
646             {
647               log_info ("issuer certificate (");
648               gpgsm_dump_string (issuer);
649               log_printf (") not found\n");
650             }
651           else
652             log_error ("failed to find issuer's certificate: rc=%d\n", rc);
653           rc = GNUPG_Missing_Certificate;
654           goto leave;
655         }
656       
657       ksba_cert_release (issuer_cert); issuer_cert = NULL;
658       rc = keydb_get_cert (kh, &issuer_cert);
659       if (rc)
660         {
661           log_error ("failed to get cert: rc=%d\n", rc);
662           rc = GNUPG_General_Error;
663           goto leave;
664         }
665
666       if (gpgsm_check_cert_sig (issuer_cert, cert) )
667         {
668           log_error ("certificate has a BAD signatures\n");
669           rc = GNUPG_Bad_Certificate;
670           goto leave;
671         }
672       if (opt.verbose)
673         log_info ("certificate is good\n");
674     }
675
676  leave:
677   xfree (issuer);
678   keydb_release (kh); 
679   ksba_cert_release (issuer_cert);
680   return rc;
681 }
682