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