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