Merged jnlib into common.
[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       err = gpg_error_from_syserror ();
364       xfree (table);
365       return err;
366     }
367
368   lock_trusttable ();
369   xfree (trusttable);
370   trusttable = ti;
371   trusttablesize = tableidx;
372   unlock_trusttable ();
373   return 0;
374 }
375
376
377
378 /* Check whether the given fpr is in our trustdb.  We expect FPR to be
379    an all uppercase hexstring of 40 characters. */
380 gpg_error_t 
381 agent_istrusted (ctrl_t ctrl, const char *fpr, int *r_disabled)
382 {
383   gpg_error_t err;
384   trustitem_t *ti;
385   size_t len;
386   unsigned char fprbin[20];
387
388   if (r_disabled)
389     *r_disabled = 0;
390
391   if ( hexcolon2bin (fpr, fprbin, 20) < 0 )
392     return gpg_error (GPG_ERR_INV_VALUE);
393
394   if (!trusttable)
395     {
396       err = read_trustfiles ();
397       if (err)
398         {
399           log_error (_("error reading list of trusted root certificates\n"));
400           return err;
401         }
402     }
403
404   if (trusttable)
405     {
406       for (ti=trusttable, len = trusttablesize; len; ti++, len--)
407         if (!memcmp (ti->fpr, fprbin, 20))
408           {
409             if (ti->flags.disabled && r_disabled)
410               *r_disabled = 1;
411
412             if (ti->flags.relax)
413               {
414                 err = agent_write_status (ctrl,
415                                           "TRUSTLISTFLAG", "relax", 
416                                           NULL);
417                 if (err)
418                   return err;
419               }
420             else if (ti->flags.cm)
421               {
422                 err = agent_write_status (ctrl,
423                                           "TRUSTLISTFLAG", "cm", 
424                                           NULL);
425                 if (err)
426                   return err;
427               }
428             return ti->flags.disabled? gpg_error (GPG_ERR_NOT_TRUSTED) : 0;
429           }
430     }
431   return gpg_error (GPG_ERR_NOT_TRUSTED);
432 }
433
434
435 /* Write all trust entries to FP. */
436 gpg_error_t 
437 agent_listtrusted (void *assuan_context)
438 {
439   trustitem_t *ti;
440   char key[51];
441   gpg_error_t err;
442   size_t len;
443
444   if (!trusttable)
445     {
446       err = read_trustfiles ();
447       if (err)
448         {
449           log_error (_("error reading list of trusted root certificates\n"));
450           return err;
451         }
452     }
453
454   if (trusttable)
455     {
456       /* We need to lock the table because the scheduler may interrupt
457          assuan_send_data and an other thread may then re-read the table. */
458       lock_trusttable ();
459       for (ti=trusttable, len = trusttablesize; len; ti++, len--)
460         {
461           if (ti->flags.disabled)
462             continue;
463           bin2hex (ti->fpr, 20, key);
464           key[40] = ' ';
465           key[41] = ((ti->flags.for_smime && ti->flags.for_pgp)? '*'
466                      : ti->flags.for_smime? 'S': ti->flags.for_pgp? 'P':' ');
467           key[42] = '\n';
468           assuan_send_data (assuan_context, key, 43);
469           assuan_send_data (assuan_context, NULL, 0); /* flush */
470         }
471       unlock_trusttable ();
472     }
473
474   return 0;
475 }
476
477
478 /* Create a copy of string with colons inserted after each two bytes.
479    Caller needs to release the string.  In case of a memory failure,
480    NULL is returned.  */
481 static char *
482 insert_colons (const char *string)
483 {
484   char *buffer, *p;
485   size_t n = strlen (string);
486   size_t nnew = n + (n+1)/2;
487
488   p = buffer = xtrymalloc ( nnew + 1 );
489   if (!buffer)
490     return NULL;
491   while (*string)
492     {
493       *p++ = *string++;
494       if (*string)
495         {
496           *p++ = *string++;
497           if (*string)
498             *p++ = ':';
499         }
500     }
501   *p = 0;
502   assert (strlen (buffer) <= nnew);
503
504   return buffer;
505 }
506
507
508 /* To pretty print DNs in the Pinentry, we replace slashes by
509    REPLSTRING.  The caller needs to free the returned string.  NULL is
510    returned on error with ERRNO set.  */
511 static char *
512 reformat_name (const char *name, const char *replstring)
513 {
514   const char *s;
515   char *newname;
516   char *d;
517   size_t count;
518   size_t replstringlen = strlen (replstring);
519
520   /* If the name does not start with a slash it is not a preformatted
521      DN and thus we don't bother to reformat it.  */
522   if (*name != '/')
523     return xtrystrdup (name);
524
525   /* Count the names.  Note that a slash contained in a DN part is
526      expected to be C style escaped and thus the slashes we see here
527      are the actual part delimiters.  */
528   for (s=name+1, count=0; *s; s++)
529     if (*s == '/')
530       count++;
531   newname = xtrymalloc (strlen (name) + count*replstringlen + 1);
532   if (!newname)
533     return NULL; 
534   for (s=name+1, d=newname; *s; s++)
535     if (*s == '/')
536       d = stpcpy (d, replstring);
537     else
538       *d++ = *s;
539   *d = 0;
540   return newname;
541 }
542
543
544 /* Insert the given fpr into our trustdb.  We expect FPR to be an all
545    uppercase hexstring of 40 characters. FLAG is either 'P' or 'C'.
546    This function does first check whether that key has already been put
547    into the trustdb and returns success in this case.  Before a FPR
548    actually gets inserted, the user is asked by means of the Pinentry
549    whether this is actual want he wants to do.  */
550 gpg_error_t
551 agent_marktrusted (ctrl_t ctrl, const char *name, const char *fpr, int flag)
552 {
553   gpg_error_t err = 0;
554   char *desc;
555   char *fname;
556   estream_t fp;
557   char *fprformatted;
558   char *nameformatted;
559   int is_disabled;
560   int yes_i_trust;
561
562   /* Check whether we are at all allowed to modify the trustlist.
563      This is useful so that the trustlist may be a symlink to a global
564      trustlist with only admin priviliges to modify it.  Of course
565      this is not a secure way of denying access, but it avoids the
566      usual clicking on an Okay button most users are used to. */
567   fname = make_filename (opt.homedir, "trustlist.txt", NULL);
568   if ( access (fname, W_OK) && errno != ENOENT)
569     {
570       xfree (fname);
571       return gpg_error (GPG_ERR_EPERM);
572     }    
573   xfree (fname);
574
575   if (!agent_istrusted (ctrl, fpr, &is_disabled))
576     {
577       return 0; /* We already got this fingerprint.  Silently return
578                    success. */
579     }
580   
581   /* This feature must explicitly been enabled. */
582   if (!opt.allow_mark_trusted)
583     return gpg_error (GPG_ERR_NOT_SUPPORTED);
584
585   if (is_disabled)
586     {
587       /* There is an disabled entry in the trustlist.  Return an error
588          so that the user won't be asked again for that one.  Changing
589          this flag with the integrated marktrusted feature is and will
590          not be made possible.  */
591       return gpg_error (GPG_ERR_NOT_TRUSTED);
592     }
593
594
595   /* Insert a new one. */
596   nameformatted = reformat_name (name, "%0A   ");
597   if (!nameformatted)
598     return gpg_error_from_syserror ();
599
600   /* First a general question whether this is trusted.  */
601   desc = xtryasprintf (
602                 /* TRANSLATORS: This prompt is shown by the Pinentry
603                    and has one special property: A "%%0A" is used by
604                    Pinentry to insert a line break.  The double
605                    percent sign is actually needed because it is also
606                    a printf format string.  If you need to insert a
607                    plain % sign, you need to encode it as "%%25".  The
608                    "%s" gets replaced by the name as stored in the
609                    certificate. */
610                 _("Do you ultimately trust%%0A"
611                   "  \"%s\"%%0A"
612                   "to correctly certify user certificates?"),
613                 nameformatted);
614   if (!desc)
615     {
616       xfree (nameformatted);
617       return out_of_core ();
618     }
619   err = agent_get_confirmation (ctrl, desc, _("Yes"), _("No"), 1);
620   xfree (desc);
621   if (!err)
622     yes_i_trust = 1;
623   else if (gpg_err_code (err) == GPG_ERR_NOT_CONFIRMED)
624     yes_i_trust = 0;
625   else
626     {
627       xfree (nameformatted);
628       return err;
629     }
630     
631
632   fprformatted = insert_colons (fpr);
633   if (!fprformatted)
634     {
635       xfree (nameformatted);
636       return out_of_core ();
637     }
638
639   /* If the user trusts this certificate he has to verify the
640      fingerprint of course.  */
641   if (yes_i_trust)
642     {
643       desc = xtryasprintf 
644         (
645          /* TRANSLATORS: This prompt is shown by the Pinentry and has
646             one special property: A "%%0A" is used by Pinentry to
647             insert a line break.  The double percent sign is actually
648             needed because it is also a printf format string.  If you
649             need to insert a plain % sign, you need to encode it as
650             "%%25".  The second "%s" gets replaced by a hexdecimal
651             fingerprint string whereas the first one receives the name
652             as stored in the certificate. */
653          _("Please verify that the certificate identified as:%%0A"
654            "  \"%s\"%%0A"
655            "has the fingerprint:%%0A"
656            "  %s"), nameformatted, fprformatted);
657       if (!desc)
658         {
659           xfree (fprformatted);
660           xfree (nameformatted);
661           return out_of_core ();
662         }
663       
664       /* TRANSLATORS: "Correct" is the label of a button and intended
665          to be hit if the fingerprint matches the one of the CA.  The
666          other button is "the default "Cancel" of the Pinentry. */
667       err = agent_get_confirmation (ctrl, desc, _("Correct"), _("Wrong"), 1);
668       xfree (desc);
669       if (gpg_err_code (err) == GPG_ERR_NOT_CONFIRMED)
670         yes_i_trust = 0;
671       else if (err)
672         {
673           xfree (fprformatted);
674           xfree (nameformatted);
675           return err;
676         }
677     }
678
679
680   /* Now check again to avoid duplicates.  We take the lock to make
681      sure that nobody else plays with our file and force a reread.  */
682   lock_trusttable ();
683   agent_reload_trustlist ();
684   if (!agent_istrusted (ctrl, fpr, &is_disabled) || is_disabled)
685     {
686       unlock_trusttable ();
687       xfree (fprformatted);
688       xfree (nameformatted);
689       return is_disabled? gpg_error (GPG_ERR_NOT_TRUSTED) : 0; 
690     }
691
692   fname = make_filename (opt.homedir, "trustlist.txt", NULL);
693   if ( access (fname, F_OK) && errno == ENOENT)
694     {
695       fp = es_fopen (fname, "wx");
696       if (!fp)
697         {
698           err = gpg_error_from_syserror ();
699           log_error ("can't create `%s': %s\n", fname, gpg_strerror (err));
700           xfree (fname);
701           unlock_trusttable ();
702           xfree (fprformatted);
703           xfree (nameformatted);
704           return err;
705         }
706       es_fputs (headerblurb, fp);
707       es_fclose (fp);
708     }
709   fp = es_fopen (fname, "a+");
710   if (!fp)
711     {
712       err = gpg_error_from_syserror ();
713       log_error ("can't open `%s': %s\n", fname, gpg_strerror (err));
714       xfree (fname);
715       unlock_trusttable ();
716       xfree (fprformatted);
717       xfree (nameformatted);
718       return err;
719     }
720
721   /* Append the key. */
722   es_fputs ("\n# ", fp);
723   xfree (nameformatted);
724   nameformatted = reformat_name (name, "\n# ");
725   if (!nameformatted || strchr (name, '\n'))
726     {
727       /* Note that there should never be a LF in NAME but we better
728          play safe and print a sanitized version in this case.  */
729       es_write_sanitized (fp, name, strlen (name), NULL, NULL);
730     }
731   else
732     es_fputs (nameformatted, fp);
733   es_fprintf (fp, "\n%s%s %c\n", yes_i_trust?"":"!", fprformatted, flag);
734   if (es_ferror (fp))
735     err = gpg_error_from_syserror ();
736   
737   if (es_fclose (fp))
738     err = gpg_error_from_syserror ();
739
740   agent_reload_trustlist ();
741   xfree (fname);
742   unlock_trusttable ();
743   xfree (fprformatted);
744   xfree (nameformatted);
745   return err;
746 }
747
748
749 /* This function may be called to force reloading of the
750    trustlist.  */
751 void
752 agent_reload_trustlist (void)
753 {
754   /* All we need to do is to delete the trusttable.  At the next
755      access it will get re-read. */
756   lock_trusttable ();
757   xfree (trusttable);
758   trusttable = NULL;
759   trusttablesize = 0;
760   unlock_trusttable ();
761   bump_key_eventcounter ();
762 }