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