Port to npth.
[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 <npth.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 npth_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   int err;
85
86   if (!initialized)
87     {
88       err = npth_mutex_init (&trusttable_lock, NULL);
89       if (err)
90         log_fatal ("error initializing mutex: %s\n", strerror (err));
91       initialized = 1;
92     }
93 }
94
95
96
97 \f
98 static void
99 lock_trusttable (void)
100 {
101   int err;
102
103   err = npth_mutex_lock (&trusttable_lock);
104   if (err)
105     log_fatal ("failed to acquire mutex in %s: %s\n", __FILE__, strerror (err));
106 }
107
108 static void
109 unlock_trusttable (void)
110 {
111   int err;
112
113   err = npth_mutex_unlock (&trusttable_lock);
114   if (err)
115     log_fatal ("failed to release mutex in %s: %s\n", __FILE__, strerror (err));
116 }
117
118
119
120 static gpg_error_t
121 read_one_trustfile (const char *fname, int allow_include,
122                     trustitem_t **addr_of_table,
123                     size_t *addr_of_tablesize,
124                     int *addr_of_tableidx)
125 {
126   gpg_error_t err = 0;
127   estream_t fp;
128   int n, c;
129   char *p, line[256];
130   trustitem_t *table, *ti;
131   int tableidx;
132   size_t tablesize;
133   int lnr = 0;
134
135   table = *addr_of_table;
136   tablesize = *addr_of_tablesize;
137   tableidx = *addr_of_tableidx;
138
139   fp = es_fopen (fname, "r");
140   if (!fp)
141     {
142       err = gpg_error_from_syserror ();
143       log_error (_("error opening `%s': %s\n"), fname, gpg_strerror (err));
144       goto leave;
145     }
146
147   while (es_fgets (line, DIM(line)-1, fp))
148     {
149       lnr++;
150
151       n = strlen (line);
152       if (!n || line[n-1] != '\n')
153         {
154           /* Eat until end of line. */
155           while ( (c=es_getc (fp)) != EOF && c != '\n')
156             ;
157           err = gpg_error (*line? GPG_ERR_LINE_TOO_LONG
158                            : GPG_ERR_INCOMPLETE_LINE);
159           log_error (_("file `%s', line %d: %s\n"),
160                      fname, lnr, gpg_strerror (err));
161           continue;
162         }
163       line[--n] = 0; /* Chop the LF. */
164       if (n && line[n-1] == '\r')
165         line[--n] = 0; /* Chop an optional CR. */
166
167       /* Allow for empty lines and spaces */
168       for (p=line; spacep (p); p++)
169         ;
170       if (!*p || *p == '#')
171         continue;
172
173       if (!strncmp (p, "include-default", 15)
174           && (!p[15] || spacep (p+15)))
175         {
176           char *etcname;
177           gpg_error_t err2;
178
179           if (!allow_include)
180             {
181               log_error (_("statement \"%s\" ignored in `%s', line %d\n"),
182                          "include-default", fname, lnr);
183               continue;
184             }
185           /* fixme: Should check for trailing garbage.  */
186
187           etcname = make_filename (gnupg_sysconfdir (), "trustlist.txt", NULL);
188           if ( !strcmp (etcname, fname) ) /* Same file. */
189             log_info (_("statement \"%s\" ignored in `%s', line %d\n"),
190                       "include-default", fname, lnr);
191           else if ( access (etcname, F_OK) && errno == ENOENT )
192             {
193               /* A non existent system trustlist is not an error.
194                  Just print a note. */
195               log_info (_("system trustlist `%s' not available\n"), etcname);
196             }
197           else
198             {
199               err2 = read_one_trustfile (etcname, 0,
200                                          &table, &tablesize, &tableidx);
201               if (err2)
202                 err = err2;
203             }
204           xfree (etcname);
205
206           continue;
207         }
208
209       if (tableidx == tablesize)  /* Need more space. */
210         {
211           trustitem_t *tmp;
212           size_t tmplen;
213
214           tmplen = tablesize + 20;
215           tmp = xtryrealloc (table, tmplen * sizeof *table);
216           if (!tmp)
217             {
218               err = gpg_error_from_syserror ();
219               goto leave;
220             }
221           table = tmp;
222           tablesize = tmplen;
223         }
224
225       ti = table + tableidx;
226
227       memset (&ti->flags, 0, sizeof ti->flags);
228       if (*p == '!')
229         {
230           ti->flags.disabled = 1;
231           p++;
232           while (spacep (p))
233             p++;
234         }
235
236       n = hexcolon2bin (p, ti->fpr, 20);
237       if (n < 0)
238         {
239           log_error (_("bad fingerprint in `%s', line %d\n"), fname, lnr);
240           err = gpg_error (GPG_ERR_BAD_DATA);
241           continue;
242         }
243       p += n;
244       for (; spacep (p); p++)
245         ;
246
247       /* Process the first flag which needs to be the first for
248          backward compatibility. */
249       if (!*p || *p == '*' )
250         {
251           ti->flags.for_smime = 1;
252           ti->flags.for_pgp = 1;
253         }
254       else if ( *p == 'P' || *p == 'p')
255         {
256           ti->flags.for_pgp = 1;
257         }
258       else if ( *p == 'S' || *p == 's')
259         {
260           ti->flags.for_smime = 1;
261         }
262       else
263         {
264           log_error (_("invalid keyflag in `%s', line %d\n"), fname, lnr);
265           err = gpg_error (GPG_ERR_BAD_DATA);
266           continue;
267         }
268       p++;
269       if ( *p && !spacep (p) )
270         {
271           log_error (_("invalid keyflag in `%s', line %d\n"), fname, lnr);
272           err = gpg_error (GPG_ERR_BAD_DATA);
273           continue;
274         }
275
276       /* Now check for more key-value pairs of the form NAME[=VALUE]. */
277       while (*p)
278         {
279           for (; spacep (p); p++)
280             ;
281           if (!*p)
282             break;
283           n = strcspn (p, "= \t");
284           if (p[n] == '=')
285             {
286               log_error ("assigning a value to a flag is not yet supported; "
287                          "in `%s', line %d\n", fname, lnr);
288               err = gpg_error (GPG_ERR_BAD_DATA);
289               p++;
290             }
291           else if (n == 5 && !memcmp (p, "relax", 5))
292             ti->flags.relax = 1;
293           else if (n == 2 && !memcmp (p, "cm", 2))
294             ti->flags.cm = 1;
295           else
296             log_error ("flag `%.*s' in `%s', line %d ignored\n",
297                        n, p, fname, lnr);
298           p += n;
299         }
300       tableidx++;
301     }
302   if ( !err && !es_feof (fp) )
303     {
304       err = gpg_error_from_syserror ();
305       log_error (_("error reading `%s', line %d: %s\n"),
306                  fname, lnr, gpg_strerror (err));
307     }
308
309  leave:
310   es_fclose (fp);
311   *addr_of_table = table;
312   *addr_of_tablesize = tablesize;
313   *addr_of_tableidx = tableidx;
314   return err;
315 }
316
317
318 /* Read the trust files and update the global table on success.  */
319 static gpg_error_t
320 read_trustfiles (void)
321 {
322   gpg_error_t err;
323   trustitem_t *table, *ti;
324   int tableidx;
325   size_t tablesize;
326   char *fname;
327   int allow_include = 1;
328
329   tablesize = 20;
330   table = xtrycalloc (tablesize, sizeof *table);
331   if (!table)
332     return gpg_error_from_syserror ();
333   tableidx = 0;
334
335   fname = make_filename (opt.homedir, "trustlist.txt", NULL);
336   if ( access (fname, F_OK) )
337     {
338       if ( errno == ENOENT )
339         ; /* Silently ignore a non-existing trustfile.  */
340       else
341         {
342           err = gpg_error_from_syserror ();
343           log_error (_("error opening `%s': %s\n"), fname, gpg_strerror (err));
344         }
345       xfree (fname);
346       fname = make_filename (gnupg_sysconfdir (), "trustlist.txt", NULL);
347       allow_include = 0;
348     }
349   err = read_one_trustfile (fname, allow_include,
350                             &table, &tablesize, &tableidx);
351   xfree (fname);
352
353   if (err)
354     {
355       xfree (table);
356       if (gpg_err_code (err) == GPG_ERR_ENOENT)
357         {
358           /* Take a missing trustlist as an empty one.  */
359           lock_trusttable ();
360           xfree (trusttable);
361           trusttable = NULL;
362           trusttablesize = 0;
363           unlock_trusttable ();
364           err = 0;
365         }
366       return err;
367     }
368
369   /* Fixme: we should drop duplicates and sort the table. */
370   ti = xtryrealloc (table, (tableidx?tableidx:1) * sizeof *table);
371   if (!ti)
372     {
373       err = gpg_error_from_syserror ();
374       xfree (table);
375       return err;
376     }
377
378   lock_trusttable ();
379   xfree (trusttable);
380   trusttable = ti;
381   trusttablesize = tableidx;
382   unlock_trusttable ();
383   return 0;
384 }
385
386
387
388 /* Check whether the given fpr is in our trustdb.  We expect FPR to be
389    an all uppercase hexstring of 40 characters. */
390 gpg_error_t
391 agent_istrusted (ctrl_t ctrl, const char *fpr, int *r_disabled)
392 {
393   gpg_error_t err;
394   trustitem_t *ti;
395   size_t len;
396   unsigned char fprbin[20];
397
398   if (r_disabled)
399     *r_disabled = 0;
400
401   if ( hexcolon2bin (fpr, fprbin, 20) < 0 )
402     return gpg_error (GPG_ERR_INV_VALUE);
403
404   if (!trusttable)
405     {
406       err = read_trustfiles ();
407       if (err)
408         {
409           log_error (_("error reading list of trusted root certificates\n"));
410           return err;
411         }
412     }
413
414   if (trusttable)
415     {
416       for (ti=trusttable, len = trusttablesize; len; ti++, len--)
417         if (!memcmp (ti->fpr, fprbin, 20))
418           {
419             if (ti->flags.disabled && r_disabled)
420               *r_disabled = 1;
421
422             if (ti->flags.relax)
423               {
424                 err = agent_write_status (ctrl,
425                                           "TRUSTLISTFLAG", "relax",
426                                           NULL);
427                 if (err)
428                   return err;
429               }
430             else if (ti->flags.cm)
431               {
432                 err = agent_write_status (ctrl,
433                                           "TRUSTLISTFLAG", "cm",
434                                           NULL);
435                 if (err)
436                   return err;
437               }
438             return ti->flags.disabled? gpg_error (GPG_ERR_NOT_TRUSTED) : 0;
439           }
440     }
441   return gpg_error (GPG_ERR_NOT_TRUSTED);
442 }
443
444
445 /* Write all trust entries to FP. */
446 gpg_error_t
447 agent_listtrusted (void *assuan_context)
448 {
449   trustitem_t *ti;
450   char key[51];
451   gpg_error_t err;
452   size_t len;
453
454   if (!trusttable)
455     {
456       err = read_trustfiles ();
457       if (err)
458         {
459           log_error (_("error reading list of trusted root certificates\n"));
460           return err;
461         }
462     }
463
464   if (trusttable)
465     {
466       /* We need to lock the table because the scheduler may interrupt
467          assuan_send_data and an other thread may then re-read the table. */
468       lock_trusttable ();
469       for (ti=trusttable, len = trusttablesize; len; ti++, len--)
470         {
471           if (ti->flags.disabled)
472             continue;
473           bin2hex (ti->fpr, 20, key);
474           key[40] = ' ';
475           key[41] = ((ti->flags.for_smime && ti->flags.for_pgp)? '*'
476                      : ti->flags.for_smime? 'S': ti->flags.for_pgp? 'P':' ');
477           key[42] = '\n';
478           assuan_send_data (assuan_context, key, 43);
479           assuan_send_data (assuan_context, NULL, 0); /* flush */
480         }
481       unlock_trusttable ();
482     }
483
484   return 0;
485 }
486
487
488 /* Create a copy of string with colons inserted after each two bytes.
489    Caller needs to release the string.  In case of a memory failure,
490    NULL is returned.  */
491 static char *
492 insert_colons (const char *string)
493 {
494   char *buffer, *p;
495   size_t n = strlen (string);
496   size_t nnew = n + (n+1)/2;
497
498   p = buffer = xtrymalloc ( nnew + 1 );
499   if (!buffer)
500     return NULL;
501   while (*string)
502     {
503       *p++ = *string++;
504       if (*string)
505         {
506           *p++ = *string++;
507           if (*string)
508             *p++ = ':';
509         }
510     }
511   *p = 0;
512   assert (strlen (buffer) <= nnew);
513
514   return buffer;
515 }
516
517
518 /* To pretty print DNs in the Pinentry, we replace slashes by
519    REPLSTRING.  The caller needs to free the returned string.  NULL is
520    returned on error with ERRNO set.  */
521 static char *
522 reformat_name (const char *name, const char *replstring)
523 {
524   const char *s;
525   char *newname;
526   char *d;
527   size_t count;
528   size_t replstringlen = strlen (replstring);
529
530   /* If the name does not start with a slash it is not a preformatted
531      DN and thus we don't bother to reformat it.  */
532   if (*name != '/')
533     return xtrystrdup (name);
534
535   /* Count the names.  Note that a slash contained in a DN part is
536      expected to be C style escaped and thus the slashes we see here
537      are the actual part delimiters.  */
538   for (s=name+1, count=0; *s; s++)
539     if (*s == '/')
540       count++;
541   newname = xtrymalloc (strlen (name) + count*replstringlen + 1);
542   if (!newname)
543     return NULL;
544   for (s=name+1, d=newname; *s; s++)
545     if (*s == '/')
546       d = stpcpy (d, replstring);
547     else
548       *d++ = *s;
549   *d = 0;
550   return newname;
551 }
552
553
554 /* Insert the given fpr into our trustdb.  We expect FPR to be an all
555    uppercase hexstring of 40 characters. FLAG is either 'P' or 'C'.
556    This function does first check whether that key has already been put
557    into the trustdb and returns success in this case.  Before a FPR
558    actually gets inserted, the user is asked by means of the Pinentry
559    whether this is actual want he wants to do.  */
560 gpg_error_t
561 agent_marktrusted (ctrl_t ctrl, const char *name, const char *fpr, int flag)
562 {
563   gpg_error_t err = 0;
564   char *desc;
565   char *fname;
566   estream_t fp;
567   char *fprformatted;
568   char *nameformatted;
569   int is_disabled;
570   int yes_i_trust;
571
572   /* Check whether we are at all allowed to modify the trustlist.
573      This is useful so that the trustlist may be a symlink to a global
574      trustlist with only admin priviliges to modify it.  Of course
575      this is not a secure way of denying access, but it avoids the
576      usual clicking on an Okay button most users are used to. */
577   fname = make_filename (opt.homedir, "trustlist.txt", NULL);
578   if ( access (fname, W_OK) && errno != ENOENT)
579     {
580       xfree (fname);
581       return gpg_error (GPG_ERR_EPERM);
582     }
583   xfree (fname);
584
585   if (!agent_istrusted (ctrl, fpr, &is_disabled))
586     {
587       return 0; /* We already got this fingerprint.  Silently return
588                    success. */
589     }
590
591   /* This feature must explicitly been enabled. */
592   if (!opt.allow_mark_trusted)
593     return gpg_error (GPG_ERR_NOT_SUPPORTED);
594
595   if (is_disabled)
596     {
597       /* There is an disabled entry in the trustlist.  Return an error
598          so that the user won't be asked again for that one.  Changing
599          this flag with the integrated marktrusted feature is and will
600          not be made possible.  */
601       return gpg_error (GPG_ERR_NOT_TRUSTED);
602     }
603
604
605   /* Insert a new one. */
606   nameformatted = reformat_name (name, "%0A   ");
607   if (!nameformatted)
608     return gpg_error_from_syserror ();
609
610   /* First a general question whether this is trusted.  */
611   desc = xtryasprintf (
612                 /* TRANSLATORS: This prompt is shown by the Pinentry
613                    and has one special property: A "%%0A" is used by
614                    Pinentry to insert a line break.  The double
615                    percent sign is actually needed because it is also
616                    a printf format string.  If you need to insert a
617                    plain % sign, you need to encode it as "%%25".  The
618                    "%s" gets replaced by the name as stored in the
619                    certificate. */
620                 _("Do you ultimately trust%%0A"
621                   "  \"%s\"%%0A"
622                   "to correctly certify user certificates?"),
623                 nameformatted);
624   if (!desc)
625     {
626       xfree (nameformatted);
627       return out_of_core ();
628     }
629   err = agent_get_confirmation (ctrl, desc, _("Yes"), _("No"), 1);
630   xfree (desc);
631   if (!err)
632     yes_i_trust = 1;
633   else if (gpg_err_code (err) == GPG_ERR_NOT_CONFIRMED)
634     yes_i_trust = 0;
635   else
636     {
637       xfree (nameformatted);
638       return err;
639     }
640
641
642   fprformatted = insert_colons (fpr);
643   if (!fprformatted)
644     {
645       xfree (nameformatted);
646       return out_of_core ();
647     }
648
649   /* If the user trusts this certificate he has to verify the
650      fingerprint of course.  */
651   if (yes_i_trust)
652     {
653       desc = xtryasprintf
654         (
655          /* TRANSLATORS: This prompt is shown by the Pinentry and has
656             one special property: A "%%0A" is used by Pinentry to
657             insert a line break.  The double percent sign is actually
658             needed because it is also a printf format string.  If you
659             need to insert a plain % sign, you need to encode it as
660             "%%25".  The second "%s" gets replaced by a hexdecimal
661             fingerprint string whereas the first one receives the name
662             as stored in the certificate. */
663          _("Please verify that the certificate identified as:%%0A"
664            "  \"%s\"%%0A"
665            "has the fingerprint:%%0A"
666            "  %s"), nameformatted, fprformatted);
667       if (!desc)
668         {
669           xfree (fprformatted);
670           xfree (nameformatted);
671           return out_of_core ();
672         }
673
674       /* TRANSLATORS: "Correct" is the label of a button and intended
675          to be hit if the fingerprint matches the one of the CA.  The
676          other button is "the default "Cancel" of the Pinentry. */
677       err = agent_get_confirmation (ctrl, desc, _("Correct"), _("Wrong"), 1);
678       xfree (desc);
679       if (gpg_err_code (err) == GPG_ERR_NOT_CONFIRMED)
680         yes_i_trust = 0;
681       else if (err)
682         {
683           xfree (fprformatted);
684           xfree (nameformatted);
685           return err;
686         }
687     }
688
689
690   /* Now check again to avoid duplicates.  We take the lock to make
691      sure that nobody else plays with our file and force a reread.  */
692   lock_trusttable ();
693   agent_reload_trustlist ();
694   if (!agent_istrusted (ctrl, fpr, &is_disabled) || is_disabled)
695     {
696       unlock_trusttable ();
697       xfree (fprformatted);
698       xfree (nameformatted);
699       return is_disabled? gpg_error (GPG_ERR_NOT_TRUSTED) : 0;
700     }
701
702   fname = make_filename (opt.homedir, "trustlist.txt", NULL);
703   if ( access (fname, F_OK) && errno == ENOENT)
704     {
705       fp = es_fopen (fname, "wx,mode=-rw-r");
706       if (!fp)
707         {
708           err = gpg_error_from_syserror ();
709           log_error ("can't create `%s': %s\n", fname, gpg_strerror (err));
710           xfree (fname);
711           unlock_trusttable ();
712           xfree (fprformatted);
713           xfree (nameformatted);
714           return err;
715         }
716       es_fputs (headerblurb, fp);
717       es_fclose (fp);
718     }
719   fp = es_fopen (fname, "a+,mode=-rw-r");
720   if (!fp)
721     {
722       err = gpg_error_from_syserror ();
723       log_error ("can't open `%s': %s\n", fname, gpg_strerror (err));
724       xfree (fname);
725       unlock_trusttable ();
726       xfree (fprformatted);
727       xfree (nameformatted);
728       return err;
729     }
730
731   /* Append the key. */
732   es_fputs ("\n# ", fp);
733   xfree (nameformatted);
734   nameformatted = reformat_name (name, "\n# ");
735   if (!nameformatted || strchr (name, '\n'))
736     {
737       /* Note that there should never be a LF in NAME but we better
738          play safe and print a sanitized version in this case.  */
739       es_write_sanitized (fp, name, strlen (name), NULL, NULL);
740     }
741   else
742     es_fputs (nameformatted, fp);
743   es_fprintf (fp, "\n%s%s %c\n", yes_i_trust?"":"!", fprformatted, flag);
744   if (es_ferror (fp))
745     err = gpg_error_from_syserror ();
746
747   if (es_fclose (fp))
748     err = gpg_error_from_syserror ();
749
750   agent_reload_trustlist ();
751   xfree (fname);
752   unlock_trusttable ();
753   xfree (fprformatted);
754   xfree (nameformatted);
755   return err;
756 }
757
758
759 /* This function may be called to force reloading of the
760    trustlist.  */
761 void
762 agent_reload_trustlist (void)
763 {
764   /* All we need to do is to delete the trusttable.  At the next
765      access it will get re-read. */
766   lock_trusttable ();
767   xfree (trusttable);
768   trusttable = NULL;
769   trusttablesize = 0;
770   unlock_trusttable ();
771   bump_key_eventcounter ();
772 }