gpg: Improve output.
[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   if (! argv[i])
1065     time_ago = 0;
1066   else
1067     {
1068       tail = NULL;
1069       errno = 0;
1070       time_ago = strtol (argv[i], &tail, 0);
1071       if (errno || ! (strcmp (tail, ".0") == 0 || *tail == '\0'))
1072         {
1073           /* Abort.  */
1074           log_error ("%s: Error converting %s to an integer (tail = '%s')\n",
1075                      __func__, argv[i], tail);
1076           return 1;
1077         }
1078     }
1079   i ++;
1080
1081   /* If time_ago is NULL, then we had no messages, but we still have a
1082      single row, which count(*) turns into 1.  */
1083   if (! argv[i - 1])
1084     count = 0;
1085   else
1086     {
1087       tail = NULL;
1088       errno = 0;
1089       count = strtoul (argv[i], &tail, 0);
1090       if (errno || ! (strcmp (tail, ".0") == 0 || *tail == '\0'))
1091         {
1092           /* Abort.  */
1093           log_error ("%s: Error converting %s to an integer (tail = '%s')\n",
1094                      __func__, argv[i], tail);
1095           return 1;
1096         }
1097     }
1098   i ++;
1099
1100   assert (argc == i);
1101
1102   signature_stats_prepend (statsp, argv[0], policy, time_ago, count);
1103
1104   return 0;
1105 }
1106
1107 /* Convert from seconds to time units.
1108
1109    Note: T should already be a multiple of TIME_AGO_UNIT_SMALL or
1110    TIME_AGO_UNIT_MEDIUM or TIME_AGO_UNIT_LARGE.  */
1111 signed long
1112 time_ago_scale (signed long t)
1113 {
1114   if (t < TIME_AGO_UNIT_MEDIUM)
1115     return t / TIME_AGO_UNIT_SMALL;
1116   if (t < TIME_AGO_UNIT_LARGE)
1117     return t / TIME_AGO_UNIT_MEDIUM;
1118   return t / TIME_AGO_UNIT_LARGE;
1119 }
1120
1121 /* Return the appropriate unit (respecting whether it is plural or
1122    singular).  */
1123 const char *
1124 time_ago_unit (signed long t)
1125 {
1126   signed long t_scaled = time_ago_scale (t);
1127
1128   if (t < TIME_AGO_UNIT_MEDIUM)
1129     {
1130       if (t_scaled == 1)
1131         return TIME_AGO_UNIT_SMALL_NAME;
1132       return TIME_AGO_UNIT_SMALL_NAME_PLURAL;
1133     }
1134   if (t < TIME_AGO_UNIT_LARGE)
1135     {
1136       if (t_scaled == 1)
1137         return TIME_AGO_UNIT_MEDIUM_NAME;
1138       return TIME_AGO_UNIT_MEDIUM_NAME_PLURAL;
1139     }
1140   if (t_scaled == 1)
1141     return TIME_AGO_UNIT_LARGE_NAME;
1142   return TIME_AGO_UNIT_LARGE_NAME_PLURAL;
1143 }
1144
1145
1146 /* Return the policy for the binding <FINGERPRINT, EMAIL> (email has
1147    already been normalized) and any conflict information in *CONFLICT
1148    if CONFLICT is not NULL.  Returns _tofu_GET_POLICY_ERROR if an error
1149    occurs.  */
1150 static enum tofu_policy
1151 get_policy (struct db *dbs, const char *fingerprint, const char *email,
1152             char **conflict)
1153 {
1154   sqlite3 *db;
1155   int rc;
1156   char *err = NULL;
1157   strlist_t strlist = NULL;
1158   char *tail = NULL;
1159   enum tofu_policy policy = _tofu_GET_POLICY_ERROR;
1160
1161   db = getdb (dbs, email, DB_EMAIL);
1162   if (! db)
1163     return _tofu_GET_POLICY_ERROR;
1164
1165   /* Check if the <FINGERPRINT, EMAIL> binding is known
1166      (TOFU_POLICY_NONE cannot appear in the DB.  Thus, if POLICY is
1167      still TOFU_POLICY_NONE after executing the query, then the
1168      result set was empty.)  */
1169   rc = sqlite3_exec_printf
1170     (db, strings_collect_cb, &strlist, &err,
1171      "select policy, conflict from bindings\n"
1172      " where fingerprint = %Q and email = %Q",
1173      fingerprint, email);
1174   if (rc)
1175     {
1176       log_error (_("error reading from TOFU database"
1177                    " (checking for existing bad bindings): %s\n"),
1178                  err);
1179       sqlite3_free (err);
1180       goto out;
1181     }
1182
1183   if (strlist_length (strlist) == 0)
1184     /* No results.  */
1185     {
1186       policy = TOFU_POLICY_NONE;
1187       goto out;
1188     }
1189   else if (strlist_length (strlist) != 2)
1190     /* The result has the wrong form.  */
1191     {
1192       log_error (_("error reading from TOFU database"
1193                    " (checking for existing bad bindings):"
1194                    " expected 2 results, got %d\n"),
1195                  strlist_length (strlist));
1196       goto out;
1197     }
1198
1199   /* The result has the right form.  */
1200
1201   errno = 0;
1202   policy = strtol (strlist->d, &tail, 0);
1203   if (errno || *tail != '\0')
1204     {
1205       log_error (_("error reading from TOFU database: bad value for policy: %s\n"),
1206                  strlist->d);
1207       goto out;
1208     }
1209
1210   if (! (policy == TOFU_POLICY_AUTO
1211          || policy == TOFU_POLICY_GOOD
1212          || policy == TOFU_POLICY_UNKNOWN
1213          || policy == TOFU_POLICY_BAD
1214          || policy == TOFU_POLICY_ASK))
1215     {
1216       log_error (_("TOFU DB is corrupted.  Invalid value for policy (%d).\n"),
1217                  policy);
1218       policy = _tofu_GET_POLICY_ERROR;
1219       goto out;
1220     }
1221
1222
1223   /* If CONFLICT is set, then policy should be TOFU_POLICY_ASK.  But,
1224      just in case, we do the check again here and ignore the conflict
1225      is POLICY is not TOFU_POLICY_ASK.  */
1226   if (conflict)
1227     {
1228       if (policy == TOFU_POLICY_ASK && *strlist->next->d)
1229         *conflict = xstrdup (strlist->next->d);
1230       else
1231         *conflict = NULL;
1232     }
1233
1234  out:
1235   assert (policy == _tofu_GET_POLICY_ERROR
1236           || policy == TOFU_POLICY_NONE
1237           || policy == TOFU_POLICY_AUTO
1238           || policy == TOFU_POLICY_GOOD
1239           || policy == TOFU_POLICY_UNKNOWN
1240           || policy == TOFU_POLICY_BAD
1241           || policy == TOFU_POLICY_ASK);
1242
1243   free_strlist (strlist);
1244
1245   return policy;
1246 }
1247
1248 /* Return the trust level (TRUST_NEVER, etc.) for the binding
1249    <FINGERPRINT, EMAIL> (email is already normalized).  If no policy
1250    is registered, returns TOFU_POLICY_NONE.  If an error occurs,
1251    returns _tofu_GET_TRUST_ERROR.
1252
1253    USER_ID is the unadultered user id.
1254
1255    If MAY_ASK is set, then we may interact with the user.  This is
1256    necessary if there is a conflict or the binding's policy is
1257    TOFU_POLICY_ASK.  In the case of a conflict, we set the new
1258    conflicting binding's policy to TOFU_POLICY_ASK.  In either case,
1259    we return TRUST_UNDEFINED.  */
1260 static enum tofu_policy
1261 get_trust (struct db *dbs, const char *fingerprint, const char *email,
1262            const char *user_id, int may_ask)
1263 {
1264   sqlite3 *db;
1265   enum tofu_policy policy;
1266   char *conflict = NULL;
1267   int rc;
1268   char *err = NULL;
1269   strlist_t bindings_with_this_email = NULL;
1270   int bindings_with_this_email_count;
1271   int change_conflicting_to_ask = 0;
1272   int trust_level = TRUST_UNKNOWN;
1273
1274   if (opt.batch)
1275     may_ask = 0;
1276
1277   /* Make sure _tofu_GET_TRUST_ERROR isn't equal to any of the trust
1278      levels.  */
1279   assert (_tofu_GET_TRUST_ERROR != TRUST_UNKNOWN
1280           && _tofu_GET_TRUST_ERROR != TRUST_EXPIRED
1281           && _tofu_GET_TRUST_ERROR != TRUST_UNDEFINED
1282           && _tofu_GET_TRUST_ERROR != TRUST_NEVER
1283           && _tofu_GET_TRUST_ERROR != TRUST_MARGINAL
1284           && _tofu_GET_TRUST_ERROR != TRUST_FULLY
1285           && _tofu_GET_TRUST_ERROR != TRUST_ULTIMATE);
1286
1287   db = getdb (dbs, email, DB_EMAIL);
1288   if (! db)
1289     return _tofu_GET_TRUST_ERROR;
1290
1291   policy = get_policy (dbs, fingerprint, email, &conflict);
1292   if (policy == TOFU_POLICY_AUTO)
1293     {
1294       policy = opt.tofu_default_policy;
1295       if (DBG_TRUST)
1296         log_debug ("TOFU: binding <%s, %s>'s policy is auto (default: %s).\n",
1297                    fingerprint, email,
1298                    tofu_policy_str (opt.tofu_default_policy));
1299     }
1300   switch (policy)
1301     {
1302     case TOFU_POLICY_AUTO:
1303     case TOFU_POLICY_GOOD:
1304     case TOFU_POLICY_UNKNOWN:
1305     case TOFU_POLICY_BAD:
1306       /* The saved judgement is auto -> auto, good, unknown or bad.
1307          We don't need to ask the user anything.  */
1308       if (DBG_TRUST)
1309         log_debug ("TOFU: Known binding <%s, %s>'s policy: %s\n",
1310                    fingerprint, email, tofu_policy_str (policy));
1311       trust_level = tofu_policy_to_trust_level (policy);
1312       goto out;
1313
1314     case TOFU_POLICY_ASK:
1315       /* We need to ask the user what to do.  Case #1 or #2 below.  */
1316       if (! may_ask)
1317         {
1318           trust_level = TRUST_UNDEFINED;
1319           goto out;
1320         }
1321
1322       break;
1323
1324     case TOFU_POLICY_NONE:
1325       /* The binding is new, we need to check for conflicts.  Case #3
1326          below.  */
1327       break;
1328
1329     case _tofu_GET_POLICY_ERROR:
1330       trust_level = _tofu_GET_TRUST_ERROR;
1331       goto out;
1332
1333     default:
1334       log_bug ("%s: Impossible value for policy (%d)\n", __func__, policy);
1335     }
1336
1337
1338   /* We get here if:
1339
1340        1. The saved policy is auto and the default policy is ask
1341           (get_policy() == TOFU_POLICY_AUTO
1342            && opt.tofu_default_policy == TOFU_POLICY_ASK)
1343
1344        2. The saved policy is ask (either last time the user selected
1345           accept once or reject once or there was a conflict and this
1346           binding's policy was changed from auto to ask)
1347           (policy == TOFU_POLICY_ASK), or,
1348
1349        3. We don't have a saved policy (policy == TOFU_POLICY_NONE)
1350           (need to check for a conflict).
1351    */
1352
1353   /* Look for conflicts.  This is need in all 3 cases.
1354
1355      Get the fingerprints of any bindings that share the email
1356      address.  Note: if the binding in question is in the DB, it will
1357      also be returned.  Thus, if the result set is empty, then this is
1358      a new binding.  */
1359   rc = sqlite3_exec_printf
1360     (db, strings_collect_cb, &bindings_with_this_email, &err,
1361      "select distinct fingerprint from bindings where email = %Q;",
1362      email);
1363   if (rc)
1364     {
1365       log_error (_("error reading from TOFU database"
1366                    " (listing fingerprints): %s\n"),
1367                  err);
1368       sqlite3_free (err);
1369       goto out;
1370     }
1371
1372   bindings_with_this_email_count = strlist_length (bindings_with_this_email);
1373   if (bindings_with_this_email_count == 0
1374       && opt.tofu_default_policy != TOFU_POLICY_ASK)
1375     /* New binding with no conflict and a concrete default policy.
1376
1377        We've never observed a binding with this email address
1378        (BINDINGS_WITH_THIS_EMAIL_COUNT is 0 and the above query would return
1379        the current binding if it were in the DB) and we have a default
1380        policy, which is not to ask the user.  */
1381     {
1382       /* If we've seen this binding, then we've seen this email and
1383          policy couldn't possibly be TOFU_POLICY_NONE.  */
1384       assert (policy == TOFU_POLICY_NONE);
1385
1386       if (DBG_TRUST)
1387         log_debug ("TOFU: New binding <%s, %s>, no conflict.\n",
1388                    email, fingerprint);
1389
1390       if (record_binding (dbs, fingerprint, email, user_id,
1391                           TOFU_POLICY_AUTO, 0) != 0)
1392         {
1393           log_error (_("error setting TOFU binding's trust level to %s\n"),
1394                        "auto");
1395           trust_level = _tofu_GET_TRUST_ERROR;
1396           goto out;
1397         }
1398
1399       trust_level = tofu_policy_to_trust_level (TOFU_POLICY_AUTO);
1400       goto out;
1401     }
1402
1403   if (policy == TOFU_POLICY_NONE)
1404     /* This is a new binding and we have a conflict.  Mark any
1405        conflicting bindings that have an automatic policy as now
1406        requiring confirmation.  Note: we delay this until after we ask
1407        for confirmation so that when the current policy is printed, it
1408        is correct.  */
1409     change_conflicting_to_ask = 1;
1410
1411   if (! may_ask)
1412     /* We can only get here in the third case (no saved policy) and if
1413        there is a conflict.  (If the policy was ask (cases #1 and #2)
1414        and we weren't allowed to ask, we'd have already exited).  */
1415     {
1416       assert (policy == TOFU_POLICY_NONE);
1417
1418       if (record_binding (dbs, fingerprint, email, user_id,
1419                           TOFU_POLICY_ASK, 0) != 0)
1420         log_error (_("error setting TOFU binding's trust level to %s\n"),
1421                    "ask");
1422
1423       trust_level = TRUST_UNDEFINED;
1424       goto out;
1425     }
1426
1427   /* If we get here, we need to ask the user about the binding.  There
1428      are three ways we could end up here:
1429
1430        - This is a new binding and there is a conflict
1431          (policy == TOFU_POLICY_NONE && bindings_with_this_email_count > 0),
1432
1433        - This is a new binding and opt.tofu_default_policy is set to
1434          ask.  (policy == TOFU_POLICY_NONE && opt.tofu_default_policy ==
1435          TOFU_POLICY_ASK), or,
1436
1437        - The policy is ask (the user deferred last time) (policy ==
1438          TOFU_POLICY_ASK).
1439    */
1440   {
1441     int is_conflict =
1442       ((policy == TOFU_POLICY_NONE && bindings_with_this_email_count > 0)
1443        || (policy == TOFU_POLICY_ASK && conflict));
1444     estream_t fp;
1445     char *binding;
1446     int binding_shown;
1447     strlist_t other_user_ids = NULL;
1448     struct signature_stats *stats = NULL;
1449     struct signature_stats *stats_iter = NULL;
1450     char *prompt;
1451     char *choices;
1452
1453     fp = es_fopenmem (0, "rw,samethread");
1454     if (! fp)
1455       log_fatal ("Error creating memory stream\n");
1456
1457     binding = xasprintf ("<%s, %s>", fingerprint, email);
1458     binding_shown = 0;
1459
1460     if (policy == TOFU_POLICY_NONE)
1461       {
1462         es_fprintf (fp, _("The binding %s is NOT known.  "), binding);
1463         binding_shown = 1;
1464       }
1465     else if (policy == TOFU_POLICY_ASK
1466              /* If there the conflict is with itself, then don't
1467                 display this message.  */
1468              && conflict && strcmp (conflict, fingerprint) != 0)
1469       {
1470         es_fprintf (fp,
1471                     _("The key %s raised a conflict with this binding (%s)."
1472                       "  Since this binding's policy was 'auto', it was"
1473                       "changed to 'ask'.  "),
1474                     conflict, binding);
1475         binding_shown = 1;
1476       }
1477     es_fprintf (fp,
1478                 _("Please indicate whether you believe the binding %s%s"
1479                   "is legitimate (the key belongs to the stated owner) "
1480                   "or a forgery (bad).\n\n"),
1481                 binding_shown ? "" : binding,
1482                 binding_shown ? "" : " ");
1483
1484     xfree (binding);
1485
1486     /* Find other user ids associated with this key and whether the
1487        bindings are marked as good or bad.  */
1488     {
1489       sqlite3 *db_key;
1490
1491       if (opt.tofu_db_format == TOFU_DB_SPLIT)
1492         /* In the split format, we need to search in the fingerprint
1493            DB for all the emails associated with this key, not the
1494            email DB.  */
1495         db_key = getdb (dbs, fingerprint, DB_KEY);
1496       else
1497         db_key = db;
1498
1499       if (db_key)
1500         {
1501           rc = sqlite3_exec_printf
1502             (db_key, strings_collect_cb, &other_user_ids, &err,
1503              "select user_id, %s from bindings where fingerprint = %Q;",
1504              opt.tofu_db_format == TOFU_DB_SPLIT ? "email" : "policy",
1505              fingerprint);
1506           if (rc)
1507             {
1508               log_error (_("error gathering other user ids: %s.\n"), err);
1509               sqlite3_free (err);
1510               err = NULL;
1511             }
1512         }
1513     }
1514
1515     if (other_user_ids)
1516       {
1517         strlist_t strlist_iter;
1518
1519         es_fprintf (fp, _("Known user ids associated with this key:\n"));
1520         for (strlist_iter = other_user_ids;
1521              strlist_iter;
1522              strlist_iter = strlist_iter->next)
1523           {
1524             char *other_user_id = strlist_iter->d;
1525             char *other_thing;
1526             enum tofu_policy other_policy;
1527
1528             assert (strlist_iter->next);
1529             strlist_iter = strlist_iter->next;
1530             other_thing = strlist_iter->d;
1531
1532             if (opt.tofu_db_format == TOFU_DB_SPLIT)
1533               other_policy = get_policy (dbs, fingerprint, other_thing, NULL);
1534             else
1535               other_policy = atoi (other_thing);
1536
1537             es_fprintf (fp, _("  %s (policy: %s)\n"),
1538                         other_user_id,
1539                         tofu_policy_str (other_policy));
1540           }
1541         es_fprintf (fp, "\n");
1542
1543         free_strlist (other_user_ids);
1544       }
1545
1546     /* Find other keys associated with this email address.  */
1547     /* XXX: When generating the statistics, do we want the time
1548        embedded in the signature (column 'sig_time') or the time that
1549        we first verified the signature (column 'time').  */
1550     rc = sqlite3_exec_printf
1551       (db, signature_stats_collect_cb, &stats, &err,
1552        "select fingerprint, policy, time_ago, count(*)\n"
1553        " from (select bindings.*,\n"
1554        "        case\n"
1555        /* From the future (but if its just a couple of hours in the
1556           future don't turn it into a warning)?  Or should we use
1557           small, medium or large units?  (Note: whatever we do, we
1558           keep the value in seconds.  Then when we group, everything
1559           that rounds to the same number of seconds is grouped.)  */
1560        "         when delta < -%d then -1\n"
1561        "         when delta < %d then max(0, round(delta / %d) * %d)\n"
1562        "         when delta < %d then round(delta / %d) * %d\n"
1563        "         else round(delta / %d) * %d\n"
1564        "        end time_ago,\n"
1565        "        delta time_ago_raw\n"
1566        "       from bindings\n"
1567        "       left join\n"
1568        "         (select *,\n"
1569        "            cast(strftime('%%s','now') - sig_time as real) delta\n"
1570        "           from signatures) ss\n"
1571        "        on ss.binding = bindings.oid)\n"
1572        " where email = %Q\n"
1573        " group by fingerprint, time_ago\n"
1574        /* Make sure the current key is first.  */
1575        " order by fingerprint = %Q asc, fingerprint desc, time_ago desc;\n",
1576        TIME_AGO_FUTURE_IGNORE,
1577        TIME_AGO_MEDIUM_THRESHOLD, TIME_AGO_UNIT_SMALL, TIME_AGO_UNIT_SMALL,
1578        TIME_AGO_LARGE_THRESHOLD, TIME_AGO_UNIT_MEDIUM, TIME_AGO_UNIT_MEDIUM,
1579        TIME_AGO_UNIT_LARGE, TIME_AGO_UNIT_LARGE,
1580        email, fingerprint);
1581     if (rc)
1582       {
1583         strlist_t strlist_iter;
1584
1585         log_error (_("error gathering signature stats: %s.\n"),
1586                    err);
1587         sqlite3_free (err);
1588         err = NULL;
1589
1590         es_fprintf
1591           (fp, _("The email address (%s) is associated with %d keys:\n"),
1592            email, bindings_with_this_email_count);
1593         for (strlist_iter = bindings_with_this_email;
1594              strlist_iter;
1595              strlist_iter = strlist_iter->next)
1596           es_fprintf (fp, _("  %s\n"), strlist_iter->d);
1597       }
1598     else
1599       {
1600         char *key = NULL;
1601
1602         if (! stats || strcmp (stats->fingerprint, fingerprint) != 0)
1603           /* If we have already added this key to the DB, then it will
1604              be first (see the above select).  Since the first key on
1605              the list is not this key, we must not yet have verified
1606              any messages signed by this key.  Add a dummy entry.  */
1607           signature_stats_prepend (&stats, fingerprint, TOFU_POLICY_AUTO, 0, 0);
1608
1609         es_fprintf (fp, _("Statistics for keys with the email '%s':\n"),
1610                     email);
1611         for (stats_iter = stats; stats_iter; stats_iter = stats_iter->next)
1612           {
1613             if (! key || strcmp (key, stats_iter->fingerprint) != 0)
1614               {
1615                 int this_key;
1616                 key = stats_iter->fingerprint;
1617                 this_key = strcmp (key, fingerprint) == 0;
1618                 if (this_key)
1619                   es_fprintf (fp, _("  %s (this key):"), key);
1620                 else
1621                   es_fprintf (fp, _("  %s (policy: %s):"),
1622                               key, tofu_policy_str (stats_iter->policy));
1623                 es_fprintf (fp, "\n");
1624               }
1625
1626             if (stats_iter->time_ago == -1)
1627               es_fprintf (fp, _("    %ld %s signed in the future.\n"),
1628                           stats_iter->count,
1629                           stats_iter->count == 1
1630                           ? _("message") : _("messages"));
1631             else if (stats_iter->count == 0)
1632               es_fprintf (fp, _("    0 signed messages.\n"));
1633             else
1634               es_fprintf (fp, _("    %ld %s signed over the past %ld %s.\n"),
1635                           stats_iter->count,
1636                           stats_iter->count == 1
1637                           ? _("message") : _("messages"),
1638                           time_ago_scale (stats_iter->time_ago),
1639                           time_ago_unit (stats_iter->time_ago));
1640           }
1641       }
1642
1643     if (is_conflict)
1644       {
1645         /* TRANSLATORS: translate the below text.  We don't directly
1646            internationalize that text so that we can tweak it without
1647            breaking translations.  */
1648         char *text = _("TOFU detected a binding conflict");
1649         if (strcmp (text, "TOFU detected a binding conflict") == 0)
1650           /* No translation.  Use the English text.  */
1651           text =
1652             "Normally, there is only a single key associated with an email "
1653             "address.  However, people sometimes generate a new key if "
1654             "their key is too old or they think it might be compromised.  "
1655             "Alternatively, a new key may indicate a man-in-the-middle"
1656             "attack!  Before accepting this key, you should talk to or "
1657             "call the person to make sure this new key is legitimate.";
1658         es_fprintf (fp, "\n%s\n", text);
1659       }
1660
1661     es_fputc ('\n', fp);
1662     /* TRANSLATORS: Two letters (normally the lower and upper case
1663        version of the hotkey) for each of the five choices.  If there
1664        is only one choice in your language, repeat it.  */
1665     choices = _("gG" "aA" "uU" "rR" "bB");
1666     es_fprintf (fp, _("(G)ood/(A)ccept once/(U)nknown/(R)eject once/(B)ad? "));
1667
1668     /* Add a NUL terminator.  */
1669     es_fputc (0, fp);
1670     if (es_fclose_snatch (fp, (void **) &prompt, NULL))
1671       log_fatal ("error snatching memory stream\n");
1672
1673     while (1)
1674       {
1675         char *response;
1676
1677         if (strlen (choices) != 10)
1678           log_bug ("Bad TOFU conflict translation!  Please report.");
1679
1680         response = cpr_get ("tofu conflict", prompt);
1681         trim_spaces (response);
1682         cpr_kill_prompt ();
1683         if (strlen (response) == 1)
1684           {
1685             char *choice = strchr (choices, *response);
1686             if (choice)
1687               {
1688                 int c = ((size_t) choice - (size_t) choices) / 2;
1689                 assert (0 <= c && c <= 4);
1690
1691                 switch (c)
1692                   {
1693                   case 0: /* Good.  */
1694                     policy = TOFU_POLICY_GOOD;
1695                     trust_level = tofu_policy_to_trust_level (policy);
1696                     break;
1697                   case 1: /* Accept once.  */
1698                     policy = TOFU_POLICY_ASK;
1699                     trust_level =
1700                       tofu_policy_to_trust_level (TOFU_POLICY_GOOD);
1701                     break;
1702                   case 2: /* Unknown.  */
1703                     policy = TOFU_POLICY_UNKNOWN;
1704                     trust_level = tofu_policy_to_trust_level (policy);
1705                     break;
1706                   case 3: /* Reject once.  */
1707                     policy = TOFU_POLICY_ASK;
1708                     trust_level =
1709                       tofu_policy_to_trust_level (TOFU_POLICY_BAD);
1710                     break;
1711                   case 4: /* Bad.  */
1712                     policy = TOFU_POLICY_BAD;
1713                     trust_level = tofu_policy_to_trust_level (policy);
1714                     break;
1715                   default:
1716                     log_bug ("c should be between 0 and 4 but it is %d!", c);
1717                   }
1718
1719                 if (record_binding (dbs, fingerprint, email, user_id,
1720                                     policy, 0) != 0)
1721                   /* If there's an error registering the
1722                      binding, don't save the signature.  */
1723                   trust_level = _tofu_GET_TRUST_ERROR;
1724
1725                 break;
1726               }
1727           }
1728         xfree (response);
1729       }
1730
1731     xfree (prompt);
1732
1733     signature_stats_free (stats);
1734   }
1735
1736  out:
1737   if (change_conflicting_to_ask)
1738     {
1739       if (! may_ask)
1740         /* If we weren't allowed to ask, also update this key as
1741            conflicting with itself.  */
1742         rc = sqlite3_exec_printf
1743           (db, NULL, NULL, &err,
1744            "update bindings set policy = %d, conflict = %Q"
1745            " where email = %Q"
1746            "  and (policy = %d or (policy = %d and fingerprint = %Q));",
1747            TOFU_POLICY_ASK, fingerprint, email, TOFU_POLICY_AUTO,
1748            TOFU_POLICY_ASK, fingerprint);
1749       else
1750         rc = sqlite3_exec_printf
1751           (db, NULL, NULL, &err,
1752            "update bindings set policy = %d, conflict = %Q"
1753            " where email = %Q and fingerprint != %Q and policy = %d;",
1754            TOFU_POLICY_ASK, fingerprint, email, fingerprint, TOFU_POLICY_AUTO);
1755       if (rc)
1756         {
1757           log_error (_("error changing TOFU policy: %s\n"), err);
1758           sqlite3_free (err);
1759           goto out;
1760         }
1761     }
1762
1763   xfree (conflict);
1764   free_strlist (bindings_with_this_email);
1765
1766   return trust_level;
1767 }
1768
1769 static void
1770 show_statistics (struct db *dbs, const char *fingerprint,
1771                  const char *email, const char *user_id,
1772                  const char *sig_exclude)
1773 {
1774   sqlite3 *db;
1775   int rc;
1776   strlist_t strlist = NULL;
1777   char *err = NULL;
1778
1779   db = getdb (dbs, email, DB_EMAIL);
1780   if (! db)
1781     return;
1782
1783   rc = sqlite3_exec_printf
1784     (db, strings_collect_cb, &strlist, &err,
1785      "select count (*), strftime('%%s','now') - min (signatures.time)\n"
1786      " from signatures\n"
1787      " left join bindings on signatures.binding = bindings.oid\n"
1788      " where fingerprint = %Q and email = %Q and sig_digest %s%s%s;",
1789      fingerprint, email,
1790      /* We want either: sig_digest != 'SIG_EXCLUDE' or sig_digest is
1791         not NULL.  */
1792      sig_exclude ? "!= '" : "is not NULL",
1793      sig_exclude ? sig_exclude : "",
1794      sig_exclude ? "'" : "");
1795   if (rc)
1796     {
1797       log_error (_("error reading from TOFU database"
1798                    " (getting statistics): %s\n"),
1799                  err);
1800       sqlite3_free (err);
1801       goto out;
1802     }
1803
1804   if (! strlist)
1805     log_info (_("Have never verified a message signed by key %s!\n"),
1806               fingerprint);
1807   else
1808     {
1809       char *tail = NULL;
1810       signed long messages;
1811       signed long first_seen_ago;
1812
1813       assert (strlist_length (strlist) == 2);
1814
1815       errno = 0;
1816       messages = strtol (strlist->d, &tail, 0);
1817       if (errno || *tail != '\0')
1818         /* Abort.  */
1819         {
1820           log_debug ("%s:%d: Couldn't convert %s (messages) to an int: %s.\n",
1821                      __func__, __LINE__, strlist->d, strerror (errno));
1822           messages = -1;
1823         }
1824
1825       if (messages == 0 && *strlist->next->d == '\0')
1826         /* min(NULL) => NULL => "".  */
1827         first_seen_ago = -1;
1828       else
1829         {
1830           errno = 0;
1831           first_seen_ago = strtol (strlist->next->d, &tail, 0);
1832           if (errno || *tail != '\0')
1833             /* Abort.  */
1834             {
1835               log_debug ("%s:%d: Cound't convert %s (first_seen) to an int: %s.\n",
1836                          __func__, __LINE__,
1837                          strlist->next->d, strerror (errno));
1838               first_seen_ago = 0;
1839             }
1840         }
1841
1842       if (messages == -1 || first_seen_ago == 0)
1843         log_info (_("Failed to collect signature statistics for \"%s\" (key %s)\n"),
1844                   user_id, fingerprint);
1845       else
1846         {
1847           enum tofu_policy policy = get_policy (dbs, fingerprint, email, NULL);
1848           estream_t fp;
1849           char *msg;
1850
1851           fp = es_fopenmem (0, "rw,samethread");
1852           if (! fp)
1853             log_fatal ("error creating memory stream\n");
1854
1855           if (messages == 0)
1856             es_fprintf (fp,
1857                         _("Verified 0 messages signed by \"%s\""
1858                           " (key: %s, policy %s)."),
1859                         user_id, fingerprint, tofu_policy_str (policy));
1860           else
1861             {
1862               int years = 0;
1863               int months = 0;
1864               int days = 0;
1865               int hours = 0;
1866               int minutes = 0;
1867               int seconds = 0;
1868
1869               /* The number of units that we've printed so far.  */
1870               int count = 0;
1871               /* The first unit that we printed (year = 0, month = 1,
1872                  etc.).  */
1873               int first = -1;
1874               /* The current unit.  */
1875               int i = 0;
1876
1877               es_fprintf (fp,
1878                           _("Verified %ld messages signed by \"%s\""
1879                             " (key: %s, policy: %s) in the past "),
1880                           messages, user_id,
1881                           fingerprint, tofu_policy_str (policy));
1882
1883               /* It would be nice to use a macro to do this, but gettext
1884                  works on the unpreprocessed code.  */
1885 #define MIN_SECS (60)
1886 #define HOUR_SECS (60 * MIN_SECS)
1887 #define DAY_SECS (24 * HOUR_SECS)
1888 #define MONTH_SECS (30 * DAY_SECS)
1889 #define YEAR_SECS (365 * DAY_SECS)
1890
1891               if (first_seen_ago > YEAR_SECS)
1892                 {
1893                   years = first_seen_ago / YEAR_SECS;
1894                   first_seen_ago -= years * YEAR_SECS;
1895                 }
1896               if (first_seen_ago > MONTH_SECS)
1897                 {
1898                   months = first_seen_ago / MONTH_SECS;
1899                   first_seen_ago -= months * MONTH_SECS;
1900                 }
1901               if (first_seen_ago > DAY_SECS)
1902                 {
1903                   days = first_seen_ago / DAY_SECS;
1904                   first_seen_ago -= days * DAY_SECS;
1905                 }
1906               if (first_seen_ago > HOUR_SECS)
1907                 {
1908                   hours = first_seen_ago / HOUR_SECS;
1909                   first_seen_ago -= hours * HOUR_SECS;
1910                 }
1911               if (first_seen_ago > MIN_SECS)
1912                 {
1913                   minutes = first_seen_ago / MIN_SECS;
1914                   first_seen_ago -= minutes * MIN_SECS;
1915                 }
1916               seconds = first_seen_ago;
1917
1918 #undef MIN_SECS
1919 #undef HOUR_SECS
1920 #undef DAY_SECS
1921 #undef MONTH_SECS
1922 #undef YEAR_SECS
1923
1924               if (years)
1925                 {
1926                   if (years > 1)
1927                     es_fprintf (fp, _("%d years"), years);
1928                   else
1929                     es_fprintf (fp, _("%d year"), years);
1930                   count ++;
1931                   first = i;
1932                 }
1933               i ++;
1934               if ((first == -1 || i - first <= 3) && months)
1935                 {
1936                   if (count)
1937                     es_fprintf (fp, _(", "));
1938
1939                   if (months > 1)
1940                     es_fprintf (fp, _("%d months"), months);
1941                   else
1942                     es_fprintf (fp, _("%d month"), months);
1943                   count ++;
1944                   first = i;
1945                 }
1946               i ++;
1947               if ((first == -1 || i - first <= 3) && count < 2 && days)
1948                 {
1949                   if (count)
1950                     es_fprintf (fp, _(", "));
1951
1952                   if (days > 1)
1953                     es_fprintf (fp, _("%d days"), days);
1954                   else
1955                     es_fprintf (fp, _("%d day"), days);
1956                   count ++;
1957                   first = i;
1958                 }
1959               i ++;
1960               if ((first == -1 || i - first <= 3) && count < 2 && hours)
1961                 {
1962                   if (count)
1963                     es_fprintf (fp, _(", "));
1964
1965                   if (hours > 1)
1966                     es_fprintf (fp, _("%d hours"), hours);
1967                   else
1968                     es_fprintf (fp, _("%d hour"), hours);
1969                   count ++;
1970                   first = i;
1971                 }
1972               i ++;
1973               if ((first == -1 || i - first <= 3) && count < 2 && minutes)
1974                 {
1975                   if (count)
1976                     es_fprintf (fp, _(", "));
1977
1978                   if (minutes > 1)
1979                     es_fprintf (fp, _("%d minutes"), minutes);
1980                   else
1981                     es_fprintf (fp, _("%d minute"), minutes);
1982                   count ++;
1983                   first = i;
1984                 }
1985               i ++;
1986               if ((first == -1 || i - first <= 3) && count < 2)
1987                 {
1988                   if (count)
1989                     es_fprintf (fp, _(", "));
1990
1991                   if (seconds > 1)
1992                     es_fprintf (fp, _("%d seconds"), seconds);
1993                   else
1994                     es_fprintf (fp, _("%d second"), seconds);
1995                 }
1996
1997               es_fprintf (fp, _("."));
1998             }
1999
2000           es_fputc (0, fp);
2001           if (es_fclose_snatch (fp, (void **) &msg, NULL))
2002             log_fatal ("error snatching memory stream\n");
2003
2004           log_info ("%s\n", msg);
2005
2006           if (policy == TOFU_POLICY_AUTO && messages < 10)
2007             {
2008               char *set_policy_command;
2009               const char *text;
2010
2011               if (messages == 0)
2012                 log_info (_("Warning: we've have yet to see a message signed by this key!\n"));
2013               else if (messages == 1)
2014                 log_info (_("Warning: we've only seen a single message signed by this key!\n"));
2015
2016               set_policy_command =
2017                 xasprintf ("gpg --tofu-policy bad \"%s\"", fingerprint);
2018               /* TRANSLATORS: translate the below text.  We don't
2019                  directly internationalize that text so that we can
2020                  tweak it without breaking translations.  */
2021               text = _("TOFU: few signatures %d %s %s");
2022               if (strcmp (text, "TOFU: few signatures %d %s %s") == 0)
2023                 text =
2024                   "Warning: if you think you've seen more than %d %s "
2025                   "signed by this key, then this key might be a forgery!  "
2026                   "Carefully examine the email address for small variations "
2027                   "(e.g., additional white space).  If the key is suspect, "
2028                   "then use '%s' to mark it as being bad.\n";
2029               log_info (text,
2030                         messages, messages == 1 ? _("message") : _("message"),
2031                         set_policy_command);
2032               free (set_policy_command);
2033             }
2034         }
2035     }
2036
2037  out:
2038   free_strlist (strlist);
2039
2040   return;
2041 }
2042
2043 /* Extract the email address from a user id and normalize it.  If the
2044    user id doesn't contain an email address, then we use the whole
2045    user_id and normalize that.  The returned string must be freed.  */
2046 static char *
2047 email_from_user_id (const char *user_id)
2048 {
2049   char *email = mailbox_from_userid (user_id);
2050   if (! email)
2051     /* Hmm, no email address was provided.  Just take the lower-case
2052        version of the whole user id.  It could be a hostname, for
2053        instance.  */
2054     email = ascii_strlwr (xstrdup (user_id));
2055
2056   return email;
2057 }
2058
2059 /* Pretty print a MAX_FINGERPRINT_LEN-byte binary fingerprint into a
2060    malloc'd string.  */
2061 static char *
2062 fingerprint_pp (const byte *fingerprint_bin)
2063 {
2064   char fingerprint[MAX_FINGERPRINT_LEN * 2 + 1];
2065   char *fingerprint_pretty;
2066   int space = (/* The characters and the NUL.  */
2067                sizeof (fingerprint)
2068                /* After every fourth character, we add a space (except
2069                   the last).  */
2070                + (sizeof (fingerprint) - 1) / 4 - 1
2071                /* Half way through we add a second space.  */
2072                + 1);
2073   int i;
2074   int j;
2075
2076   bin2hex (fingerprint_bin, MAX_FINGERPRINT_LEN, fingerprint);
2077
2078   fingerprint_pretty = xmalloc (space);
2079
2080   for (i = 0, j = 0; i < MAX_FINGERPRINT_LEN * 2; i ++)
2081     {
2082       if (i && i % 4 == 0)
2083         fingerprint_pretty[j ++] = ' ';
2084       if (i == MAX_FINGERPRINT_LEN * 2 / 2)
2085         fingerprint_pretty[j ++] = ' ';
2086
2087       fingerprint_pretty[j ++] = fingerprint[i];
2088     }
2089   fingerprint_pretty[j ++] = 0;
2090   assert (j == space);
2091
2092   return fingerprint_pretty;
2093 }
2094
2095 /* Register the signature with the binding <FINGERPRINT_BIN, USER_ID>.
2096    FINGERPRINT must be MAX_FINGERPRINT_LEN bytes long.
2097
2098    SIG_DIGEST_BIN is the binary representation of the message's
2099    digest.  SIG_DIGEST_BIN_LEN is its length.
2100
2101    SIG_TIME is the time that the signature was generated.
2102
2103    ORIGIN is a free-formed string describing the origin of the
2104    signature.  If this was from an email and the Claws MUA was used,
2105    then this should be something like: "email:claws".  If this is
2106    NULL, the default is simply "unknown".
2107
2108    If MAY_ASK is 1, then this function may interact with the user.
2109    This is necessary if there is a conflict or the binding's policy is
2110    TOFU_POLICY_ASK.
2111
2112    This function returns the binding's trust level on return.  If an
2113    error occurs, this function returns TRUST_UNKNOWN.  */
2114 int
2115 tofu_register (const byte *fingerprint_bin, const char *user_id,
2116                const byte *sig_digest_bin, int sig_digest_bin_len,
2117                time_t sig_time, const char *origin, int may_ask)
2118 {
2119   struct db *dbs;
2120   sqlite3 *db;
2121   char *fingerprint = NULL;
2122   char *email = NULL;
2123   char *err = NULL;
2124   int rc;
2125   int trust_level = TRUST_UNKNOWN;
2126   char *sig_digest;
2127   unsigned long c;
2128   int already_verified = 0;
2129
2130   sig_digest = make_radix64_string (sig_digest_bin, sig_digest_bin_len);
2131
2132   dbs = opendbs ();
2133   if (! dbs)
2134     {
2135       log_error (_("error opening TOFU DB.\n"));
2136       goto die;
2137     }
2138
2139   fingerprint = fingerprint_pp (fingerprint_bin);
2140
2141   if (! *user_id)
2142     {
2143       log_debug ("TOFU: user id is empty.  Can't continue.\n");
2144       goto die;
2145     }
2146
2147   email = email_from_user_id (user_id);
2148
2149   if (! origin)
2150     /* The default origin is simply "unknown".  */
2151     origin = "unknown";
2152
2153   /* It's necessary to get the trust so that we are certain that the
2154      binding has been registered.  */
2155   trust_level = get_trust (dbs, fingerprint, email, user_id, may_ask);
2156   if (trust_level == _tofu_GET_TRUST_ERROR)
2157     /* An error.  */
2158     {
2159       trust_level = TRUST_UNKNOWN;
2160       goto die;
2161     }
2162
2163   /* Save the observed signature in the DB.  */
2164   db = getdb (dbs, email, DB_EMAIL);
2165   if (! db)
2166     {
2167       log_error (_("error opening TOFU DB.\n"));
2168       goto die;
2169     }
2170
2171   /* We do a query and then an insert.  Make sure they are atomic
2172      by wrapping them in a transaction.  */
2173   rc = sqlite3_exec (db, "begin transaction;", NULL, NULL, &err);
2174   if (rc)
2175     {
2176       log_error (_("error beginning transaction on TOFU database: %s\n"), err);
2177       sqlite3_free (err);
2178       goto die;
2179     }
2180
2181   /* If we've already seen this signature before, then don't add
2182      it again.  */
2183   rc = sqlite3_exec_printf
2184     (db, get_single_unsigned_long_cb, &c, &err,
2185      "select count (*)\n"
2186      " from signatures left join bindings\n"
2187      "  on signatures.binding = bindings.oid\n"
2188      " where fingerprint = %Q and email = %Q and sig_time = 0x%lx\n"
2189      "  and sig_digest = %Q",
2190      fingerprint, email, (unsigned long) sig_time, sig_digest);
2191   if (rc)
2192     {
2193       log_error (_("error reading from signatures database"
2194                    " (checking existence): %s\n"),
2195                  err);
2196       sqlite3_free (err);
2197     }
2198   else if (c > 1)
2199     /* Duplicates!  This should not happen.  In particular,
2200        because <fingerprint, email, sig_time, sig_digest> is the
2201        primary key!  */
2202     log_debug ("SIGNATURES DB contains duplicate records"
2203                " <key: %s, %s, time: 0x%lx, sig: %s, %s>."
2204                "  Please report.\n",
2205                fingerprint, email, (unsigned long) sig_time,
2206                sig_digest, origin);
2207   else if (c == 1)
2208     {
2209       already_verified = 1;
2210       if (DBG_TRUST)
2211         log_debug ("Already observed the signature"
2212                    " <key: %s, %s, time: 0x%lx, sig: %s, %s>\n",
2213                    fingerprint, email, (unsigned long) sig_time,
2214                    sig_digest, origin);
2215     }
2216   else
2217     /* This is the first time that we've seen this signature.
2218        Record it.  */
2219     {
2220       if (DBG_TRUST)
2221         log_debug ("TOFU: Saving signature <%s, %s, %s>\n",
2222                    fingerprint, email, sig_digest);
2223
2224       assert (c == 0);
2225
2226       rc = sqlite3_exec_printf
2227         (db, NULL, NULL, &err,
2228          "insert into signatures\n"
2229          " (binding, sig_digest, origin, sig_time, time)\n"
2230          " values\n"
2231          " ((select oid from bindings\n"
2232          "    where fingerprint = %Q and email = %Q),\n"
2233          "  %Q, %Q, 0x%lx, strftime('%%s', 'now'));",
2234          fingerprint, email, sig_digest, origin, (unsigned long) sig_time);
2235       if (rc)
2236         {
2237           log_error (_("error updating TOFU DB"
2238                        " (inserting into signatures table): %s\n"),
2239                      err);
2240           sqlite3_free (err);
2241         }
2242     }
2243
2244   /* It only matters whether we abort or commit the transaction
2245      (so long as we do something) if we execute the insert.  */
2246   if (rc)
2247     rc = sqlite3_exec (db, "rollback;", NULL, NULL, &err);
2248   else
2249     rc = sqlite3_exec (db, "commit transaction;", NULL, NULL, &err);
2250   if (rc)
2251     {
2252       log_error (_("error ending transaction on TOFU database: %s\n"), err);
2253       sqlite3_free (err);
2254       goto die;
2255     }
2256
2257  die:
2258   if (may_ask)
2259     /* It's only appropriate to show the statistics in an interactive
2260        context.  */
2261     show_statistics (dbs, fingerprint, email, user_id,
2262                      already_verified ? NULL : sig_digest);
2263
2264   xfree (email);
2265   xfree (fingerprint);
2266   if (dbs)
2267     closedbs (dbs);
2268   xfree (sig_digest);
2269
2270   return trust_level;
2271 }
2272
2273 /* Combine a trust level returned from the TOFU trust model with a
2274    trust level returned by the PGP trust model.  This is primarily of
2275    interest when the trust model is tofu+pgp (TM_TOFU_PGP).
2276
2277    This function ors together the upper bits (the values not covered
2278    by TRUST_MASK, i.e., TRUST_FLAG_REVOKED, etc.).  */
2279 int
2280 tofu_wot_trust_combine (int tofu_base, int wot_base)
2281 {
2282   int tofu = tofu_base & TRUST_MASK;
2283   int wot = wot_base & TRUST_MASK;
2284   int upper = (tofu_base & ~TRUST_MASK) | (wot_base & ~TRUST_MASK);
2285
2286   assert (tofu == TRUST_UNKNOWN
2287           || tofu == TRUST_EXPIRED
2288           || tofu == TRUST_UNDEFINED
2289           || tofu == TRUST_NEVER
2290           || tofu == TRUST_MARGINAL
2291           || tofu == TRUST_FULLY
2292           || tofu == TRUST_ULTIMATE);
2293   assert (wot == TRUST_UNKNOWN
2294           || wot == TRUST_EXPIRED
2295           || wot == TRUST_UNDEFINED
2296           || wot == TRUST_NEVER
2297           || wot == TRUST_MARGINAL
2298           || wot == TRUST_FULLY
2299           || wot == TRUST_ULTIMATE);
2300
2301   /* We first consider negative trust policys.  These trump positive
2302      trust policies.  */
2303   if (tofu == TRUST_NEVER || wot == TRUST_NEVER)
2304     /* TRUST_NEVER trumps everything else.  */
2305     return upper | TRUST_NEVER;
2306   if (tofu == TRUST_EXPIRED || wot == TRUST_EXPIRED)
2307     /* TRUST_EXPIRED trumps everything but TRUST_NEVER.  */
2308     return upper | TRUST_EXPIRED;
2309
2310   /* Now we only have positive or neutral trust policies.  We take
2311      the max.  */
2312   if (tofu == TRUST_ULTIMATE || wot == TRUST_ULTIMATE)
2313     return upper | TRUST_ULTIMATE;
2314   if (tofu == TRUST_FULLY || wot == TRUST_FULLY)
2315     return upper | TRUST_FULLY;
2316   if (tofu == TRUST_MARGINAL || wot == TRUST_MARGINAL)
2317     return upper | TRUST_MARGINAL;
2318   if (tofu == TRUST_UNDEFINED || wot == TRUST_UNDEFINED)
2319     return upper | TRUST_UNDEFINED;
2320   return upper | TRUST_UNKNOWN;
2321 }
2322
2323 /* Return the validity (TRUST_NEVER, etc.) of the binding
2324    <FINGERPRINT, USER_ID>.
2325
2326    FINGERPRINT must be a MAX_FINGERPRINT_LEN-byte fingerprint.
2327
2328    If MAY_ASK is 1 and the policy is TOFU_POLICY_ASK, then the user
2329    will be prompted to choose a different policy.  If MAY_ASK is 0 and
2330    the policy is TOFU_POLICY_ASK, then TRUST_UNKNOWN is returned.
2331
2332    Returns TRUST_UNDEFINED if an error occurs.  */
2333 int
2334 tofu_get_validity (const byte *fingerprint_bin, const char *user_id,
2335                    int may_ask)
2336 {
2337   struct db *dbs;
2338   char *fingerprint = NULL;
2339   char *email = NULL;
2340   int trust_level = TRUST_UNDEFINED;
2341
2342   dbs = opendbs ();
2343   if (! dbs)
2344     {
2345       log_error (_("error opening TOFU DB.\n"));
2346       goto die;
2347     }
2348
2349   fingerprint = fingerprint_pp (fingerprint_bin);
2350
2351   if (! *user_id)
2352     {
2353       log_debug ("user id is empty.  Can't get TOFU validity for this binding.\n");
2354       goto die;
2355     }
2356
2357   email = email_from_user_id (user_id);
2358
2359   trust_level = get_trust (dbs, fingerprint, email, user_id, may_ask);
2360   if (trust_level == _tofu_GET_TRUST_ERROR)
2361     /* An error.  */
2362     trust_level = TRUST_UNDEFINED;
2363
2364   if (may_ask)
2365     show_statistics (dbs, fingerprint, email, user_id, NULL);
2366
2367  die:
2368   xfree (email);
2369   xfree (fingerprint);
2370   if (dbs)
2371     closedbs (dbs);
2372
2373   return trust_level;
2374 }
2375
2376 /* Set the policy for all non-revoked user ids in the keyblock KB to
2377    POLICY.
2378
2379    If no key is available with the specified key id, then this
2380    function returns GPG_ERR_NO_PUBKEY.
2381
2382    Returns 0 on success and an error code otherwise.  */
2383 gpg_error_t
2384 tofu_set_policy (kbnode_t kb, enum tofu_policy policy)
2385 {
2386   struct db *dbs;
2387   PKT_public_key *pk;
2388   char fingerprint_bin[MAX_FINGERPRINT_LEN];
2389   size_t fingerprint_bin_len = sizeof (fingerprint_bin);
2390   char *fingerprint = NULL;
2391
2392   assert (kb->pkt->pkttype == PKT_PUBLIC_KEY);
2393   pk = kb->pkt->pkt.public_key;
2394
2395   dbs = opendbs ();
2396   if (! dbs)
2397     {
2398       log_error (_("error opening TOFU DB.\n"));
2399       return gpg_error (GPG_ERR_GENERAL);
2400     }
2401
2402   if (DBG_TRUST)
2403     log_debug ("Setting TOFU policy for %s to %s\n",
2404                keystr (pk->keyid), tofu_policy_str (policy));
2405   if (! (pk->main_keyid[0] == pk->keyid[0]
2406          && pk->main_keyid[1] == pk->keyid[1]))
2407     log_bug ("%s: Passed a subkey, but expecting a primary key.\n", __func__);
2408
2409   fingerprint_from_pk (pk, fingerprint_bin, &fingerprint_bin_len);
2410   assert (fingerprint_bin_len == sizeof (fingerprint_bin));
2411
2412   fingerprint = fingerprint_pp (fingerprint_bin);
2413
2414   for (; kb; kb = kb->next)
2415     {
2416       PKT_user_id *user_id;
2417       char *email;
2418
2419       if (kb->pkt->pkttype != PKT_USER_ID)
2420         continue;
2421
2422       user_id = kb->pkt->pkt.user_id;
2423       if (user_id->is_revoked)
2424         /* Skip revoked user ids.  (Don't skip expired user ids, the
2425            expiry can be changed.)  */
2426         continue;
2427
2428       email = email_from_user_id (user_id->name);
2429
2430       record_binding (dbs, fingerprint, email, user_id->name, policy, 1);
2431
2432       xfree (email);
2433     }
2434
2435   xfree (fingerprint);
2436   closedbs (dbs);
2437
2438   return 0;
2439 }
2440
2441 /* Set the TOFU policy for all non-revoked user ids in the KEY with
2442    the key id KEYID to POLICY.
2443
2444    If no key is available with the specified key id, then this
2445    function returns GPG_ERR_NO_PUBKEY.
2446
2447    Returns 0 on success and an error code otherwise.  */
2448 gpg_error_t
2449 tofu_set_policy_by_keyid (u32 *keyid, enum tofu_policy policy)
2450 {
2451   kbnode_t keyblock = get_pubkeyblock (keyid);
2452   if (! keyblock)
2453     return gpg_error (GPG_ERR_NO_PUBKEY);
2454
2455   return tofu_set_policy (keyblock, policy);
2456 }
2457
2458 /* Return the TOFU policy for the specified binding in *POLICY.  If no
2459    policy has been set for the binding, sets *POLICY to
2460    TOFU_POLICY_NONE.
2461
2462    PK is a primary public key and USER_ID is a user id.
2463
2464    Returns 0 on success and an error code otherwise.  */
2465 gpg_error_t
2466 tofu_get_policy (PKT_public_key *pk, PKT_user_id *user_id,
2467                  enum tofu_policy *policy)
2468 {
2469   struct db *dbs;
2470   char fingerprint_bin[MAX_FINGERPRINT_LEN];
2471   size_t fingerprint_bin_len = sizeof (fingerprint_bin);
2472   char *fingerprint;
2473   char *email;
2474
2475   /* Make sure PK is a primary key.  */
2476   assert (pk->main_keyid[0] == pk->keyid[0]
2477           && pk->main_keyid[1] == pk->keyid[1]);
2478
2479   dbs = opendbs ();
2480   if (! dbs)
2481     {
2482       log_error (_("error opening TOFU DB.\n"));
2483       return gpg_error (GPG_ERR_GENERAL);
2484     }
2485
2486   fingerprint_from_pk (pk, fingerprint_bin, &fingerprint_bin_len);
2487   assert (fingerprint_bin_len == sizeof (fingerprint_bin));
2488
2489   fingerprint = fingerprint_pp (fingerprint_bin);
2490
2491   email = email_from_user_id (user_id->name);
2492
2493   *policy = get_policy (dbs, fingerprint, email, NULL);
2494
2495   xfree (email);
2496   xfree (fingerprint);
2497   closedbs (dbs);
2498
2499   if (*policy == _tofu_GET_POLICY_ERROR)
2500     return gpg_error (GPG_ERR_GENERAL);
2501   return 0;
2502 }