Changed order of the confirmation questions for root certificates
[gnupg.git] / agent / trustlist.c
1 /* trustlist.c - Maintain the list of trusted keys
2  * Copyright (C) 2002, 2004, 2006, 2007, 2009 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 3 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, see <http://www.gnu.org/licenses/>.
18  */
19
20 #include <config.h>
21 #include <errno.h>
22 #include <stdio.h>
23 #include <stdlib.h>
24 #include <string.h>
25 #include <ctype.h>
26 #include <assert.h>
27 #include <unistd.h>
28 #include <sys/stat.h>
29 #include <pth.h>
30
31 #include "agent.h"
32 #include <assuan.h> /* fixme: need a way to avoid assuan calls here */
33 #include "i18n.h"
34
35
36 /* A structure to store the information from the trust file. */
37 struct trustitem_s
38 {
39   struct
40   {
41     int disabled:1;       /* This entry is disabled.  */
42     int for_pgp:1;        /* Set by '*' or 'P' as first flag. */
43     int for_smime:1;      /* Set by '*' or 'S' as first flag. */
44     int relax:1;          /* Relax checking of root certificate
45                              constraints. */
46     int cm:1;             /* Use chain model for validation. */
47   } flags;
48   unsigned char fpr[20];  /* The binary fingerprint. */
49 };
50 typedef struct trustitem_s trustitem_t;
51
52 /* Malloced table and its allocated size with all trust items. */
53 static trustitem_t *trusttable; 
54 static size_t trusttablesize; 
55 /* A mutex used to protect the table. */
56 static pth_mutex_t trusttable_lock;
57
58
59
60 static const char headerblurb[] =
61 "# This is the list of trusted keys.  Comment lines, like this one, as\n"
62 "# well as empty lines are ignored.  Lines have a length limit but this\n"
63 "# is not a serious limitation as the format of the entries is fixed and\n"
64 "# checked by gpg-agent.  A non-comment line starts with optional white\n"
65 "# space, followed by the SHA-1 fingerpint in hex, followed by a flag\n"
66 "# which may be one of 'P', 'S' or '*' and optionally followed by a list of\n"
67 "# other flags.  The fingerprint may be prefixed with a '!' to mark the\n"
68 "# key as not trusted.  You should give the gpg-agent a HUP or run the\n"
69 "# command \"gpgconf --reload gpg-agent\" after changing this file.\n"
70 "\n\n"
71 "# Include the default trust list\n"
72 "include-default\n"
73 "\n";
74
75
76 /* This function must be called once to initialize this module.  This
77    has to be done before a second thread is spawned.  We can't do the
78    static initialization because Pth emulation code might not be able
79    to do a static init; in particular, it is not possible for W32. */
80 void
81 initialize_module_trustlist (void)
82 {
83   static int initialized;
84
85   if (!initialized)
86     {
87       if (!pth_mutex_init (&trusttable_lock))
88         log_fatal ("error initializing mutex: %s\n", strerror (errno));
89       initialized = 1;
90     }
91 }
92
93
94
95 \f
96 static void
97 lock_trusttable (void)
98 {
99   if (!pth_mutex_acquire (&trusttable_lock, 0, NULL))
100     log_fatal ("failed to acquire mutex in %s\n", __FILE__);
101 }
102
103 static void
104 unlock_trusttable (void)
105 {
106   if (!pth_mutex_release (&trusttable_lock))
107     log_fatal ("failed to release mutex in %s\n", __FILE__);
108 }
109
110
111
112 static gpg_error_t
113 read_one_trustfile (const char *fname, int allow_include,
114                     trustitem_t **addr_of_table, 
115                     size_t *addr_of_tablesize,
116                     int *addr_of_tableidx)
117 {
118   gpg_error_t err = 0;
119   FILE *fp;
120   int n, c;
121   char *p, line[256];
122   trustitem_t *table, *ti;
123   int tableidx;
124   size_t tablesize;
125   int lnr = 0;
126   
127   table = *addr_of_table;
128   tablesize = *addr_of_tablesize;
129   tableidx = *addr_of_tableidx;
130
131   fp = fopen (fname, "r");
132   if (!fp)
133     {
134       err = gpg_error_from_syserror ();
135       log_error (_("error opening `%s': %s\n"), fname, gpg_strerror (err));
136       goto leave;
137     }
138
139   while (fgets (line, DIM(line)-1, fp))
140     {
141       lnr++;
142       
143       if (!*line || line[strlen(line)-1] != '\n')
144         {
145           /* Eat until end of line. */
146           while ( (c=getc (fp)) != EOF && c != '\n')
147             ;
148           err = gpg_error (*line? GPG_ERR_LINE_TOO_LONG
149                            : GPG_ERR_INCOMPLETE_LINE);
150           log_error (_("file `%s', line %d: %s\n"),
151                      fname, lnr, gpg_strerror (err));
152           continue;
153         }
154       line[strlen(line)-1] = 0; /* Chop the LF. */
155       
156       /* Allow for empty lines and spaces */
157       for (p=line; spacep (p); p++)
158         ;
159       if (!*p || *p == '#')
160         continue;
161   
162       if (!strncmp (p, "include-default", 15)
163           && (!p[15] || spacep (p+15)))
164         {
165           char *etcname;
166           gpg_error_t err2;
167
168           if (!allow_include)
169             {
170               log_error (_("statement \"%s\" ignored in `%s', line %d\n"),
171                          "include-default", fname, lnr);
172               continue;
173             }
174           /* fixme: Should check for trailing garbage.  */
175
176           etcname = make_filename (gnupg_sysconfdir (), "trustlist.txt", NULL);
177           if ( !strcmp (etcname, fname) ) /* Same file. */
178             log_info (_("statement \"%s\" ignored in `%s', line %d\n"),
179                       "include-default", fname, lnr);
180           else if ( access (etcname, F_OK) && errno == ENOENT )
181             {
182               /* A non existent system trustlist is not an error.
183                  Just print a note. */
184               log_info (_("system trustlist `%s' not available\n"), etcname);
185             }
186           else
187             {
188               err2 = read_one_trustfile (etcname, 0,
189                                          &table, &tablesize, &tableidx);
190               if (err2)
191                 err = err2;
192             }
193           xfree (etcname);
194           
195           continue;
196         }
197
198       if (tableidx == tablesize)  /* Need more space. */
199         {
200           trustitem_t *tmp;
201           size_t tmplen;
202           
203           tmplen = tablesize + 20;
204           tmp = xtryrealloc (table, tmplen * sizeof *table);
205           if (!tmp)
206             {
207               err = gpg_error_from_syserror ();
208               goto leave;
209             }
210           table = tmp;
211           tablesize = tmplen;
212         }
213
214       ti = table + tableidx;
215
216       memset (&ti->flags, 0, sizeof ti->flags);
217       if (*p == '!')
218         {
219           ti->flags.disabled = 1;
220           p++;
221           while (spacep (p))
222             p++;
223         }
224
225       n = hexcolon2bin (p, ti->fpr, 20);
226       if (n < 0)
227         {
228           log_error (_("bad fingerprint in `%s', line %d\n"), fname, lnr);
229           err = gpg_error (GPG_ERR_BAD_DATA); 
230           continue;
231         }
232       p += n;
233       for (; spacep (p); p++)
234         ;
235       
236       /* Process the first flag which needs to be the first for
237          backward compatibility. */
238       if (!*p || *p == '*' )
239         {
240           ti->flags.for_smime = 1;
241           ti->flags.for_pgp = 1;
242         }
243       else if ( *p == 'P' || *p == 'p')
244         {
245           ti->flags.for_pgp = 1;
246         }
247       else if ( *p == 'S' || *p == 's')
248         {
249           ti->flags.for_smime = 1;
250         }
251       else
252         {
253           log_error (_("invalid keyflag in `%s', line %d\n"), fname, lnr);
254           err = gpg_error (GPG_ERR_BAD_DATA);
255           continue;
256         }
257       p++;
258       if ( *p && !spacep (p) )
259         {
260           log_error (_("invalid keyflag in `%s', line %d\n"), fname, lnr);
261           err = gpg_error (GPG_ERR_BAD_DATA);
262           continue;
263         }
264
265       /* Now check for more key-value pairs of the form NAME[=VALUE]. */
266       while (*p)
267         {
268           for (; spacep (p); p++)
269             ;
270           if (!*p)
271             break;
272           n = strcspn (p, "= \t");
273           if (p[n] == '=')
274             {
275               log_error ("assigning a value to a flag is not yet supported; "
276                          "in `%s', line %d\n", fname, lnr);
277               err = gpg_error (GPG_ERR_BAD_DATA);
278               p++;
279             }
280           else if (n == 5 && !memcmp (p, "relax", 5))
281             ti->flags.relax = 1;
282           else if (n == 2 && !memcmp (p, "cm", 2))
283             ti->flags.cm = 1;
284           else
285             log_error ("flag `%.*s' in `%s', line %d ignored\n",
286                        n, p, fname, lnr);
287           p += n;
288         }
289       tableidx++;
290     }
291   if ( !err && !feof (fp) )
292     {
293       err = gpg_error_from_syserror ();
294       log_error (_("error reading `%s', line %d: %s\n"),
295                  fname, lnr, gpg_strerror (err));
296     }
297
298  leave:
299   if (fp)
300     fclose (fp);
301   *addr_of_table = table;
302   *addr_of_tablesize = tablesize;
303   *addr_of_tableidx = tableidx;
304   return err;
305 }
306
307
308 /* Read the trust files and update the global table on success.  */
309 static gpg_error_t
310 read_trustfiles (void)
311 {
312   gpg_error_t err;
313   trustitem_t *table, *ti;
314   int tableidx;
315   size_t tablesize;
316   char *fname;
317   int allow_include = 1;
318
319   tablesize = 20;
320   table = xtrycalloc (tablesize, sizeof *table);
321   if (!table)
322     return gpg_error_from_syserror ();
323   tableidx = 0;
324
325   fname = make_filename (opt.homedir, "trustlist.txt", NULL);
326   if ( access (fname, F_OK) )
327     {
328       if ( errno == ENOENT )
329         ; /* Silently ignore a non-existing trustfile.  */
330       else
331         {
332           err = gpg_error_from_syserror ();
333           log_error (_("error opening `%s': %s\n"), fname, gpg_strerror (err));
334         }
335       xfree (fname);
336       fname = make_filename (gnupg_sysconfdir (), "trustlist.txt", NULL);
337       allow_include = 0;
338     }
339   err = read_one_trustfile (fname, allow_include,
340                             &table, &tablesize, &tableidx);
341   xfree (fname);
342
343   if (err)
344     {
345       xfree (table);
346       if (gpg_err_code (err) == GPG_ERR_ENOENT)
347         {
348           /* Take a missing trustlist as an empty one.  */
349           lock_trusttable ();
350           xfree (trusttable);
351           trusttable = NULL;
352           trusttablesize = 0;
353           unlock_trusttable ();
354           err = 0;
355         }
356       return err;
357     }
358
359   /* Fixme: we should drop duplicates and sort the table. */
360   ti = xtryrealloc (table, (tableidx?tableidx:1) * sizeof *table);
361   if (!ti)
362     {
363       xfree (table);
364       return err;
365     }
366
367   lock_trusttable ();
368   xfree (trusttable);
369   trusttable = table;
370   trusttablesize = tableidx;
371   unlock_trusttable ();
372   return 0;
373 }
374
375
376
377 /* Check whether the given fpr is in our trustdb.  We expect FPR to be
378    an all uppercase hexstring of 40 characters. */
379 gpg_error_t 
380 agent_istrusted (ctrl_t ctrl, const char *fpr, int *r_disabled)
381 {
382   gpg_error_t err;
383   trustitem_t *ti;
384   size_t len;
385   unsigned char fprbin[20];
386
387   if (r_disabled)
388     *r_disabled = 0;
389
390   if ( hexcolon2bin (fpr, fprbin, 20) < 0 )
391     return gpg_error (GPG_ERR_INV_VALUE);
392
393   if (!trusttable)
394     {
395       err = read_trustfiles ();
396       if (err)
397         {
398           log_error (_("error reading list of trusted root certificates\n"));
399           return err;
400         }
401     }
402
403   if (trusttable)
404     {
405       for (ti=trusttable, len = trusttablesize; len; ti++, len--)
406         if (!memcmp (ti->fpr, fprbin, 20))
407           {
408             if (ti->flags.relax)
409               {
410                 err = agent_write_status (ctrl,
411                                           "TRUSTLISTFLAG", "relax", 
412                                           NULL);
413                 if (err)
414                   return err;
415               }
416             else if (ti->flags.cm)
417               {
418                 err = agent_write_status (ctrl,
419                                           "TRUSTLISTFLAG", "cm", 
420                                           NULL);
421                 if (err)
422                   return err;
423               }
424             if (ti->flags.disabled)
425               {
426                 if (r_disabled)
427                   *r_disabled = 1;
428                 return gpg_error (GPG_ERR_NOT_TRUSTED);
429               }
430             return 0; /* Trusted.  */
431           }
432     }
433   return gpg_error (GPG_ERR_NOT_TRUSTED);
434 }
435
436
437 /* Write all trust entries to FP. */
438 gpg_error_t 
439 agent_listtrusted (void *assuan_context)
440 {
441   trustitem_t *ti;
442   char key[51];
443   gpg_error_t err;
444   size_t len;
445
446   if (!trusttable)
447     {
448       err = read_trustfiles ();
449       if (err)
450         {
451           log_error (_("error reading list of trusted root certificates\n"));
452           return err;
453         }
454     }
455
456   if (trusttable)
457     {
458       /* We need to lock the table because the scheduler may interrupt
459          assuan_send_data and an other thread may then re-read the table. */
460       lock_trusttable ();
461       for (ti=trusttable, len = trusttablesize; len; ti++, len--)
462         {
463           if (ti->flags.disabled)
464             continue;
465           bin2hex (ti->fpr, 20, key);
466           key[40] = ' ';
467           key[41] = ((ti->flags.for_smime && ti->flags.for_pgp)? '*'
468                      : ti->flags.for_smime? 'S': ti->flags.for_pgp? 'P':' ');
469           key[42] = '\n';
470           assuan_send_data (assuan_context, key, 43);
471           assuan_send_data (assuan_context, NULL, 0); /* flush */
472         }
473       unlock_trusttable ();
474     }
475
476   return 0;
477 }
478
479
480 /* Create a copy of string with colons inserted after each two bytes.
481    Caller needs to release the string.  In case of a memory failure,
482    NULL is returned.  */
483 static char *
484 insert_colons (const char *string)
485 {
486   char *buffer, *p;
487   size_t n = strlen (string);
488   size_t nnew = n + (n+1)/2;
489
490   p = buffer = xtrymalloc ( nnew + 1 );
491   if (!buffer)
492     return NULL;
493   while (*string)
494     {
495       *p++ = *string++;
496       if (*string)
497         {
498           *p++ = *string++;
499           if (*string)
500             *p++ = ':';
501         }
502     }
503   *p = 0;
504   assert (strlen (buffer) <= nnew);
505
506   return buffer;
507 }
508
509
510 /* Insert the given fpr into our trustdb.  We expect FPR to be an all
511    uppercase hexstring of 40 characters. FLAG is either 'P' or 'C'.
512    This function does first check whether that key has already been put
513    into the trustdb and returns success in this case.  Before a FPR
514    actually gets inserted, the user is asked by means of the Pinentry
515    whether this is actual want he wants to do.  */
516 gpg_error_t
517 agent_marktrusted (ctrl_t ctrl, const char *name, const char *fpr, int flag)
518 {
519   gpg_error_t err = 0;
520   char *desc;
521   char *fname;
522   FILE *fp;
523   char *fprformatted;
524   int is_disabled;
525   int yes_i_trust;
526
527   /* Check whether we are at all allowed to modify the trustlist.
528      This is useful so that the trustlist may be a symlink to a global
529      trustlist with only admin priviliges to modify it.  Of course
530      this is not a secure way of denying access, but it avoids the
531      usual clicking on an Okay button most users are used to. */
532   fname = make_filename (opt.homedir, "trustlist.txt", NULL);
533   if ( access (fname, W_OK) && errno != ENOENT)
534     {
535       xfree (fname);
536       return gpg_error (GPG_ERR_EPERM);
537     }    
538   xfree (fname);
539
540   if (!agent_istrusted (ctrl, fpr, &is_disabled))
541     {
542       return 0; /* We already got this fingerprint.  Silently return
543                    success. */
544     }
545   
546   /* This feature must explicitly been enabled. */
547   if (!opt.allow_mark_trusted)
548     return gpg_error (GPG_ERR_NOT_SUPPORTED);
549
550   if (is_disabled)
551     {
552       /* There is an disabled entry in the trustlist.  Return an error
553          so that the user won't be asked again for that one.  Changing
554          this flag with the integrated marktrusted feature is and will
555          not be made possible.  */
556       return gpg_error (GPG_ERR_NOT_TRUSTED);
557     }
558
559
560   /* Insert a new one. */
561
562   /* First a general question whether this is trusted.  */
563   desc = xtryasprintf (
564                 /* TRANSLATORS: This prompt is shown by the Pinentry
565                    and has one special property: A "%%0A" is used by
566                    Pinentry to insert a line break.  The double
567                    percent sign is actually needed because it is also
568                    a printf format string.  If you need to insert a
569                    plain % sign, you need to encode it as "%%25".  The
570                    "%s" gets replaced by the name as store in the
571                    certificate. */
572                 _("Do you ultimately trust%%0A"
573                   "  \"%s\"%%0A"
574                   "to correctly certify user certificates?"),
575                 name);
576   if (!desc)
577     return out_of_core ();
578   err = agent_get_confirmation (ctrl, desc, _("Yes"), _("No"));
579   xfree (desc);
580   if (!err)
581     yes_i_trust = 1;
582   else if (gpg_err_code (err) == GPG_ERR_NOT_CONFIRMED)
583     yes_i_trust = 0;
584   else
585     return err;
586
587
588   fprformatted = insert_colons (fpr);
589   if (!fprformatted)
590     return out_of_core ();
591
592   /* If the user trusts this certificate he has to verify the
593      fingerprint of course.  */
594   if (yes_i_trust)
595     {
596       desc = xtryasprintf 
597         (
598          /* TRANSLATORS: This prompt is shown by the Pinentry and has
599             one special property: A "%%0A" is used by Pinentry to
600             insert a line break.  The double percent sign is actually
601             needed because it is also a printf format string.  If you
602             need to insert a plain % sign, you need to encode it as
603             "%%25".  The second "%s" gets replaced by a hexdecimal
604             fingerprint string whereas the first one receives the name
605             as stored in the certificate. */
606          _("Please verify that the certificate identified as:%%0A"
607            "  \"%s\"%%0A"
608            "has the fingerprint:%%0A"
609            "  %s"), name, fprformatted);
610       if (!desc)
611         {
612           xfree (fprformatted);
613           return out_of_core ();
614         }
615       
616       /* TRANSLATORS: "Correct" is the label of a button and intended
617          to be hit if the fingerprint matches the one of the CA.  The
618          other button is "the default "Cancel" of the Pinentry. */
619       err = agent_get_confirmation (ctrl, desc, _("Correct"), _("Wrong"));
620       xfree (desc);
621       if (gpg_err_code (err) == GPG_ERR_NOT_CONFIRMED)
622         yes_i_trust = 0;
623       else if (err)
624         {
625           xfree (fprformatted);
626           return err;
627         }
628     }
629
630
631   /* Now check again to avoid duplicates.  We take the lock to make
632      sure that nobody else plays with our file.  Frankly we don't work
633      with the trusttable but using this lock is just fine for our
634      purpose.  */
635   lock_trusttable ();
636   {
637     int now_disabled;
638
639     if (!agent_istrusted (ctrl, fpr, &now_disabled) || now_disabled)
640       {
641         unlock_trusttable ();
642         xfree (fprformatted);
643         return now_disabled? gpg_error (GPG_ERR_NOT_TRUSTED) : 0; 
644       }
645   }
646
647
648   fname = make_filename (opt.homedir, "trustlist.txt", NULL);
649   if ( access (fname, F_OK) && errno == ENOENT)
650     {
651       fp = fopen (fname, "wx"); /* Warning: "x" is a GNU extension. */
652       if (!fp)
653         {
654           err = gpg_error_from_syserror ();
655           log_error ("can't create `%s': %s\n", fname, gpg_strerror (err));
656           xfree (fname);
657           unlock_trusttable ();
658           xfree (fprformatted);
659           return err;
660         }
661       fputs (headerblurb, fp);
662       fclose (fp);
663     }
664   fp = fopen (fname, "a+");
665   if (!fp)
666     {
667       err = gpg_error_from_syserror ();
668       log_error ("can't open `%s': %s\n", fname, gpg_strerror (err));
669       xfree (fname);
670       unlock_trusttable ();
671       xfree (fprformatted);
672       return err;
673     }
674
675   /* Append the key. */
676   fputs ("\n# ", fp);
677   print_sanitized_string (fp, name, 0);
678   fprintf (fp, "\n%s%s %c\n", yes_i_trust?"":"!", fprformatted, flag);
679   if (ferror (fp))
680     err = gpg_error_from_syserror ();
681   
682   if (fclose (fp))
683     err = gpg_error_from_syserror ();
684
685   if (!err)
686     agent_reload_trustlist ();
687   xfree (fname);
688   unlock_trusttable ();
689   xfree (fprformatted);
690   return err;
691 }
692
693
694 /* This function may be called to force reloading of the
695    trustlist.  */
696 void
697 agent_reload_trustlist (void)
698 {
699   /* All we need to do is to delete the trusttable.  At the next
700      access it will get re-read. */
701   lock_trusttable ();
702   xfree (trusttable);
703   trusttable = NULL;
704   trusttablesize = 0;
705   unlock_trusttable ();
706   bump_key_eventcounter ();
707 }