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