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