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