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