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