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