g10: Add TOFU support.
[gnupg.git] / g10 / tofu.c
1 /* tofu.c - TOFU trust model.
2  * Copyright (C) 2015 g10 Code GmbH
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 /* TODO:
21
22    - Format the fingerprints nicely when printing (similar to gpg
23      --list-keys)
24  */
25
26 #include <config.h>
27 #include <stdio.h>
28 #include <sys/stat.h>
29 #include <assert.h>
30 #include <sqlite3.h>
31
32 #include "gpg.h"
33 #include "types.h"
34 #include "logging.h"
35 #include "stringhelp.h"
36 #include "options.h"
37 #include "mbox-util.h"
38 #include "i18n.h"
39 #include "trustdb.h"
40 #include "mkdir_p.h"
41
42 #include "tofu.h"
43
44 /* The TOFU data can be saved in two different formats: either in a
45    single combined database (opt.tofu_db_format == TOFU_DB_FLAT) or in
46    a split file format (opt.tofu_db_format == TOFU_DB_SPLIT).  In the
47    split format, there is one database per normalized email address
48    (DB_EMAIL) and one per key (DB_KEY).  */
49 enum db_type
50   {
51     DB_COMBINED,
52     DB_EMAIL,
53     DB_KEY
54   };
55
56 /* A list of open DBs.
57
58    In the flat format, this consists of a single element with the type
59    DB_COMBINED and whose name is the empty string.
60
61    In the split format, the first element is a dummy element (DB is
62    NULL) whose type is DB_COMBINED and whose name is the empty string.
63    Any following elements describe either DB_EMAIL or DB_KEY DBs.  In
64    theis case, NAME is either the normalized email address or the
65    fingerprint.
66
67    To initialize this data structure, call opendbs().  When you are
68    done, clean it up using closedbs().  To get a handle to a database,
69    use the getdb() function.  This will either return an existing
70    handle or open a new DB connection, as appropriate.  */
71 struct db
72 {
73   struct db *next;
74
75   enum db_type type;
76
77   sqlite3 *db;
78
79   /* If TYPE is DB_COMBINED, this is "".  Otherwise, it is either the
80      fingerprint (type == DB_KEY) or the normalized email address
81      (type == DB_EMAIL).  */
82   char name[1];
83 };
84
85 const char *
86 tofu_policy_str (enum tofu_policy policy)
87 {
88   switch (policy)
89     {
90     case TOFU_POLICY_NONE: return "none";
91     case TOFU_POLICY_AUTO: return "auto";
92     case TOFU_POLICY_GOOD: return "good";
93     case TOFU_POLICY_UNKNOWN: return "unknown";
94     case TOFU_POLICY_BAD: return "bad";
95     case TOFU_POLICY_ASK: return "ask";
96     default: return "???";
97     }
98 }
99
100 /* Convert a binding policy (e.g., TOFU_POLICY_BAD) to a trust level
101    (e.g., TRUST_BAD) in light of the current configuration.  */
102 int
103 tofu_policy_to_trust_level (enum tofu_policy policy)
104 {
105   if (policy == TOFU_POLICY_AUTO)
106     /* If POLICY is AUTO, fallback to OPT.TOFU_DEFAULT_POLICY.  */
107     policy = opt.tofu_default_policy;
108
109   switch (policy)
110     {
111     case TOFU_POLICY_AUTO:
112       /* If POLICY and OPT.TOFU_DEFAULT_POLICY are both AUTO, default
113          to marginal trust.  */
114       return TRUST_MARGINAL;
115     case TOFU_POLICY_GOOD:
116       return TRUST_FULLY;
117     case TOFU_POLICY_UNKNOWN:
118       return TRUST_UNKNOWN;
119     case TOFU_POLICY_BAD:
120       return TRUST_NEVER;
121     case TOFU_POLICY_ASK:
122       return TRUST_UNKNOWN;
123     default:
124       log_bug ("Bad value for trust policy: %d\n",
125                opt.tofu_default_policy);
126       return 0;
127     }
128 }
129
130 /* This is a convenience function that combines sqlite3_mprintf and
131    sqlite3_exec.  */
132 static int
133 sqlite3_exec_printf (sqlite3 *db,
134                      int (*callback)(void*,int,char**,char**), void *cookie,
135                      char **errmsg,
136                      const char *sql, ...)
137 {
138   va_list ap;
139   int rc;
140   char *sql2;
141
142   va_start (ap, sql);
143   sql2 = sqlite3_vmprintf (sql, ap);
144   va_end (ap);
145
146 #if 0
147   log_debug ("tofo db: executing: '%s'\n", sql2);
148 #endif
149
150   rc = sqlite3_exec (db, sql2, callback, cookie, errmsg);
151
152   sqlite3_free (sql2);
153
154   return rc;
155 }
156
157
158 /* Collect results of a select count (*) ...; style query.  Aborts if
159    the argument is not a valid integer (or real of the form X.0).  */
160 static int
161 get_single_unsigned_long_cb (void *cookie, int argc, char **argv,
162                              char **azColName)
163 {
164   unsigned long int *count = cookie;
165   char *tail = NULL;
166
167   (void) azColName;
168
169   assert (argc == 1);
170
171   errno = 0;
172   *count = strtoul (argv[0], &tail, 0);
173   if (errno || ! (strcmp (tail, ".0") == 0 || *tail == '\0'))
174     /* Abort.  */
175     return 1;
176   return 0;
177 }
178
179 /* We expect a single integer column whose name is "version".  COOKIE
180    must point to an int.  This function always aborts.  On error or a
181    if the version is bad, sets *VERSION to -1.  */
182 static int
183 version_check_cb (void *cookie, int argc, char **argv, char **azColName)
184 {
185   int *version = cookie;
186
187   if (argc != 1 || strcmp (azColName[0], "version") != 0)
188     {
189       *version = -1;
190       return 1;
191     }
192
193   if (strcmp (argv[0], "1") == 0)
194     *version = 1;
195   else
196     {
197       log_error (_("unsupported TOFU DB version: %s\n"), argv[0]);
198       *version = -1;
199     }
200
201   /* Don't run again.  */
202   return 1;
203 }
204
205
206 /* If the DB is new, initialize it.  Otherwise, check the DB's
207    version.
208
209    Return 0 if the database is okay and 1 otherwise.  */
210 static int
211 initdb (sqlite3 *db, enum db_type type)
212 {
213   char *err = NULL;
214   int rc;
215   unsigned long int count;
216   int version = -1;
217
218   /* If the DB has no tables, then assume this is a new DB that needs
219      to be initialized.  */
220   rc = sqlite3_exec (db,
221                      "select count(*) from sqlite_master where type='table';",
222                      get_single_unsigned_long_cb, &count, &err);
223   if (rc)
224     {
225       log_error (_("error querying TOFU DB's available tables: %s\n"),
226                  err);
227       sqlite3_free (err);
228       return 1;
229     }
230   else if (count != 0)
231     /* Assume that the DB is already initialized.  Make sure the
232        version is okay.  */
233     {
234       rc = sqlite3_exec (db, "select version from version;", version_check_cb,
235                          &version, &err);
236       if (rc == SQLITE_ABORT && version == 1)
237         /* Happy, happy, joy, joy.  */
238         {
239           sqlite3_free (err);
240           return 0;
241         }
242       else if (rc == SQLITE_ABORT && version == -1)
243         /* Unsupported version.  */
244         {
245           /* An error message was already displayed.  */
246           sqlite3_free (err);
247           return 1;
248         }
249       else if (rc)
250         /* Some error.  */
251         {
252           log_error (_("error determining TOFU DB's version: %s\n"), err);
253           sqlite3_free (err);
254           return 1;
255         }
256       else
257         /* Unexpected success.  This can only happen if there are no
258            rows.  */
259         {
260           log_error (_("error determining TOFU DB's version: %s\n"),
261                      "select returned 0, but expected ABORT");
262           return 1;
263         }
264     }
265
266   rc = sqlite3_exec (db, "begin transaction;", NULL, NULL, &err);
267   if (rc)
268     {
269       log_error (_("error beginning transaction on TOFU database: %s\n"),
270                  err);
271       sqlite3_free (err);
272       return 1;
273     }
274
275   /* Create the version table.  */
276   rc = sqlite3_exec (db,
277                      "create table version (version INTEGER);",
278                      NULL, NULL, &err);
279   if (rc)
280     {
281       log_error (_("error initializing TOFU database (%s): %s\n"),
282                  "version", err);
283       sqlite3_free (err);
284       goto out;
285     }
286
287   /* Initialize the version table, which contains a single integer
288      value.  */
289   rc = sqlite3_exec (db,
290                      "insert into version values (1);",
291                      NULL, NULL, &err);
292   if (rc)
293     {
294       log_error (_("error initializing TOFU database (%s): %s\n"),
295                  "version, init", err);
296       sqlite3_free (err);
297       goto out;
298     }
299
300   /* The list of <fingerprint, email> bindings and auxiliary data.
301
302        OID is a unique ID identifying this binding (and used by the
303          signatures table, see below).  Note: OIDs will never be
304          reused.
305
306        FINGERPRINT: The key's fingerprint.
307
308        EMAIL: The normalized email address.
309
310        USER_ID: The unmodified user id from which EMAIL was extracted.
311
312        TIME: The time this binding was first observed.
313
314        POLICY: The trust policy (-1, 0, 1, or 2; see the
315          documentation for TOFU_POLICY_BAD, etc. above).
316
317        CONFLICT is either NULL or a fingerprint.  Assume that we have
318          a binding <0xdeadbeef, foo@example.com> and then we observe
319          <0xbaddecaf, foo@example.com>.  There two bindings conflict
320          (they have the same email address).  When we observe the
321          latter binding, we warn the user about the conflict and ask
322          for a policy decision about the new binding.  We also change
323          the old binding's policy to ask if it was auto.  So that we
324          know why this occured, we also set conflict to 0xbaddecaf.
325   */
326   if (type == DB_EMAIL || type == DB_COMBINED)
327     rc = sqlite3_exec_printf
328       (db, NULL, NULL, &err,
329        "create table bindings\n"
330        " (oid INTEGER PRIMARY KEY AUTOINCREMENT,\n"
331        "  fingerprint TEXT, email TEXT, user_id TEXT, time INTEGER,\n"
332        "  policy BOOLEAN CHECK (policy in (%d, %d, %d, %d, %d)),\n"
333        "  conflict STRING,\n"
334        "  unique (fingerprint, email));\n"
335        "create index bindings_fingerprint_email\n"
336        " on bindings (fingerprint, email);\n"
337        "create index bindings_email on bindings (email);\n",
338        TOFU_POLICY_AUTO, TOFU_POLICY_GOOD, TOFU_POLICY_UNKNOWN,
339        TOFU_POLICY_BAD, TOFU_POLICY_ASK);
340   else
341     /* In the split DB case, the fingerprint DB only contains a subset
342        of the fields.  This reduces the amount of duplicated data.
343
344        Note: since the data is split on the email address, there is no
345        need to index the email column.  */
346     rc = sqlite3_exec_printf
347       (db, NULL, NULL, &err,
348        "create table bindings\n"
349        " (oid INTEGER PRIMARY KEY AUTOINCREMENT,\n"
350        "  fingerprint TEXT, email TEXT, user_id,\n"
351        "  unique (fingerprint, email));\n"
352        "create index bindings_fingerprint\n"
353        " on bindings (fingerprint);\n");
354   if (rc)
355     {
356       log_error (_("error initializing TOFU database (%s): %s\n"),
357                  "bindings", err);
358       sqlite3_free (err);
359       goto out;
360     }
361
362   if (type != DB_KEY)
363     {
364       /* The signatures that we have observed.
365
366          BINDING refers to a record in the bindings table, which
367          describes the binding (i.e., this is a foreign key that
368          references bindings.oid).
369
370          SIG_DIGEST is the digest stored in the signature.
371
372          SIG_TIME is the timestamp stored in the signature.
373
374          ORIGIN is a free-form string that describes who fed this
375          signature to GnuPG (e.g., email:claws).
376
377          TIME is the time this signature was registered.  */
378       rc = sqlite3_exec (db,
379                          "create table signatures "
380                          " (binding INTEGER NOT NULL, sig_digest TEXT,"
381                          "  origin TEXT, sig_time INTEGER, time INTEGER,"
382                          "  primary key (binding, sig_digest, origin));",
383                          NULL, NULL, &err);
384       if (rc)
385         {
386           log_error (_("error initializing TOFU database (%s): %s\n"),
387                      "signatures", err);
388           sqlite3_free (err);
389           goto out;
390         }
391     }
392
393  out:
394   if (rc)
395     {
396       rc = sqlite3_exec (db, "rollback;", NULL, NULL, &err);
397       if (rc)
398         {
399           log_error (_("error aborting transaction on TOFU DB: %s\n"),
400                      err);
401           sqlite3_free (err);
402         }
403       return 1;
404     }
405   else
406     {
407       rc = sqlite3_exec (db, "commit transaction;", NULL, NULL, &err);
408       if (rc)
409         {
410           log_error (_("error committing transaction on TOFU DB: %s\n"),
411                      err);
412           sqlite3_free (err);
413           return 1;
414         }
415       return 0;
416     }
417 }
418
419 static sqlite3 *combined_db;
420
421 /* Open and initialize a low-level TOFU database.  Returns NULL on
422    failure.  This function should not normally be directly called to
423    get a database handle.  Instead, use getdb().  */
424 static sqlite3 *
425 opendb (char *filename, enum db_type type)
426 {
427   sqlite3 *db;
428   int filename_free = 0;
429   int rc;
430
431   if (opt.tofu_db_format == TOFU_DB_FLAT)
432     {
433       assert (! filename);
434       assert (type == DB_COMBINED);
435
436       if (combined_db)
437         return combined_db;
438
439       filename = make_filename (opt.homedir, "tofu.db", NULL);
440       filename_free = 1;
441     }
442   else
443     assert (type == DB_EMAIL || type == DB_KEY);
444
445   assert (filename);
446
447   rc = sqlite3_open (filename, &db);
448   if (rc)
449     {
450       log_error (_("can't open TOFU DB ('%s'): %s\n"),
451                  filename, sqlite3_errmsg (db));
452       /* Even if an error occurs, DB is guaranteed to be valid.  */
453       sqlite3_close (db);
454       db = NULL;
455     }
456
457   if (filename_free)
458     xfree (filename);
459
460   if (db && initdb (db, type))
461     {
462       sqlite3_close (db);
463       db = NULL;
464     }
465
466   if (opt.tofu_db_format == TOFU_DB_FLAT)
467     combined_db = db;
468
469   return db;
470 }
471
472 /* Return a database handle.  <type, name> describes the required
473    database.  If there is a cached handle in DBS, that handle is
474    returned.  Otherwise, the database is opened and cached in DBS.
475
476    NAME is the name of the DB and may not be NULL.
477
478    TYPE must be either DB_MAIL or DB_KEY.  In the combined format, the
479    combined DB is always returned.  */
480 static sqlite3 *
481 getdb (struct db *dbs, const char *name, enum db_type type)
482 {
483   struct db *t = NULL;
484   sqlite3 *sqlitedb = NULL;
485   char *name_sanitized = NULL;
486   char *filename = NULL;
487   int i;
488
489   assert (name);
490   assert (type == DB_EMAIL || type == DB_KEY);
491
492   assert (dbs);
493   /* The first entry is always for the combined DB.  */
494   assert (dbs->type == DB_COMBINED);
495   assert (! dbs->name[0]);
496
497   if (opt.tofu_db_format == TOFU_DB_FLAT)
498     /* When using the flat format, we only have a single combined
499        DB.  */
500     {
501       assert (dbs->db);
502       assert (! dbs->next);
503       return dbs->db;
504     }
505   else
506     /* When using the split format the first entry on the DB list is a
507        dummy entry.  */
508     assert (! dbs->db);
509
510   /* We have the split format.  */
511
512   /* Only allow alpha-numeric characters in the filename.  */
513   name_sanitized = xstrdup (name);
514   for (i = 0; name[i]; i ++)
515     {
516       char c = name_sanitized[i];
517       if (! (('a' <= c && c <= 'z')
518              || ('A' <= c && c <= 'Z')
519              || ('0' <= c && c <= '9')))
520         name_sanitized[i] = '_';
521     }
522
523   /* See if the DB is cached.  */
524   for (t = dbs->next; t; t = t->next)
525     if (type == t->type && strcmp (t->name, name_sanitized) == 0)
526       goto out;
527
528   /* Open the DB.  The filename has the form:
529
530        tofu.d/TYPE/PREFIX/NAME.db
531
532      We use a short prefix to try to avoid having many files in a
533      single directory.  */
534   {
535     char *type_str = type == DB_EMAIL ? "email" : "key";
536     char prefix[3] = { name_sanitized[0], name_sanitized[1], 0 };
537     char *name_db;
538
539     /* Make the directory.  */
540     if (gnupg_mkdir_p (opt.homedir, "tofu.d", type_str, prefix, NULL) != 0)
541       {
542         log_error (_("unable to create directory %s/%s/%s/%s"),
543                    opt.homedir, "tofu.d", type_str, prefix);
544         g10_exit (1);
545       }
546
547     name_db = xstrconcat (name_sanitized, ".db", NULL);
548     filename = make_filename
549       (opt.homedir, "tofu.d", type_str, prefix, name_db, NULL);
550     xfree (name_db);
551   }
552
553   sqlitedb = opendb (filename, type);
554   if (! sqlitedb)
555     goto out;
556
557   t = xmalloc (sizeof (struct db) + strlen (name_sanitized));
558   t->type = type;
559   t->db = sqlitedb;
560   strcpy (t->name, name_sanitized);
561
562   /* Insert it immediately after the first element.  */
563   t->next = dbs->next;
564   dbs->next = t;
565
566  out:
567   xfree (filename);
568   xfree (name_sanitized);
569
570   if (! t)
571     return NULL;
572   return t->db;
573 }
574
575
576 /* Create a new DB meta-handle.  Returns NULL on error.  */
577 static struct db *
578 opendbs (void)
579 {
580   sqlite3 *db = NULL;
581   struct db *dbs;
582
583   if (opt.tofu_db_format == TOFU_DB_AUTO)
584     {
585       char *filename = make_filename (opt.homedir, "tofu.db", NULL);
586       struct stat s;
587       int have_tofu_db = 0;
588       int have_tofu_d = 0;
589
590       if (stat (filename, &s) == 0)
591         {
592           have_tofu_db = 1;
593           if (DBG_TRUST)
594             log_debug ("%s exists.\n", filename);
595         }
596       else
597         {
598           if (DBG_TRUST)
599             log_debug ("%s does not exist.\n", filename);
600         }
601
602       /* We now have tofu.d.  */
603       filename[strlen (filename) - 1] = '\0';
604       if (stat (filename, &s) == 0)
605         {
606           have_tofu_d = 1;
607           if (DBG_TRUST)
608             log_debug ("%s exists.\n", filename);
609         }
610       else
611         {
612           if (DBG_TRUST)
613             log_debug ("%s does not exist.\n", filename);
614         }
615
616       xfree (filename);
617
618       if (have_tofu_db && have_tofu_d)
619         {
620           log_info (_("Warning: Home directory contains both tofu.db and tofu.d.  Using split format for TOFU DB.\n"));
621           opt.tofu_db_format = TOFU_DB_SPLIT;
622         }
623       else if (have_tofu_db)
624         {
625           opt.tofu_db_format = TOFU_DB_FLAT;
626           if (DBG_TRUST)
627             log_debug ("Using flat format for TOFU DB.\n");
628         }
629       else if (have_tofu_d)
630         {
631           opt.tofu_db_format = TOFU_DB_SPLIT;
632           if (DBG_TRUST)
633             log_debug ("Using split format for TOFU DB.\n");
634         }
635       else
636         {
637           opt.tofu_db_format = TOFU_DB_SPLIT;
638           if (DBG_TRUST)
639             log_debug ("Using split format for TOFU DB.\n");
640         }
641     }
642
643   if (opt.tofu_db_format == TOFU_DB_FLAT)
644     {
645       db = opendb (NULL, DB_COMBINED);
646       if (! db)
647         return NULL;
648     }
649   else
650     /* Create a dummy entry so that we have a handle.  */
651     ;
652
653   dbs = xmalloc_clear (sizeof (*dbs));
654   dbs->db = db;
655   dbs->type = DB_COMBINED;
656
657   return dbs;
658 }
659
660 /* Release all of the resources associated with a DB meta-handle.  */
661 static void
662 closedbs (struct db *dbs)
663 {
664   struct db *db;
665   struct db *n;
666
667   /* The first entry is always the combined DB.  */
668   assert (dbs->type == DB_COMBINED);
669   if (opt.tofu_db_format == TOFU_DB_FLAT)
670     {
671       /* If we are using the flat format, then there is only ever the
672          combined DB.  */
673       assert (! dbs->next);
674       assert (dbs->db);
675       assert (dbs->db == combined_db);
676     }
677   else
678     /* In the split format, the combined record is just a place holder
679        so that we have a stable handle.  */
680     assert (! dbs->db);
681
682   for (db = dbs; db; db = n)
683     {
684       n = db->next;
685
686       if (combined_db && db->db == combined_db)
687         {
688           assert (opt.tofu_db_format == TOFU_DB_FLAT);
689           assert (dbs == db);
690           assert (db->type == DB_COMBINED);
691           assert (! db->name[0]);
692         }
693       else if (db->db)
694         /* Not the dummy entry.  */
695         {
696           if (dbs == db)
697             /* The first entry.  */
698             {
699               assert (opt.tofu_db_format == TOFU_DB_FLAT);
700               assert (db->type == DB_COMBINED);
701               assert (! db->name[0]);
702             }
703           else
704             /* Not the first entry.  */
705             {
706               assert (opt.tofu_db_format == TOFU_DB_SPLIT);
707               assert (db->type != DB_COMBINED);
708               assert (db->name[0]);
709             }
710
711           sqlite3_close (db->db);
712         }
713       else
714         /* The dummy entry.  */
715         {
716           assert (opt.tofu_db_format == TOFU_DB_SPLIT);
717           assert (dbs == db);
718           assert (db->type == DB_COMBINED);
719           assert (! db->name[0]);
720         }
721
722       xfree (db);
723     }
724 }
725
726
727 /* Collect results of a select min (foo) ...; style query.  Aborts if
728    the argument is not a valid integer (or real of the form X.0).  */
729 static int
730 get_single_long_cb (void *cookie, int argc, char **argv, char **azColName)
731 {
732   long *count = cookie;
733   char *tail = NULL;
734
735   (void) azColName;
736
737   assert (argc == 1);
738
739   errno = 0;
740   *count = strtol (argv[0], &tail, 0);
741   if (errno || ! (strcmp (tail, ".0") == 0 || *tail == '\0'))
742     /* Abort.  */
743     return 1;
744   return 0;
745 }
746
747
748 /* Record (or update) a trust policy about a (possibly new)
749    binding.
750
751    If SHOW_OLD is set, the binding's old policy is displayed.  */
752 static gpg_error_t
753 record_binding (struct db *dbs, const char *fingerprint, const char *email,
754                 const char *user_id, enum tofu_policy policy, int show_old)
755 {
756   sqlite3 *db_email = NULL, *db_key = NULL;
757   int rc;
758   char *err = NULL;
759   enum tofu_policy policy_old = TOFU_POLICY_NONE;
760
761   if (! (policy == TOFU_POLICY_AUTO
762          || policy == TOFU_POLICY_GOOD
763          || policy == TOFU_POLICY_UNKNOWN
764          || policy == TOFU_POLICY_BAD
765          || policy == TOFU_POLICY_ASK))
766     log_bug ("%s: Bad value for policy (%d)!\n", __func__, policy);
767
768   db_email = getdb (dbs, email, DB_EMAIL);
769   if (! db_email)
770     return gpg_error (GPG_ERR_GENERAL);
771
772   if (opt.tofu_db_format == TOFU_DB_SPLIT)
773     /* In the split format, we need to update two DBs.  To keep them
774        consistent, we start a transaction on each.  Note: this is the
775        only place where we start two transaction and we always start
776        transaction on the DB_KEY DB first, thus deadlock is not
777        possible.  */
778     {
779       db_key = getdb (dbs, fingerprint, DB_KEY);
780       if (! db_key)
781         return gpg_error (GPG_ERR_GENERAL);
782
783       rc = sqlite3_exec (db_email, "begin transaction;", NULL, NULL, &err);
784       if (rc)
785         {
786           log_error (_("error beginning transaction on TOFU %s database: %s\n"),
787                      "email", err);
788           sqlite3_free (err);
789           return gpg_error (GPG_ERR_GENERAL);
790         }
791
792       rc = sqlite3_exec (db_key, "begin transaction;", NULL, NULL, &err);
793       if (rc)
794         {
795           log_error (_("error beginning transaction on TOFU %s database: %s\n"),
796                      "key", err);
797           sqlite3_free (err);
798           goto out_revert_one;
799         }
800     }
801
802   if (show_old)
803     /* Get the old policy.  Since this is just for informational
804        purposes, there is no need to start a transaction or to die if
805        there is a failure.  */
806     {
807       rc = sqlite3_exec_printf
808         (db_email, get_single_long_cb, &policy_old, &err,
809          "select policy from bindings where fingerprint = %Q and email = %Q",
810          fingerprint, email);
811       if (rc)
812         {
813           log_debug ("TOFU: Error reading from binding database"
814                      " (reading policy for <%s, %s>): %s\n",
815                      fingerprint, email, err);
816           sqlite3_free (err);
817         }
818     }
819
820   if (DBG_TRUST)
821     {
822       if (policy_old != TOFU_POLICY_NONE)
823         log_debug ("Changing TOFU trust policy for binding <%s, %s>"
824                    " from %s to %s.\n",
825                    fingerprint, email,
826                    tofu_policy_str (policy_old),
827                    tofu_policy_str (policy));
828       else
829         log_debug ("Set TOFU trust policy for binding <%s, %s> to %s.\n",
830                    fingerprint, email,
831                    tofu_policy_str (policy));
832     }
833
834   if (policy_old == policy)
835     /* Nothing to do.  */
836     goto out;
837
838   rc = sqlite3_exec_printf
839     (db_email, NULL, NULL, &err,
840      "insert or replace into bindings\n"
841      " (oid, fingerprint, email, user_id, time, policy)\n"
842      " values (\n"
843      /* If we don't explicitly reuse the OID, then SQLite will
844         reallocate a new one.  We just need to search for the OID
845         based on the fingerprint and email since they are unique.  */
846      "  (select oid from bindings where fingerprint = %Q and email = %Q),\n"
847      "  %Q, %Q, %Q, strftime('%%s','now'), %d);",
848      fingerprint, email, fingerprint, email, user_id, policy);
849   if (rc)
850     {
851       log_error (_("error updating TOFU binding database"
852                    " (inserting <%s, %s> = %s): %s\n"),
853                  fingerprint, email, tofu_policy_str (policy),
854                  err);
855       sqlite3_free (err);
856       goto out;
857     }
858
859   if (db_key)
860     /* We also need to update the key DB.  */
861     {
862       assert (opt.tofu_db_format == TOFU_DB_SPLIT);
863
864       rc = sqlite3_exec_printf
865         (db_key, NULL, NULL, &err,
866          "insert or replace into bindings\n"
867          " (oid, fingerprint, email, user_id)\n"
868          " values (\n"
869          /* If we don't explicitly reuse the OID, then SQLite will
870             reallocate a new one.  We just need to search for the OID
871             based on the fingerprint and email since they are unique.  */
872          "  (select oid from bindings where fingerprint = %Q and email = %Q),\n"
873          "  %Q, %Q, %Q);",
874          fingerprint, email, fingerprint, email, user_id);
875       if (rc)
876         {
877           log_error (_("error updating TOFU binding database"
878                        " (inserting <%s, %s>): %s\n"),
879                      fingerprint, email, err);
880           sqlite3_free (err);
881           goto out;
882         }
883     }
884   else
885     assert (opt.tofu_db_format == TOFU_DB_FLAT);
886
887  out:
888   if (opt.tofu_db_format == TOFU_DB_SPLIT)
889     /* We only need a transaction for the split format.  */
890     {
891       int rc2;
892
893       rc2 = sqlite3_exec_printf (db_key, NULL, NULL, &err,
894                                  rc ? "rollback;" : "end transaction;");
895       if (rc2)
896         {
897           log_error (_("error ending transaction on TOFU database: %s\n"),
898                      err);
899           sqlite3_free (err);
900         }
901
902     out_revert_one:
903       rc2 = sqlite3_exec_printf (db_email, NULL, NULL, &err,
904                                  rc ? "rollback;" : "end transaction;");
905       if (rc2)
906         {
907           log_error (_("error ending transaction on TOFU database: %s\n"),
908                      err);
909           sqlite3_free (err);
910         }
911     }
912
913   if (rc)
914     return gpg_error (GPG_ERR_GENERAL);
915   return 0;
916 }
917
918
919 /* Collect the strings returned by a query in a simply string list.
920    Any NULL values are converted to the empty string.
921
922    If a result has 3 rows and each row contains two columns, then the
923    results are added to the list as follows (the value is parentheses
924    is the 1-based index in the final list):
925
926      row 1, col 2 (6)
927      row 1, col 1 (5)
928      row 2, col 2 (4)
929      row 2, col 1 (3)
930      row 3, col 2 (2)
931      row 3, col 1 (1)
932
933    This is because add_to_strlist pushes the results onto the front of
934    the list.  The end result is that the rows are backwards, but the
935    columns are in the expected order.  */
936 static int
937 strings_collect_cb (void *cookie, int argc, char **argv, char **azColName)
938 {
939   int i;
940   strlist_t *strlist = cookie;
941
942   (void) azColName;
943
944   for (i = argc - 1; i >= 0; i --)
945     add_to_strlist (strlist, argv[i] ? argv[i] : "");
946
947   return 0;
948 }
949
950 /* Auxiliary data structure to collect statistics about
951    signatures.  */
952 struct signature_stats
953 {
954   struct signature_stats *next;
955
956   /* The user-assigned policy for this binding.  */
957   enum tofu_policy policy;
958
959   /* How long ago the signature was created (rounded to a multiple of
960      TIME_AGO_UNIT_SMALL, etc.).  */
961   long time_ago;
962   /* Number of signatures during this time.  */
963   unsigned long count;
964
965   /* The key that generated this signature.  */
966   char fingerprint[1];
967 };
968
969 static void
970 signature_stats_free (struct signature_stats *stats)
971 {
972   while (stats)
973     {
974       struct signature_stats *next = stats->next;
975       xfree (stats);
976       stats = next;
977     }
978 }
979
980 static void
981 signature_stats_prepend (struct signature_stats **statsp,
982                          const char *fingerprint,
983                          enum tofu_policy policy,
984                          long time_ago,
985                          unsigned long count)
986 {
987   struct signature_stats *stats =
988     xmalloc (sizeof (*stats) + strlen (fingerprint));
989
990   stats->next = *statsp;
991   *statsp = stats;
992
993   strcpy (stats->fingerprint, fingerprint);
994   stats->policy = policy;
995   stats->time_ago = time_ago;
996   stats->count = count;
997 }
998
999
1000 /* Process rows that contain the four columns:
1001
1002      <fingerprint, policy, time ago, count>.  */
1003 static int
1004 signature_stats_collect_cb (void *cookie, int argc, char **argv,
1005                             char **azColName)
1006 {
1007   struct signature_stats **statsp = cookie;
1008   char *tail;
1009   int i = 0;
1010   enum tofu_policy policy;
1011   long time_ago;
1012   unsigned long count;
1013
1014   (void) azColName;
1015
1016   i ++;
1017
1018   tail = NULL;
1019   errno = 0;
1020   policy = strtol (argv[i], &tail, 0);
1021   if (errno || ! (strcmp (tail, ".0") == 0 || *tail == '\0'))
1022     {
1023       /* Abort.  */
1024       log_error ("%s: Error converting %s to an integer (tail = '%s')\n",
1025                  __func__, argv[i], tail);
1026       return 1;
1027     }
1028   i ++;
1029
1030   tail = NULL;
1031   errno = 0;
1032   time_ago = strtol (argv[i], &tail, 0);
1033   if (errno || ! (strcmp (tail, ".0") == 0 || *tail == '\0'))
1034     {
1035       /* Abort.  */
1036       log_error ("%s: Error converting %s to an integer (tail = '%s')\n",
1037                  __func__, argv[i], tail);
1038       return 1;
1039     }
1040   i ++;
1041
1042   tail = NULL;
1043   errno = 0;
1044   count = strtoul (argv[i], &tail, 0);
1045   if (errno || ! (strcmp (tail, ".0") == 0 || *tail == '\0'))
1046     {
1047       /* Abort.  */
1048       log_error ("%s: Error converting %s to an integer (tail = '%s')\n",
1049                  __func__, argv[i], tail);
1050       return 1;
1051     }
1052   i ++;
1053
1054   assert (argc == i);
1055
1056   signature_stats_prepend (statsp, argv[0], policy, time_ago, count);
1057
1058   return 0;
1059 }
1060
1061 /* The grouping parameters when collecting signature statistics.  */
1062
1063 /* If a message is signed a couple of hours in the future, just assume
1064    some clock skew.  */
1065 #define TIME_AGO_FUTURE_IGNORE (2 * 60 * 60)
1066 #if 0
1067 #  define TIME_AGO_UNIT_SMALL 60
1068 #  define TIME_AGO_UNIT_SMALL_NAME _("minute")
1069 #  define TIME_AGO_UNIT_SMALL_NAME_PLURAL _("minutes")
1070 #  define TIME_AGO_MEDIUM_THRESHOLD (60 * TIME_AGO_UNIT_SMALL)
1071 #  define TIME_AGO_UNIT_MEDIUM (60 * 60)
1072 #  define TIME_AGO_UNIT_MEDIUM_NAME _("hour")
1073 #  define TIME_AGO_UNIT_MEDIUM_NAME_PLURAL _("hours")
1074 #  define TIME_AGO_LARGE_THRESHOLD (24 * 60 * TIME_AGO_UNIT_SMALL)
1075 #  define TIME_AGO_UNIT_LARGE (24 * 60 * 60)
1076 #  define TIME_AGO_UNIT_LARGE_NAME _("day")
1077 #  define TIME_AGO_UNIT_LARGE_NAME_PLURAL _("days")
1078 #else
1079 #  define TIME_AGO_UNIT_SMALL (24 * 60 * 60)
1080 #  define TIME_AGO_UNIT_SMALL_NAME _("day")
1081 #  define TIME_AGO_UNIT_SMALL_NAME_PLURAL _("days")
1082 #  define TIME_AGO_MEDIUM_THRESHOLD (4 * TIME_AGO_UNIT_SMALL)
1083 #  define TIME_AGO_UNIT_MEDIUM (7 * 24 * 60 * 60)
1084 #  define TIME_AGO_UNIT_MEDIUM_NAME _("week")
1085 #  define TIME_AGO_UNIT_MEDIUM_NAME_PLURAL _("weeks")
1086 #  define TIME_AGO_LARGE_THRESHOLD (28 * TIME_AGO_UNIT_SMALL)
1087 #  define TIME_AGO_UNIT_LARGE (30 * 24 * 60 * 60)
1088 #  define TIME_AGO_UNIT_LARGE_NAME _("month")
1089 #  define TIME_AGO_UNIT_LARGE_NAME_PLURAL _("months")
1090 #endif
1091
1092 /* Convert from seconds to time units.
1093
1094    Note: T should already be a multiple of TIME_AGO_UNIT_SMALL or
1095    TIME_AGO_UNIT_MEDIUM or TIME_AGO_UNIT_LARGE.  */
1096 signed long
1097 time_ago_scale (signed long t)
1098 {
1099   if (t < TIME_AGO_UNIT_MEDIUM)
1100     return t / TIME_AGO_UNIT_SMALL;
1101   if (t < TIME_AGO_UNIT_LARGE)
1102     return t / TIME_AGO_UNIT_MEDIUM;
1103   return t / TIME_AGO_UNIT_LARGE;
1104 }
1105
1106 /* Return the appropriate unit (respecting whether it is plural or
1107    singular).  */
1108 const char *
1109 time_ago_unit (signed long t)
1110 {
1111   signed long t_scaled = time_ago_scale (t);
1112
1113   if (t < TIME_AGO_UNIT_MEDIUM)
1114     {
1115       if (t_scaled == 1)
1116         return TIME_AGO_UNIT_SMALL_NAME;
1117       return TIME_AGO_UNIT_SMALL_NAME_PLURAL;
1118     }
1119   if (t < TIME_AGO_UNIT_LARGE)
1120     {
1121       if (t_scaled == 1)
1122         return TIME_AGO_UNIT_MEDIUM_NAME;
1123       return TIME_AGO_UNIT_MEDIUM_NAME_PLURAL;
1124     }
1125   if (t_scaled == 1)
1126     return TIME_AGO_UNIT_LARGE_NAME;
1127   return TIME_AGO_UNIT_LARGE_NAME_PLURAL;
1128 }
1129
1130
1131 #define GET_POLICY_ERROR 100
1132
1133 /* Return the policy for the binding <FINGERPRINT, EMAIL> (email has
1134    already been normalized) and any conflict information in *CONFLICT
1135    if CONFLICT is not NULL.  Returns GET_POLICY_ERROR if an error
1136    occurs.  */
1137 static enum tofu_policy
1138 get_policy (struct db *dbs, const char *fingerprint, const char *email,
1139             char **conflict)
1140 {
1141   sqlite3 *db;
1142   int rc;
1143   char *err = NULL;
1144   strlist_t strlist = NULL;
1145   char *tail = NULL;
1146   enum tofu_policy policy = GET_POLICY_ERROR;
1147
1148   assert (GET_POLICY_ERROR != TOFU_POLICY_NONE
1149           && GET_POLICY_ERROR != TOFU_POLICY_AUTO
1150           && GET_POLICY_ERROR != TOFU_POLICY_GOOD
1151           && GET_POLICY_ERROR != TOFU_POLICY_UNKNOWN
1152           && GET_POLICY_ERROR != TOFU_POLICY_BAD
1153           && GET_POLICY_ERROR != TOFU_POLICY_ASK);
1154
1155   db = getdb (dbs, email, DB_EMAIL);
1156   if (! db)
1157     return GET_POLICY_ERROR;
1158
1159   /* Check if the <FINGERPRINT, EMAIL> binding is known
1160      (TOFU_POLICY_NONE cannot appear in the DB.  Thus, if POLICY is
1161      still TOFU_POLICY_NONE after executing the query, then the
1162      result set was empty.)  */
1163   rc = sqlite3_exec_printf
1164     (db, strings_collect_cb, &strlist, &err,
1165      "select policy, conflict from bindings\n"
1166      " where fingerprint = %Q and email = %Q",
1167      fingerprint, email);
1168   if (rc)
1169     {
1170       log_error (_("error reading from TOFU database"
1171                    " (checking for existing bad bindings): %s\n"),
1172                  err);
1173       sqlite3_free (err);
1174       goto out;
1175     }
1176
1177   if (strlist_length (strlist) == 0)
1178     /* No results.  */
1179     {
1180       policy = TOFU_POLICY_NONE;
1181       goto out;
1182     }
1183   else if (strlist_length (strlist) != 2)
1184     /* The result has the wrong form.  */
1185     {
1186       log_error (_("error reading from TOFU database"
1187                    " (checking for existing bad bindings):"
1188                    " expected 2 results, got %d\n"),
1189                  strlist_length (strlist));
1190       goto out;
1191     }
1192
1193   /* The result has the right form.  */
1194
1195   errno = 0;
1196   policy = strtol (strlist->d, &tail, 0);
1197   if (errno || *tail != '\0')
1198     {
1199       log_error (_("error reading from TOFU database: bad value for policy: %s\n"),
1200                  strlist->d);
1201       goto out;
1202     }
1203
1204   if (! (policy == TOFU_POLICY_AUTO
1205          || policy == TOFU_POLICY_GOOD
1206          || policy == TOFU_POLICY_UNKNOWN
1207          || policy == TOFU_POLICY_BAD
1208          || policy == TOFU_POLICY_ASK))
1209     {
1210       log_error (_("TOFU DB is corrupted.  Invalid value for policy (%d).\n"),
1211                  policy);
1212       policy = GET_POLICY_ERROR;
1213       goto out;
1214     }
1215
1216
1217   /* If CONFLICT is set, then policy should be TOFU_POLICY_ASK.  But,
1218      just in case, we do the check again here and ignore the conflict
1219      is POLICY is not TOFU_POLICY_ASK.  */
1220   if (conflict)
1221     {
1222       if (policy == TOFU_POLICY_ASK && *strlist->next->d)
1223         *conflict = xstrdup (strlist->next->d);
1224       else
1225         *conflict = NULL;
1226     }
1227
1228  out:
1229   assert (policy == GET_POLICY_ERROR
1230           || policy == TOFU_POLICY_NONE
1231           || policy == TOFU_POLICY_AUTO
1232           || policy == TOFU_POLICY_GOOD
1233           || policy == TOFU_POLICY_UNKNOWN
1234           || policy == TOFU_POLICY_BAD
1235           || policy == TOFU_POLICY_ASK);
1236
1237   free_strlist (strlist);
1238
1239   return policy;
1240 }
1241
1242 #define GET_TRUST_ERROR 100
1243
1244 /* Return the trust level (TRUST_NEVER, etc.) for the binding
1245    <FINGERPRINT, EMAIL> (email is already normalized).  If no policy
1246    is registered, returns TOFU_POLICY_NONE.  If an error occurs,
1247    returns GET_TRUST_ERROR.
1248
1249    USER_ID is the unadultered user id.
1250
1251    If MAY_ASK is set, then we may interact with the user.  This is
1252    necessary if there is a conflict or the binding's policy is
1253    TOFU_POLICY_ASK.  In the case of a conflict, we set the new
1254    conflicting binding's policy to TOFU_POLICY_ASK.  In either case,
1255    we return TRUST_UNDEFINED.  */
1256 static enum tofu_policy
1257 get_trust (struct db *dbs, const char *fingerprint, const char *email,
1258            const char *user_id, int may_ask)
1259 {
1260   sqlite3 *db;
1261   enum tofu_policy policy;
1262   char *conflict = NULL;
1263   int rc;
1264   char *err = NULL;
1265   strlist_t bindings_with_this_email = NULL;
1266   int bindings_with_this_email_count;
1267   int change_conflicting_to_ask = 0;
1268   int trust_level = TRUST_UNKNOWN;
1269
1270   if (opt.batch)
1271     may_ask = 0;
1272
1273   /* Make sure GET_TRUST_ERROR isn't equal to any of the trust
1274      levels.  */
1275   assert (GET_TRUST_ERROR != TRUST_UNKNOWN
1276           && GET_TRUST_ERROR != TRUST_EXPIRED
1277           && GET_TRUST_ERROR != TRUST_UNDEFINED
1278           && GET_TRUST_ERROR != TRUST_NEVER
1279           && GET_TRUST_ERROR != TRUST_MARGINAL
1280           && GET_TRUST_ERROR != TRUST_FULLY
1281           && GET_TRUST_ERROR != TRUST_ULTIMATE);
1282
1283   db = getdb (dbs, email, DB_EMAIL);
1284   if (! db)
1285     return GET_TRUST_ERROR;
1286
1287   policy = get_policy (dbs, fingerprint, email, &conflict);
1288   if (policy == TOFU_POLICY_AUTO)
1289     {
1290       policy = opt.tofu_default_policy;
1291       if (DBG_TRUST)
1292         log_debug ("TOFU: binding <%s, %s>'s policy is auto (default: %s).\n",
1293                    fingerprint, email,
1294                    tofu_policy_str (opt.tofu_default_policy));
1295     }
1296   switch (policy)
1297     {
1298     case TOFU_POLICY_AUTO:
1299     case TOFU_POLICY_GOOD:
1300     case TOFU_POLICY_UNKNOWN:
1301     case TOFU_POLICY_BAD:
1302       /* The saved judgement is auto -> auto, good, unknown or bad.
1303          We don't need to ask the user anything.  */
1304       if (DBG_TRUST)
1305         log_debug ("TOFU: Known binding <%s, %s>'s policy: %s\n",
1306                    fingerprint, email, tofu_policy_str (policy));
1307       trust_level = tofu_policy_to_trust_level (policy);
1308       goto out;
1309
1310     case TOFU_POLICY_ASK:
1311       /* We need to ask the user what to do.  Case #1 or #2 below.  */
1312       if (! may_ask)
1313         {
1314           trust_level = TRUST_UNDEFINED;
1315           goto out;
1316         }
1317
1318       break;
1319
1320     case TOFU_POLICY_NONE:
1321       /* The binding is new, we need to check for conflicts.  Case #3
1322          below.  */
1323       break;
1324
1325     case GET_POLICY_ERROR:
1326       trust_level = GET_TRUST_ERROR;
1327       goto out;
1328
1329     default:
1330       log_bug ("%s: Impossible value for policy (%d)\n", __func__, policy);
1331     }
1332
1333
1334   /* We get here if:
1335
1336        1. The saved policy is auto and the default policy is ask
1337           (get_policy() == TOFU_POLICY_AUTO
1338            && opt.tofu_default_policy == TOFU_POLICY_ASK)
1339
1340        2. The saved policy is ask (either last time the user selected
1341           accept once or reject once or there was a conflict and this
1342           binding's policy was changed from auto to ask)
1343           (policy == TOFU_POLICY_ASK), or,
1344
1345        3. We don't have a saved policy (policy == TOFU_POLICY_NONE)
1346           (need to check for a conflict).
1347    */
1348
1349   /* Look for conflicts.  This is need in all 3 cases.
1350
1351      Get the fingerprints of any bindings that share the email
1352      address.  Note: if the binding in question is in the DB, it will
1353      also be returned.  Thus, if the result set is empty, then this is
1354      a new binding.  */
1355   rc = sqlite3_exec_printf
1356     (db, strings_collect_cb, &bindings_with_this_email, &err,
1357      "select distinct fingerprint from bindings where email = %Q;",
1358      email);
1359   if (rc)
1360     {
1361       log_error (_("error reading from TOFU database"
1362                    " (listing fingerprints): %s\n"),
1363                  err);
1364       sqlite3_free (err);
1365       goto out;
1366     }
1367
1368   bindings_with_this_email_count = strlist_length (bindings_with_this_email);
1369   if (bindings_with_this_email_count == 0
1370       && opt.tofu_default_policy != TOFU_POLICY_ASK)
1371     /* New binding with no conflict and a concrete default policy.
1372
1373        We've never observed a binding with this email address
1374        (BINDINGS_WITH_THIS_EMAIL_COUNT is 0 and the above query would return
1375        the current binding if it were in the DB) and we have a default
1376        policy, which is not to ask the user.  */
1377     {
1378       /* If we've seen this binding, then we've seen this email and
1379          policy couldn't possibly be TOFU_POLICY_NONE.  */
1380       assert (policy == TOFU_POLICY_NONE);
1381
1382       if (DBG_TRUST)
1383         log_debug ("TOFU: New binding <%s, %s>, no conflict.\n",
1384                    email, fingerprint);
1385
1386       if (record_binding (dbs, fingerprint, email, user_id,
1387                           TOFU_POLICY_AUTO, 0) != 0)
1388         {
1389           log_error (_("error setting TOFU binding's trust level to %s\n"),
1390                        "auto");
1391           trust_level = GET_TRUST_ERROR;
1392           goto out;
1393         }
1394
1395       trust_level = tofu_policy_to_trust_level (TOFU_POLICY_AUTO);
1396       goto out;
1397     }
1398
1399   if (policy == TOFU_POLICY_NONE)
1400     /* This is a new binding and we have a conflict.  Mark any
1401        conflicting bindings that have an automatic policy as now
1402        requiring confirmation.  Note: we delay this until after we ask
1403        for confirmation so that when the current policy is printed, it
1404        is correct.  */
1405     change_conflicting_to_ask = 1;
1406
1407   if (! may_ask)
1408     /* We can only get here in the third case (no saved policy) and if
1409        there is a conflict.  (If the policy was ask (cases #1 and #2)
1410        and we weren't allowed to ask, we'd have already exited).  */
1411     {
1412       assert (policy == TOFU_POLICY_NONE);
1413
1414       if (record_binding (dbs, fingerprint, email, user_id,
1415                           TOFU_POLICY_ASK, 0) != 0)
1416         log_error (_("error setting TOFU binding's trust level to %s\n"),
1417                    "ask");
1418
1419       trust_level = TRUST_UNDEFINED;
1420       goto out;
1421     }
1422
1423   /* If we get here, we need to ask the user about the binding.  There
1424      are three ways we could end up here:
1425
1426        - This is a new binding and there is a conflict
1427          (policy == TOFU_POLICY_NONE && bindings_with_this_email_count > 0),
1428
1429        - This is a new binding and opt.tofu_default_policy is set to
1430          ask.  (policy == TOFU_POLICY_NONE && opt.tofu_default_policy ==
1431          TOFU_POLICY_ASK), or,
1432
1433        - The policy is ask (the user deferred last time) (policy ==
1434          TOFU_POLICY_ASK).
1435    */
1436   {
1437     int is_conflict =
1438       ((policy == TOFU_POLICY_NONE && bindings_with_this_email_count > 0)
1439        || (policy == TOFU_POLICY_ASK && conflict));
1440     estream_t fp;
1441     char *binding;
1442     int binding_shown;
1443     strlist_t other_user_ids = NULL;
1444     struct signature_stats *stats = NULL;
1445     struct signature_stats *stats_iter = NULL;
1446     char *prompt;
1447     char *choices;
1448
1449     fp = es_fopenmem (0, "rw,samethread");
1450     if (! fp)
1451       log_fatal ("Error creating memory stream\n");
1452
1453     binding = xasprintf ("<%s, %s>", fingerprint, email);
1454     binding_shown = 0;
1455
1456     if (policy == TOFU_POLICY_NONE)
1457       {
1458         es_fprintf (fp, _("The binding %s is NOT known.  "), binding);
1459         binding_shown = 1;
1460       }
1461     else if (policy == TOFU_POLICY_ASK && conflict)
1462       {
1463         es_fprintf (fp,
1464                     _("%s raised a conflict with this binding.  Since this"
1465                       " binding's policy was 'auto', it was changed to 'ask'.  "),
1466                     binding);
1467         binding_shown = 1;
1468       }
1469     es_fprintf (fp,
1470                 _("Please indicate whether you believe the binding %s%s"
1471                   "is legitimate (the key belongs to the stated owner) "
1472                   "or a forgery (bad).\n\n"),
1473                 binding_shown ? "" : binding,
1474                 binding_shown ? "" : " ");
1475
1476     xfree (binding);
1477
1478     /* Find other user ids associated with this key and whether the
1479        bindings are marked as good or bad.  */
1480     {
1481       sqlite3 *db_key;
1482
1483       if (opt.tofu_db_format == TOFU_DB_SPLIT)
1484         /* In the split format, we need to search in the fingerprint
1485            DB for all the emails associated with this key, not the
1486            email DB.  */
1487         db_key = getdb (dbs, fingerprint, DB_KEY);
1488       else
1489         db_key = db;
1490
1491       if (db_key)
1492         {
1493           rc = sqlite3_exec_printf
1494             (db_key, strings_collect_cb, &other_user_ids, &err,
1495              "select user_id, %s from bindings where fingerprint = %Q;",
1496              opt.tofu_db_format == TOFU_DB_SPLIT ? "email" : "policy",
1497              fingerprint);
1498           if (rc)
1499             {
1500               log_error (_("error gathering other user ids: %s.\n"), err);
1501               sqlite3_free (err);
1502               err = NULL;
1503             }
1504         }
1505     }
1506
1507     if (other_user_ids)
1508       {
1509         strlist_t strlist_iter;
1510
1511         es_fprintf (fp, _("Known user ids associated with this key:\n"));
1512         for (strlist_iter = other_user_ids;
1513              strlist_iter;
1514              strlist_iter = strlist_iter->next)
1515           {
1516             char *other_user_id = strlist_iter->d;
1517             char *other_thing;
1518             enum tofu_policy other_policy;
1519
1520             assert (strlist_iter->next);
1521             strlist_iter = strlist_iter->next;
1522             other_thing = strlist_iter->d;
1523
1524             if (opt.tofu_db_format == TOFU_DB_SPLIT)
1525               other_policy = get_policy (dbs, fingerprint, other_thing, NULL);
1526             else
1527               other_policy = atoi (other_thing);
1528
1529             es_fprintf (fp, _("  %s (policy: %s)\n"),
1530                         other_user_id,
1531                         tofu_policy_str (other_policy));
1532           }
1533         es_fprintf (fp, "\n");
1534
1535         free_strlist (other_user_ids);
1536       }
1537
1538     /* Find other keys associated with this email address.  */
1539     /* XXX: When generating the statistics, do we want the time
1540        embedded in the signature (column 'sig_time') or the time that
1541        we first verified the signature (column 'time').  */
1542     rc = sqlite3_exec_printf
1543       (db, signature_stats_collect_cb, &stats, &err,
1544        "select fingerprint, policy, time_ago, count(*)\n"
1545        " from (select bindings.*,\n"
1546        "        case\n"
1547        /* From the future (but if its just a couple of hours in the
1548           future don't turn it into a warning)?  Or should we use
1549           small, medium or large units?  (Note: whatever we do, we
1550           keep the value in seconds.  Then when we group, everything
1551           that rounds to the same number of seconds is grouped.)  */
1552        "         when delta < -%d then -1\n"
1553        "         when delta < %d then max(0, round(delta / %d) * %d)\n"
1554        "         when delta < %d then round(delta / %d) * %d\n"
1555        "         else round(delta / %d) * %d\n"
1556        "        end time_ago,\n"
1557        "        delta time_ago_raw\n"
1558        "       from (select *,\n"
1559        "              cast(strftime('%%s','now') - sig_time as real) delta\n"
1560        "             from signatures) ss\n"
1561        "       left join bindings on ss.binding = bindings.oid)\n"
1562        " where email = %Q\n"
1563        " group by fingerprint, time_ago\n"
1564        /* Make sure the current key is first.  */
1565        " order by fingerprint = %Q asc, fingerprint desc, time_ago desc;\n",
1566        TIME_AGO_FUTURE_IGNORE,
1567        TIME_AGO_MEDIUM_THRESHOLD, TIME_AGO_UNIT_SMALL, TIME_AGO_UNIT_SMALL,
1568        TIME_AGO_LARGE_THRESHOLD, TIME_AGO_UNIT_MEDIUM, TIME_AGO_UNIT_MEDIUM,
1569        TIME_AGO_UNIT_LARGE, TIME_AGO_UNIT_LARGE,
1570        email, fingerprint);
1571     if (rc)
1572       {
1573         strlist_t strlist_iter;
1574
1575         log_error (_("error gathering signature stats: %s.\n"),
1576                    err);
1577         sqlite3_free (err);
1578         err = NULL;
1579
1580         es_fprintf
1581           (fp, _("The email address (%s) is associated with %d keys:\n"),
1582            email, bindings_with_this_email_count);
1583         for (strlist_iter = bindings_with_this_email;
1584              strlist_iter;
1585              strlist_iter = strlist_iter->next)
1586           es_fprintf (fp, _("  %s\n"), strlist_iter->d);
1587       }
1588     else
1589       {
1590         char *key = NULL;
1591
1592         if (! stats || strcmp (stats->fingerprint, fingerprint) != 0)
1593           /* If we have already added this key to the DB, then it will
1594              be first (see the above select).  Since the first key on
1595              the list is not this key, we must not yet have verified
1596              any messages signed by this key.  Add a dummy entry.  */
1597           signature_stats_prepend (&stats, fingerprint, TOFU_POLICY_AUTO, 0, 0);
1598
1599         es_fprintf (fp, _("Statistics for keys with the email '%s':\n"),
1600                     email);
1601         for (stats_iter = stats; stats_iter; stats_iter = stats_iter->next)
1602           {
1603             if (! key || strcmp (key, stats_iter->fingerprint) != 0)
1604               {
1605                 int this_key;
1606                 key = stats_iter->fingerprint;
1607                 this_key = strcmp (key, fingerprint) == 0;
1608                 if (this_key)
1609                   es_fprintf (fp, _("  %s (this key):"), key);
1610                 else
1611                   es_fprintf (fp, _("  %s (policy: %s):"),
1612                               key, tofu_policy_str (stats_iter->policy));
1613                 es_fprintf (fp, "\n");
1614               }
1615
1616             if (stats_iter->time_ago == -1)
1617               es_fprintf (fp, _("    %ld %s signed in the future.\n"),
1618                           stats_iter->count,
1619                           stats_iter->count == 1
1620                           ? _("message") : _("messages"));
1621             else if (stats_iter->count == 0)
1622               es_fprintf (fp, _("    0 signed messages.\n"));
1623             else
1624               es_fprintf (fp, _("    %ld %s signed over the past %ld %s.\n"),
1625                           stats_iter->count,
1626                           stats_iter->count == 1
1627                           ? _("message") : _("messages"),
1628                           time_ago_scale (stats_iter->time_ago),
1629                           time_ago_unit (stats_iter->time_ago));
1630           }
1631       }
1632
1633     if (is_conflict)
1634       {
1635         /* TRANSLATORS: translate the below text.  We don't directly
1636            internationalize that text so that we can tweak it without
1637            breaking translations.  */
1638         char *text = _("TOFU detected a binding conflict");
1639         if (strcmp (text, "TOFU detected a binding conflict") == 0)
1640           /* No translation.  Use the English text.  */
1641           text =
1642             "Normally, there is only a single key associated with an email"
1643             "address.  However, people sometimes generate a new key if"
1644             "their key is too old or they think it might be compromised."
1645             "Alternatively, a new key may indicate a man-in-the-middle attack!"
1646             "Before accepting this key, you should talk to or call the person"
1647             "to make sure this new key is legitimate.";
1648         es_fprintf (fp, "\n%s\n", text);
1649       }
1650
1651     es_fputc ('\n', fp);
1652     /* TRANSLATORS: Two letters (normally the lower and upper case
1653        version of the hotkey) for each of the five choices.  If there
1654        is only one choice in your language, repeat it.  */
1655     choices = _("gG" "aA" "uU" "rR" "bB");
1656     es_fprintf (fp, _("(G)ood/(A)ccept once/(U)nknown/(R)eject once/(B)ad? "));
1657
1658     /* Add a NUL terminator.  */
1659     es_fputc (0, fp);
1660     if (es_fclose_snatch (fp, (void **) &prompt, NULL))
1661       log_fatal ("error snatching memory stream\n");
1662
1663     while (1)
1664       {
1665         char *response;
1666
1667         if (strlen (choices) != 10)
1668           log_bug ("Bad TOFU conflict translation!  Please report.");
1669
1670         response = cpr_get ("tofu conflict", prompt);
1671         trim_spaces (response);
1672         cpr_kill_prompt ();
1673         if (strlen (response) == 1)
1674           {
1675             char *choice = strchr (choices, *response);
1676             if (choice)
1677               {
1678                 int c = ((size_t) choice - (size_t) choices) / 2;
1679                 assert (0 <= c && c <= 3);
1680
1681                 switch (c)
1682                   {
1683                   case 0: /* Good.  */
1684                     policy = TOFU_POLICY_GOOD;
1685                     trust_level = tofu_policy_to_trust_level (policy);
1686                     break;
1687                   case 1: /* Accept once.  */
1688                     policy = TOFU_POLICY_ASK;
1689                     trust_level =
1690                       tofu_policy_to_trust_level (TOFU_POLICY_GOOD);
1691                     break;
1692                   case 2: /* Unknown.  */
1693                     policy = TOFU_POLICY_UNKNOWN;
1694                     trust_level = tofu_policy_to_trust_level (policy);
1695                     break;
1696                   case 3: /* Reject once.  */
1697                     policy = TOFU_POLICY_ASK;
1698                     trust_level =
1699                       tofu_policy_to_trust_level (TOFU_POLICY_BAD);
1700                     break;
1701                   case 4: /* Bad.  */
1702                     policy = TOFU_POLICY_BAD;
1703                     trust_level = tofu_policy_to_trust_level (policy);
1704                     break;
1705                   default:
1706                     log_bug ("c should be between 0 and 4 but it is %d!", c);
1707                   }
1708
1709                 if (record_binding (dbs, fingerprint, email, user_id,
1710                                     policy, 0) != 0)
1711                   /* If there's an error registering the
1712                      binding, don't save the signature.  */
1713                   trust_level = GET_TRUST_ERROR;
1714
1715                 break;
1716               }
1717           }
1718         xfree (response);
1719       }
1720
1721     xfree (prompt);
1722
1723     signature_stats_free (stats);
1724   }
1725
1726  out:
1727   if (change_conflicting_to_ask)
1728     {
1729       rc = sqlite3_exec_printf
1730         (db, NULL, NULL, &err,
1731          "update bindings set policy = %d, conflict = %Q"
1732          " where email = %Q and fingerprint != %Q and policy = %d;",
1733          TOFU_POLICY_ASK, fingerprint, email, fingerprint, TOFU_POLICY_AUTO);
1734       if (rc)
1735         {
1736           log_error (_("error changing TOFU policy: %s\n"), err);
1737           sqlite3_free (err);
1738           goto out;
1739         }
1740     }
1741
1742   xfree (conflict);
1743   free_strlist (bindings_with_this_email);
1744
1745   return trust_level;
1746 }
1747
1748 static void
1749 show_statistics (struct db *dbs, const char *fingerprint,
1750                  const char *email, const char *user_id,
1751                  const char *sig_exclude)
1752 {
1753   sqlite3 *db;
1754   int rc;
1755   strlist_t strlist = NULL;
1756   char *err = NULL;
1757
1758   db = getdb (dbs, email, DB_EMAIL);
1759   if (! db)
1760     return;
1761
1762   rc = sqlite3_exec_printf
1763     (db, strings_collect_cb, &strlist, &err,
1764      "select count (*), strftime('%%s','now') - min (signatures.time)\n"
1765      " from signatures\n"
1766      " left join bindings on signatures.binding = bindings.oid\n"
1767      " where fingerprint = %Q and email = %Q and sig_digest %s%s%s;",
1768      fingerprint, email,
1769      /* We want either: sig_digest != 'SIG_EXCLUDE' or sig_digest is
1770         not NULL.  */
1771      sig_exclude ? "!= '" : "is not NULL",
1772      sig_exclude ? sig_exclude : "",
1773      sig_exclude ? "'" : "");
1774   if (rc)
1775     {
1776       log_error (_("error reading from TOFU database"
1777                    " (getting statistics): %s\n"),
1778                  err);
1779       sqlite3_free (err);
1780       goto out;
1781     }
1782
1783   if (! strlist)
1784     log_info (_("Have never verified a message signed by key %s!\n"),
1785               fingerprint);
1786   else
1787     {
1788       char *tail = NULL;
1789       signed long messages;
1790       signed long first_seen_ago;
1791
1792       assert (strlist_length (strlist) == 2);
1793
1794       errno = 0;
1795       messages = strtol (strlist->d, &tail, 0);
1796       if (errno || *tail != '\0')
1797         /* Abort.  */
1798         {
1799           log_debug ("%s:%d: Couldn't convert %s (messages) to an int: %s.\n",
1800                      __func__, __LINE__, strlist->d, strerror (errno));
1801           messages = -1;
1802         }
1803
1804       if (messages == 0 && *strlist->next->d == '\0')
1805         /* min(NULL) => NULL => "".  */
1806         first_seen_ago = -1;
1807       else
1808         {
1809           errno = 0;
1810           first_seen_ago = strtol (strlist->next->d, &tail, 0);
1811           if (errno || *tail != '\0')
1812             /* Abort.  */
1813             {
1814               log_debug ("%s:%d: Cound't convert %s (first_seen) to an int: %s.\n",
1815                          __func__, __LINE__,
1816                          strlist->next->d, strerror (errno));
1817               first_seen_ago = 0;
1818             }
1819         }
1820
1821       if (messages == -1 || first_seen_ago == 0)
1822         log_info (_("Failed to collect signature statistics for \"%s\" (key %s)\n"),
1823                   user_id, fingerprint);
1824       else
1825         {
1826           enum tofu_policy policy = get_policy (dbs, fingerprint, email, NULL);
1827           estream_t fp;
1828           char *msg;
1829
1830           fp = es_fopenmem (0, "rw,samethread");
1831           if (! fp)
1832             log_fatal ("error creating memory stream\n");
1833
1834           if (messages == 0)
1835             es_fprintf (fp,
1836                         _("Verified 0 messages signed by \"%s\""
1837                           " (key: %s, policy %s)."),
1838                         user_id, fingerprint, tofu_policy_str (policy));
1839           else
1840             {
1841               int years = 0;
1842               int months = 0;
1843               int days = 0;
1844               int hours = 0;
1845               int minutes = 0;
1846               int seconds = 0;
1847
1848               /* The number of units that we've printed so far.  */
1849               int count = 0;
1850               /* The first unit that we printed (year = 0, month = 1,
1851                  etc.).  */
1852               int first = -1;
1853               /* The current unit.  */
1854               int i = 0;
1855
1856               es_fprintf (fp,
1857                           _("Verified %ld messages signed by \"%s\""
1858                             " (key: %s, policy: %s) in the past "),
1859                           messages, user_id,
1860                           fingerprint, tofu_policy_str (policy));
1861
1862               /* It would be nice to use a macro to do this, but gettext
1863                  works on the unpreprocessed code.  */
1864 #define MIN_SECS (60)
1865 #define HOUR_SECS (60 * MIN_SECS)
1866 #define DAY_SECS (24 * HOUR_SECS)
1867 #define MONTH_SECS (30 * DAY_SECS)
1868 #define YEAR_SECS (365 * DAY_SECS)
1869
1870               if (first_seen_ago > YEAR_SECS)
1871                 {
1872                   years = first_seen_ago / YEAR_SECS;
1873                   first_seen_ago -= years * YEAR_SECS;
1874                 }
1875               if (first_seen_ago > MONTH_SECS)
1876                 {
1877                   months = first_seen_ago / MONTH_SECS;
1878                   first_seen_ago -= months * MONTH_SECS;
1879                 }
1880               if (first_seen_ago > DAY_SECS)
1881                 {
1882                   days = first_seen_ago / DAY_SECS;
1883                   first_seen_ago -= days * DAY_SECS;
1884                 }
1885               if (first_seen_ago > HOUR_SECS)
1886                 {
1887                   hours = first_seen_ago / HOUR_SECS;
1888                   first_seen_ago -= hours * HOUR_SECS;
1889                 }
1890               if (first_seen_ago > MIN_SECS)
1891                 {
1892                   minutes = first_seen_ago / MIN_SECS;
1893                   first_seen_ago -= minutes * MIN_SECS;
1894                 }
1895               seconds = first_seen_ago;
1896
1897               if (years)
1898                 {
1899                   if (years > 1)
1900                     es_fprintf (fp, _("%d years"), years);
1901                   else
1902                     es_fprintf (fp, _("%d year"), years);
1903                   count ++;
1904                   first = i;
1905                 }
1906               i ++;
1907               if ((first == -1 || i - first <= 3) && months)
1908                 {
1909                   if (count)
1910                     es_fprintf (fp, _(", "));
1911
1912                   if (months > 1)
1913                     es_fprintf (fp, _("%d months"), months);
1914                   else
1915                     es_fprintf (fp, _("%d month"), months);
1916                   count ++;
1917                   first = i;
1918                 }
1919               i ++;
1920               if ((first == -1 || i - first <= 3) && count < 2 && days)
1921                 {
1922                   if (count)
1923                     es_fprintf (fp, _(", "));
1924
1925                   if (days > 1)
1926                     es_fprintf (fp, _("%d days"), days);
1927                   else
1928                     es_fprintf (fp, _("%d day"), days);
1929                   count ++;
1930                   first = i;
1931                 }
1932               i ++;
1933               if ((first == -1 || i - first <= 3) && count < 2 && hours)
1934                 {
1935                   if (count)
1936                     es_fprintf (fp, _(", "));
1937
1938                   if (hours > 1)
1939                     es_fprintf (fp, _("%d hours"), hours);
1940                   else
1941                     es_fprintf (fp, _("%d hour"), hours);
1942                   count ++;
1943                   first = i;
1944                 }
1945               i ++;
1946               if ((first == -1 || i - first <= 3) && count < 2 && minutes)
1947                 {
1948                   if (count)
1949                     es_fprintf (fp, _(", "));
1950
1951                   if (minutes > 1)
1952                     es_fprintf (fp, _("%d minutes"), minutes);
1953                   else
1954                     es_fprintf (fp, _("%d minute"), minutes);
1955                   count ++;
1956                   first = i;
1957                 }
1958               i ++;
1959               if ((first == -1 || i - first <= 3) && count < 2)
1960                 {
1961                   if (count)
1962                     es_fprintf (fp, _(", "));
1963
1964                   if (seconds > 1)
1965                     es_fprintf (fp, _("%d seconds"), seconds);
1966                   else
1967                     es_fprintf (fp, _("%d second"), seconds);
1968                 }
1969
1970               es_fprintf (fp, _("."));
1971             }
1972
1973           es_fputc (0, fp);
1974           if (es_fclose_snatch (fp, (void **) &msg, NULL))
1975             log_fatal ("error snatching memory stream\n");
1976
1977           log_info ("%s\n", msg);
1978
1979           if (policy == TOFU_POLICY_AUTO && messages < 10)
1980             {
1981               char *set_policy_command;
1982               const char *text;
1983
1984               if (messages == 0)
1985                 log_info (_("Warning: we've have yet to see a message signed by this key!\n"));
1986               else if (messages == 1)
1987                 log_info (_("Warning: we've only seen a single message signed by this key!\n"));
1988
1989               set_policy_command =
1990                 xasprintf ("gpg --tofu-policy bad \"%s\"", fingerprint);
1991               /* TRANSLATORS: translate the below text.  We don't
1992                  directly internationalize that text so that we can
1993                  tweak it without breaking translations.  */
1994               text = _("TOFU: few signatures %s");
1995               if (strcmp (text, "TOFU: few signatures %s") == 0)
1996                 text =
1997                   "Warning: if this value is unexpectedly low, this might "
1998                   "indicate that this key is a forgery!  Carefully examine "
1999                   "the email address for small variations (e.g., additional "
2000                   "white space).  If the key is suspect, then use '%s' to "
2001                   "mark the key as being bad.\n";
2002               log_info (text, set_policy_command);
2003               free (set_policy_command);
2004             }
2005         }
2006     }
2007
2008  out:
2009   free_strlist (strlist);
2010
2011   return;
2012 }
2013
2014 /* Extract the email address from a user id and normalize it.  If the
2015    user id doesn't contain an email address, then we use the whole
2016    user_id and normalize that.  The returned string must be freed.  */
2017 static char *
2018 email_from_user_id (const char *user_id)
2019 {
2020   char *email = mailbox_from_userid (user_id);
2021   if (! email)
2022     /* Hmm, no email address was provided.  Just take the lower-case
2023        version of the whole user id.  It could be a hostname, for
2024        instance.  */
2025     email = ascii_strlwr (xstrdup (user_id));
2026
2027   return email;
2028 }
2029
2030 /* Pretty print a MAX_FINGERPRINT_LEN-byte binary fingerprint into a
2031    malloc'd string.  */
2032 static char *
2033 fingerprint_pp (const byte *fingerprint_bin)
2034 {
2035   char fingerprint[MAX_FINGERPRINT_LEN * 2 + 1];
2036   char *fingerprint_pretty;
2037   int space = (/* The characters and the NUL.  */
2038                sizeof (fingerprint)
2039                /* After every fourth character, we add a space (except
2040                   the last).  */
2041                + (sizeof (fingerprint) - 1) / 4 - 1
2042                /* Half way through we add a second space.  */
2043                + 1);
2044   int i;
2045   int j;
2046
2047   bin2hex (fingerprint_bin, MAX_FINGERPRINT_LEN, fingerprint);
2048
2049   fingerprint_pretty = xmalloc (space);
2050
2051   for (i = 0, j = 0; i < MAX_FINGERPRINT_LEN * 2; i ++)
2052     {
2053       if (i && i % 4 == 0)
2054         fingerprint_pretty[j ++] = ' ';
2055       if (i == MAX_FINGERPRINT_LEN * 2 / 2)
2056         fingerprint_pretty[j ++] = ' ';
2057
2058       fingerprint_pretty[j ++] = fingerprint[i];
2059     }
2060   fingerprint_pretty[j ++] = 0;
2061   assert (j == space);
2062
2063   return fingerprint_pretty;
2064 }
2065
2066 /* Register the signature with the binding <FINGERPRINT_BIN, USER_ID>.
2067    FINGERPRINT must be MAX_FINGERPRINT_LEN bytes long.
2068
2069    SIG_DIGEST_BIN is the binary representation of the message's
2070    digest.  SIG_DIGEST_BIN_LEN is its length.
2071
2072    SIG_TIME is the time that the signature was generated.
2073
2074    ORIGIN is a free-formed string describing the origin of the
2075    signature.  If this was from an email and the Claws MUA was used,
2076    then this should be something like: "email:claws".  If this is
2077    NULL, the default is simply "unknown".
2078
2079    If MAY_ASK is 1, then this function may interact with the user.
2080    This is necessary if there is a conflict or the binding's policy is
2081    TOFU_POLICY_ASK.
2082
2083    This function returns the binding's trust level on return.  If an
2084    error occurs, this function returns TRUST_UNKNOWN.  */
2085 int
2086 tofu_register (const byte *fingerprint_bin, const char *user_id,
2087                const byte *sig_digest_bin, int sig_digest_bin_len,
2088                time_t sig_time, const char *origin, int may_ask)
2089 {
2090   struct db *dbs;
2091   sqlite3 *db;
2092   char *fingerprint = NULL;
2093   char *email = NULL;
2094   char *err = NULL;
2095   int rc;
2096   int trust_level = TRUST_UNKNOWN;
2097   char *sig_digest;
2098   unsigned long c;
2099   int already_verified = 0;
2100
2101   dbs = opendbs ();
2102   if (! dbs)
2103     {
2104       log_error (_("error opening TOFU DB.\n"));
2105       goto die;
2106     }
2107
2108   fingerprint = fingerprint_pp (fingerprint_bin);
2109
2110   if (! *user_id)
2111     {
2112       log_debug ("TOFU: user id is empty.  Can't continue.\n");
2113       goto die;
2114     }
2115
2116   email = email_from_user_id (user_id);
2117
2118   if (! origin)
2119     /* The default origin is simply "unknown".  */
2120     origin = "unknown";
2121
2122   /* It's necessary to get the trust so that we are certain that the
2123      binding has been registered.  */
2124   trust_level = get_trust (dbs, fingerprint, email, user_id, may_ask);
2125   if (trust_level == GET_TRUST_ERROR)
2126     /* An error.  */
2127     {
2128       trust_level = TRUST_UNKNOWN;
2129       goto die;
2130     }
2131
2132   /* Save the observed signature in the DB.  */
2133   sig_digest = make_radix64_string (sig_digest_bin, sig_digest_bin_len);
2134
2135   db = getdb (dbs, email, DB_EMAIL);
2136   if (! db)
2137     {
2138       log_error (_("error opening TOFU DB.\n"));
2139       goto die;
2140     }
2141
2142   /* We do a query and then an insert.  Make sure they are atomic
2143      by wrapping them in a transaction.  */
2144   rc = sqlite3_exec (db, "begin transaction;", NULL, NULL, &err);
2145   if (rc)
2146     {
2147       log_error (_("error beginning transaction on TOFU database: %s\n"), err);
2148       sqlite3_free (err);
2149       goto die;
2150     }
2151
2152   /* If we've already seen this signature before, then don't add
2153      it again.  */
2154   rc = sqlite3_exec_printf
2155     (db, get_single_unsigned_long_cb, &c, &err,
2156      "select count (*)\n"
2157      " from signatures left join bindings\n"
2158      "  on signatures.binding = bindings.oid\n"
2159      " where fingerprint = %Q and email = %Q and sig_time = 0x%lx\n"
2160      "  and sig_digest = %Q",
2161      fingerprint, email, (unsigned long) sig_time, sig_digest);
2162   if (rc)
2163     {
2164       log_error (_("error reading from signatures database"
2165                    " (checking existence): %s\n"),
2166                  err);
2167       sqlite3_free (err);
2168     }
2169   else if (c > 1)
2170     /* Duplicates!  This should not happen.  In particular,
2171        because <fingerprint, email, sig_time, sig_digest> is the
2172        primary key!  */
2173     log_debug ("SIGNATURES DB contains duplicate records"
2174                " <key: %s, %s, time: 0x%lx, sig: %s, %s>."
2175                "  Please report.\n",
2176                fingerprint, email, (unsigned long) sig_time,
2177                sig_digest, origin);
2178   else if (c == 1)
2179     {
2180       already_verified = 1;
2181       if (DBG_TRUST)
2182         log_debug ("Already observed the signature"
2183                    " <key: %s, %s, time: 0x%lx, sig: %s, %s>\n",
2184                    fingerprint, email, (unsigned long) sig_time,
2185                    sig_digest, origin);
2186     }
2187   else
2188     /* This is the first time that we've seen this signature.
2189        Record it.  */
2190     {
2191       if (DBG_TRUST)
2192         log_debug ("TOFU: Saving signature <%s, %s, %s>\n",
2193                    fingerprint, email, sig_digest);
2194
2195       assert (c == 0);
2196
2197       rc = sqlite3_exec_printf
2198         (db, NULL, NULL, &err,
2199          "insert into signatures\n"
2200          " (binding, sig_digest, origin, sig_time, time)\n"
2201          " values\n"
2202          " ((select oid from bindings\n"
2203          "    where fingerprint = %Q and email = %Q),\n"
2204          "  %Q, %Q, 0x%lx, strftime('%%s', 'now'));",
2205          fingerprint, email, sig_digest, origin, (unsigned long) sig_time);
2206       if (rc)
2207         {
2208           log_error (_("error updating TOFU DB"
2209                        " (inserting into signatures table): %s\n"),
2210                      err);
2211           sqlite3_free (err);
2212         }
2213     }
2214
2215   /* It only matters whether we abort or commit the transaction
2216      (so long as we do something) if we execute the insert.  */
2217   if (rc)
2218     rc = sqlite3_exec (db, "rollback;", NULL, NULL, &err);
2219   else
2220     rc = sqlite3_exec (db, "commit transaction;", NULL, NULL, &err);
2221   if (rc)
2222     {
2223       log_error (_("error ending transaction on TOFU database: %s\n"), err);
2224       sqlite3_free (err);
2225       goto die;
2226     }
2227
2228  die:
2229   if (may_ask)
2230     /* It's only appropriate to show the statistics in an interactive
2231        context.  */
2232     show_statistics (dbs, fingerprint, email, user_id,
2233                      already_verified ? NULL : sig_digest);
2234
2235   xfree (email);
2236   xfree (fingerprint);
2237   if (dbs)
2238     closedbs (dbs);
2239
2240   return trust_level;
2241 }
2242
2243 /* Combine a trust level returned from the TOFU trust model with a
2244    trust level returned by the PGP trust model.  This is primarily of
2245    interest when the trust model is tofu+pgp (TM_TOFU_PGP).
2246
2247    This function ors together the upper bits (the values not covered
2248    by TRUST_MASK, i.e., TRUST_FLAG_REVOKED, etc.).  */
2249 int
2250 tofu_wot_trust_combine (int tofu_base, int wot_base)
2251 {
2252   int tofu = tofu_base & TRUST_MASK;
2253   int wot = wot_base & TRUST_MASK;
2254   int upper = (tofu_base & ~TRUST_MASK) | (wot_base & ~TRUST_MASK);
2255
2256   assert (tofu == TRUST_UNKNOWN
2257           || tofu == TRUST_EXPIRED
2258           || tofu == TRUST_UNDEFINED
2259           || tofu == TRUST_NEVER
2260           || tofu == TRUST_MARGINAL
2261           || tofu == TRUST_FULLY
2262           || tofu == TRUST_ULTIMATE);
2263   assert (wot == TRUST_UNKNOWN
2264           || wot == TRUST_EXPIRED
2265           || wot == TRUST_UNDEFINED
2266           || wot == TRUST_NEVER
2267           || wot == TRUST_MARGINAL
2268           || wot == TRUST_FULLY
2269           || wot == TRUST_ULTIMATE);
2270
2271   /* We first consider negative trust policys.  These trump positive
2272      trust policies.  */
2273   if (tofu == TRUST_NEVER || wot == TRUST_NEVER)
2274     /* TRUST_NEVER trumps everything else.  */
2275     return upper | TRUST_NEVER;
2276   if (tofu == TRUST_EXPIRED || wot == TRUST_EXPIRED)
2277     /* TRUST_EXPIRED trumps everything but TRUST_NEVER.  */
2278     return upper | TRUST_EXPIRED;
2279
2280   /* Now we only have positive or neutral trust policies.  We take
2281      the max.  */
2282   if (tofu == TRUST_ULTIMATE || wot == TRUST_ULTIMATE)
2283     return upper | TRUST_ULTIMATE;
2284   if (tofu == TRUST_FULLY || wot == TRUST_FULLY)
2285     return upper | TRUST_FULLY;
2286   if (tofu == TRUST_MARGINAL || wot == TRUST_MARGINAL)
2287     return upper | TRUST_MARGINAL;
2288   if (tofu == TRUST_UNDEFINED || wot == TRUST_UNDEFINED)
2289     return upper | TRUST_UNDEFINED;
2290   return upper | TRUST_UNKNOWN;
2291 }
2292
2293 /* Return the validity (TRUST_NEVER, etc.) of the binding
2294    <FINGERPRINT, USER_ID>.
2295
2296    FINGERPRINT must be a MAX_FINGERPRINT_LEN-byte fingerprint.
2297
2298    If MAY_ASK is 1 and the policy is TOFU_POLICY_ASK, then the user
2299    will be prompted to choose a different policy.  If MAY_ASK is 0 and
2300    the policy is TOFU_POLICY_ASK, then TRUST_UNKNOWN is returned.
2301
2302    Returns TRUST_UNDEFINED if an error occurs.  */
2303 int
2304 tofu_get_validity (const byte *fingerprint_bin, const char *user_id,
2305                    int may_ask)
2306 {
2307   struct db *dbs;
2308   char *fingerprint = NULL;
2309   char *email = NULL;
2310   int trust_level = TRUST_UNDEFINED;
2311
2312   dbs = opendbs ();
2313   if (! dbs)
2314     {
2315       log_error (_("error opening TOFU DB.\n"));
2316       goto die;
2317     }
2318
2319   fingerprint = fingerprint_pp (fingerprint_bin);
2320
2321   if (! *user_id)
2322     {
2323       log_debug ("user id is empty.  Can't get TOFU validity for this binding.\n");
2324       goto die;
2325     }
2326
2327   email = email_from_user_id (user_id);
2328
2329   trust_level = get_trust (dbs, fingerprint, email, user_id, may_ask);
2330   if (trust_level == GET_TRUST_ERROR)
2331     /* An error.  */
2332     trust_level = TRUST_UNDEFINED;
2333
2334   if (may_ask)
2335     show_statistics (dbs, fingerprint, email, user_id, NULL);
2336
2337  die:
2338   xfree (email);
2339   xfree (fingerprint);
2340   if (dbs)
2341     closedbs (dbs);
2342
2343   return trust_level;
2344 }
2345
2346 /* Set the policy for all non-revoked user ids in the keyblock KB to
2347    POLICY.
2348
2349    If no key is available with the specified key id, then this
2350    function returns GPG_ERR_NO_PUBKEY.
2351
2352    Returns 0 on success and an error code otherwise.  */
2353 gpg_error_t
2354 tofu_set_policy (kbnode_t kb, enum tofu_policy policy)
2355 {
2356   struct db *dbs;
2357   PKT_public_key *pk;
2358   char fingerprint_bin[MAX_FINGERPRINT_LEN];
2359   size_t fingerprint_bin_len = sizeof (fingerprint_bin);
2360   char *fingerprint = NULL;
2361
2362   assert (kb->pkt->pkttype == PKT_PUBLIC_KEY);
2363   pk = kb->pkt->pkt.public_key;
2364
2365   dbs = opendbs ();
2366   if (! dbs)
2367     {
2368       log_error (_("error opening TOFU DB.\n"));
2369       return gpg_error (GPG_ERR_GENERAL);
2370     }
2371
2372   if (DBG_TRUST)
2373     log_debug ("Setting TOFU policy for %s to %s\n",
2374                keystr (pk->keyid), tofu_policy_str (policy));
2375   if (! (pk->main_keyid[0] == pk->keyid[0]
2376          && pk->main_keyid[1] == pk->keyid[1]))
2377     log_bug ("%s: Passed a subkey, but expecting a primary key.\n", __func__);
2378
2379   fingerprint_from_pk (pk, fingerprint_bin, &fingerprint_bin_len);
2380   assert (fingerprint_bin_len == sizeof (fingerprint_bin));
2381
2382   fingerprint = fingerprint_pp (fingerprint_bin);
2383
2384   for (; kb; kb = kb->next)
2385     {
2386       PKT_user_id *user_id;
2387       char *email;
2388
2389       if (kb->pkt->pkttype != PKT_USER_ID)
2390         continue;
2391
2392       user_id = kb->pkt->pkt.user_id;
2393       if (user_id->is_revoked)
2394         /* Skip revoked user ids.  (Don't skip expired user ids, the
2395            expiry can be changed.)  */
2396         continue;
2397
2398       email = email_from_user_id (user_id->name);
2399
2400       record_binding (dbs, fingerprint, email, user_id->name, policy, 1);
2401
2402       xfree (email);
2403     }
2404
2405   xfree (fingerprint);
2406   closedbs (dbs);
2407
2408   return 0;
2409 }
2410
2411 /* Set the TOFU policy for all non-revoked user ids in the KEY with
2412    the key id KEYID to POLICY.
2413
2414    If no key is available with the specified key id, then this
2415    function returns GPG_ERR_NO_PUBKEY.
2416
2417    Returns 0 on success and an error code otherwise.  */
2418 gpg_error_t
2419 tofu_set_policy_by_keyid (u32 *keyid, enum tofu_policy policy)
2420 {
2421   kbnode_t keyblock = get_pubkeyblock (keyid);
2422   if (! keyblock)
2423     return gpg_error (GPG_ERR_NO_PUBKEY);
2424
2425   return tofu_set_policy (keyblock, policy);
2426 }
2427
2428 /* Return the TOFU policy for the specified binding in *POLICY.  If no
2429    policy has been set for the binding, sets *POLICY to
2430    TOFU_POLICY_NONE.
2431
2432    PK is a primary public key and USER_ID is a user id.
2433
2434    Returns 0 on success and an error code otherwise.  */
2435 gpg_error_t
2436 tofu_get_policy (PKT_public_key *pk, PKT_user_id *user_id,
2437                  enum tofu_policy *policy)
2438 {
2439   struct db *dbs;
2440   char fingerprint_bin[MAX_FINGERPRINT_LEN];
2441   size_t fingerprint_bin_len = sizeof (fingerprint_bin);
2442   char *fingerprint;
2443   char *email;
2444
2445   /* Make sure PK is a primary key.  */
2446   assert (pk->main_keyid[0] == pk->keyid[0]
2447           && pk->main_keyid[1] == pk->keyid[1]);
2448
2449   dbs = opendbs ();
2450   if (! dbs)
2451     {
2452       log_error (_("error opening TOFU DB.\n"));
2453       return gpg_error (GPG_ERR_GENERAL);
2454     }
2455
2456   fingerprint_from_pk (pk, fingerprint_bin, &fingerprint_bin_len);
2457   assert (fingerprint_bin_len == sizeof (fingerprint_bin));
2458
2459   fingerprint = fingerprint_pp (fingerprint_bin);
2460
2461   email = email_from_user_id (user_id->name);
2462
2463   *policy = get_policy (dbs, fingerprint, email, NULL);
2464
2465   xfree (email);
2466   xfree (fingerprint);
2467   closedbs (dbs);
2468
2469   if (*policy == GET_POLICY_ERROR)
2470     return gpg_error (GPG_ERR_GENERAL);
2471   return 0;
2472 }