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