gpg: Do not mark ", " translatable.
[gnupg.git] / g10 / tofu.c
1 /* tofu.c - TOFU trust model.
2  * Copyright (C) 2015, 2016 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 <https://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 <stdarg.h>
30 #include <sqlite3.h>
31 #include <time.h>
32
33 #include "gpg.h"
34 #include "../common/types.h"
35 #include "../common/logging.h"
36 #include "../common/stringhelp.h"
37 #include "options.h"
38 #include "../common/mbox-util.h"
39 #include "../common/i18n.h"
40 #include "../common/ttyio.h"
41 #include "trustdb.h"
42 #include "../common/mkdir_p.h"
43 #include "gpgsql.h"
44 #include "../common/status.h"
45 #include "sqrtu32.h"
46
47 #include "tofu.h"
48
49
50 #define CONTROL_L ('L' - 'A' + 1)
51
52 /* Number of days with signed / ecnrypted messages required to
53  * indicate that enough history is available for basic trust.  */
54 #define BASIC_TRUST_THRESHOLD  4
55 /* Number of days with signed / encrypted messages required to
56  * indicate that a lot of history is available.  */
57 #define FULL_TRUST_THRESHOLD  21
58
59
60 /* A struct with data pertaining to the tofu DB.  There is one such
61    struct per session and it is cached in session's ctrl structure.
62    To initialize this or get the current singleton, call opendbs().
63    There is no need to explicitly release it; cleanup is done when the
64    CTRL object is released.  */
65 struct tofu_dbs_s
66 {
67   sqlite3 *db;
68   char *want_lock_file;
69   time_t want_lock_file_ctime;
70
71   struct
72   {
73     sqlite3_stmt *savepoint_batch;
74     sqlite3_stmt *savepoint_batch_commit;
75
76     sqlite3_stmt *record_binding_get_old_policy;
77     sqlite3_stmt *record_binding_update;
78     sqlite3_stmt *get_policy_select_policy_and_conflict;
79     sqlite3_stmt *get_trust_bindings_with_this_email;
80     sqlite3_stmt *get_trust_gather_other_user_ids;
81     sqlite3_stmt *get_trust_gather_signature_stats;
82     sqlite3_stmt *get_trust_gather_encryption_stats;
83     sqlite3_stmt *register_already_seen;
84     sqlite3_stmt *register_signature;
85     sqlite3_stmt *register_encryption;
86   } s;
87
88   int in_batch_transaction;
89   int in_transaction;
90   time_t batch_update_started;
91 };
92
93
94 #define STRINGIFY(s) STRINGIFY2(s)
95 #define STRINGIFY2(s) #s
96
97 /* The grouping parameters when collecting signature statistics.  */
98
99 /* If a message is signed a couple of hours in the future, just assume
100    some clock skew.  */
101 #define TIME_AGO_FUTURE_IGNORE (2 * 60 * 60)
102 /* Days.  */
103 #define TIME_AGO_UNIT_SMALL (24 * 60 * 60)
104 #define TIME_AGO_SMALL_THRESHOLD (7 * TIME_AGO_UNIT_SMALL)
105 /* Months.  */
106 #define TIME_AGO_UNIT_MEDIUM (30 * 24 * 60 * 60)
107 #define TIME_AGO_MEDIUM_THRESHOLD (2 * TIME_AGO_UNIT_MEDIUM)
108 /* Years.  */
109 #define TIME_AGO_UNIT_LARGE (365 * 24 * 60 * 60)
110 #define TIME_AGO_LARGE_THRESHOLD (2 * TIME_AGO_UNIT_LARGE)
111
112 /* Local prototypes.  */
113 static gpg_error_t end_transaction (ctrl_t ctrl, int only_batch);
114 static char *email_from_user_id (const char *user_id);
115 static int show_statistics (tofu_dbs_t dbs,
116                             const char *fingerprint, const char *email,
117                             enum tofu_policy policy,
118                             estream_t outfp, int only_status_fd, time_t now);
119 \f
120 const char *
121 tofu_policy_str (enum tofu_policy policy)
122 {
123   switch (policy)
124     {
125     case TOFU_POLICY_NONE: return "none";
126     case TOFU_POLICY_AUTO: return "auto";
127     case TOFU_POLICY_GOOD: return "good";
128     case TOFU_POLICY_UNKNOWN: return "unknown";
129     case TOFU_POLICY_BAD: return "bad";
130     case TOFU_POLICY_ASK: return "ask";
131     default: return "???";
132     }
133 }
134
135 /* Convert a binding policy (e.g., TOFU_POLICY_BAD) to a trust level
136    (e.g., TRUST_BAD) in light of the current configuration.  */
137 int
138 tofu_policy_to_trust_level (enum tofu_policy policy)
139 {
140   if (policy == TOFU_POLICY_AUTO)
141     /* If POLICY is AUTO, fallback to OPT.TOFU_DEFAULT_POLICY.  */
142     policy = opt.tofu_default_policy;
143
144   switch (policy)
145     {
146     case TOFU_POLICY_AUTO:
147       /* If POLICY and OPT.TOFU_DEFAULT_POLICY are both AUTO, default
148          to marginal trust.  */
149       return TRUST_MARGINAL;
150     case TOFU_POLICY_GOOD:
151       return TRUST_FULLY;
152     case TOFU_POLICY_UNKNOWN:
153       return TRUST_UNKNOWN;
154     case TOFU_POLICY_BAD:
155       return TRUST_NEVER;
156     case TOFU_POLICY_ASK:
157       return TRUST_UNKNOWN;
158     default:
159       log_bug ("Bad value for trust policy: %d\n",
160                opt.tofu_default_policy);
161       return 0;
162     }
163 }
164
165
166 \f
167 /* Start a transaction on DB.  If ONLY_BATCH is set, then this will
168    start a batch transaction if we haven't started a batch transaction
169    and one has been requested.  */
170 static gpg_error_t
171 begin_transaction (ctrl_t ctrl, int only_batch)
172 {
173   tofu_dbs_t dbs = ctrl->tofu.dbs;
174   int rc;
175   char *err = NULL;
176
177   log_assert (dbs);
178
179   /* If we've been in batch update mode for a while (on average, more
180    * than 500 ms), to prevent starving other gpg processes, we drop
181    * and retake the batch lock.
182    *
183    * Note: gnupg_get_time has a one second resolution, if we wanted a
184    * higher resolution, we could use npth_clock_gettime.  */
185   if (/* No real transactions.  */
186       dbs->in_transaction == 0
187       /* There is an open batch transaction.  */
188       && dbs->in_batch_transaction
189       /* And some time has gone by since it was started.  */
190       && dbs->batch_update_started != gnupg_get_time ())
191     {
192       struct stat statbuf;
193
194       /* If we are in a batch update, then batch updates better have
195          been enabled.  */
196       log_assert (ctrl->tofu.batch_updated_wanted);
197
198       /* Check if another process wants to run.  (We just ignore any
199        * stat failure.  A waiter might have to wait a bit longer, but
200        * otherwise there should be no impact.)  */
201       if (stat (dbs->want_lock_file, &statbuf) == 0
202           && statbuf.st_ctime != dbs->want_lock_file_ctime)
203         {
204           end_transaction (ctrl, 2);
205
206           /* Yield to allow another process a chance to run.  Note:
207            * testing suggests that anything less than a 100ms tends to
208            * not result in the other process getting the lock.  */
209           gnupg_usleep (100000);
210         }
211       else
212         dbs->batch_update_started = gnupg_get_time ();
213     }
214
215   if (/* We don't have an open batch transaction.  */
216       !dbs->in_batch_transaction
217       && (/* Batch mode is enabled or we are starting a new transaction.  */
218           ctrl->tofu.batch_updated_wanted || dbs->in_transaction == 0))
219     {
220       struct stat statbuf;
221
222       /* We are in batch mode, but we don't have an open batch
223        * transaction.  Since the batch save point must be the outer
224        * save point, it must be taken before the inner save point.  */
225       log_assert (dbs->in_transaction == 0);
226
227       rc = gpgsql_stepx (dbs->db, &dbs->s.savepoint_batch,
228                           NULL, NULL, &err,
229                           "begin immediate transaction;", GPGSQL_ARG_END);
230       if (rc)
231         {
232           log_error (_("error beginning transaction on TOFU database: %s\n"),
233                      err);
234           sqlite3_free (err);
235           return gpg_error (GPG_ERR_GENERAL);
236         }
237
238       dbs->in_batch_transaction = 1;
239       dbs->batch_update_started = gnupg_get_time ();
240
241       if (stat (dbs->want_lock_file, &statbuf) == 0)
242         dbs->want_lock_file_ctime = statbuf.st_ctime;
243     }
244
245   if (only_batch)
246     return 0;
247
248   log_assert (dbs->in_transaction >= 0);
249   dbs->in_transaction ++;
250
251   rc = gpgsql_exec_printf (dbs->db, NULL, NULL, &err,
252                            "savepoint inner%d;",
253                            dbs->in_transaction);
254   if (rc)
255     {
256       log_error (_("error beginning transaction on TOFU database: %s\n"),
257                  err);
258       sqlite3_free (err);
259       return gpg_error (GPG_ERR_GENERAL);
260     }
261
262   return 0;
263 }
264
265
266 /* Commit a transaction.  If ONLY_BATCH is 1, then this only ends the
267  * batch transaction if we have left batch mode.  If ONLY_BATCH is 2,
268  * this commits any open batch transaction even if we are still in
269  * batch mode.  */
270 static gpg_error_t
271 end_transaction (ctrl_t ctrl, int only_batch)
272 {
273   tofu_dbs_t dbs = ctrl->tofu.dbs;
274   int rc;
275   char *err = NULL;
276
277   if (only_batch || (! only_batch && dbs->in_transaction == 1))
278     {
279       if (!dbs)
280         return 0;  /* Shortcut to allow for easier cleanup code.  */
281
282       /* If we are releasing the batch transaction, then we better not
283          be in a normal transaction.  */
284       if (only_batch)
285         log_assert (dbs->in_transaction == 0);
286
287       if (/* Batch mode disabled?  */
288           (!ctrl->tofu.batch_updated_wanted || only_batch == 2)
289           /* But, we still have an open batch transaction?  */
290           && dbs->in_batch_transaction)
291         {
292           /* The batch transaction is still in open, but we've left
293            * batch mode.  */
294           dbs->in_batch_transaction = 0;
295           dbs->in_transaction = 0;
296
297           rc = gpgsql_stepx (dbs->db, &dbs->s.savepoint_batch_commit,
298                              NULL, NULL, &err,
299                              "commit transaction;", GPGSQL_ARG_END);
300           if (rc)
301             {
302               log_error (_("error committing transaction on TOFU database: %s\n"),
303                          err);
304               sqlite3_free (err);
305               return gpg_error (GPG_ERR_GENERAL);
306             }
307
308           return 0;
309         }
310
311       if (only_batch)
312         return 0;
313     }
314
315   log_assert (dbs);
316   log_assert (dbs->in_transaction > 0);
317
318   rc = gpgsql_exec_printf (dbs->db, NULL, NULL, &err,
319                            "release inner%d;", dbs->in_transaction);
320
321   dbs->in_transaction --;
322
323   if (rc)
324     {
325       log_error (_("error committing transaction on TOFU database: %s\n"),
326                  err);
327       sqlite3_free (err);
328       return gpg_error (GPG_ERR_GENERAL);
329     }
330
331   return 0;
332 }
333
334
335 static gpg_error_t
336 rollback_transaction (ctrl_t ctrl)
337 {
338   tofu_dbs_t dbs = ctrl->tofu.dbs;
339   int rc;
340   char *err = NULL;
341
342   log_assert (dbs);
343   log_assert (dbs->in_transaction > 0);
344
345   /* Be careful to not undo any progress made by closed transactions in
346      batch mode.  */
347   rc = gpgsql_exec_printf (dbs->db, NULL, NULL, &err,
348                            "rollback to inner%d;",
349                            dbs->in_transaction);
350
351   dbs->in_transaction --;
352
353   if (rc)
354     {
355       log_error (_("error rolling back transaction on TOFU database: %s\n"),
356                  err);
357       sqlite3_free (err);
358       return gpg_error (GPG_ERR_GENERAL);
359     }
360
361   return 0;
362 }
363
364 void
365 tofu_begin_batch_update (ctrl_t ctrl)
366 {
367   ctrl->tofu.batch_updated_wanted ++;
368 }
369
370 void
371 tofu_end_batch_update (ctrl_t ctrl)
372 {
373   log_assert (ctrl->tofu.batch_updated_wanted > 0);
374   ctrl->tofu.batch_updated_wanted --;
375   end_transaction (ctrl, 1);
376 }
377
378 /* Suspend any extant batch transaction (it is safe to call this even
379    no batch transaction has been started).  Note: you cannot suspend a
380    batch transaction if you are in a normal transaction.  The batch
381    transaction can be resumed explicitly by calling
382    tofu_resume_batch_transaction or implicitly by starting a normal
383    transaction.  */
384 static void
385 tofu_suspend_batch_transaction (ctrl_t ctrl)
386 {
387   end_transaction (ctrl, 2);
388 }
389
390 /* Resume a batch transaction if there is no extant batch transaction
391    and one has been requested using tofu_begin_batch_transaction.  */
392 static void
393 tofu_resume_batch_transaction (ctrl_t ctrl)
394 {
395   begin_transaction (ctrl, 1);
396 }
397
398
399 \f
400 /* Wrapper around strtol which prints a warning in case of a
401  * conversion error.  On success the converted value is stored at
402  * R_VALUE and 0 is returned; on error FALLBACK is stored at R_VALUE
403  * and an error code is returned.  */
404 static gpg_error_t
405 string_to_long (long *r_value, const char *string, long fallback, int line)
406 {
407   gpg_error_t err;
408   char *tail = NULL;
409
410   gpg_err_set_errno (0);
411   *r_value = strtol (string, &tail, 0);
412   if (errno || !(!strcmp (tail, ".0") || !*tail))
413     {
414       err = errno? gpg_error_from_errno (errno) : gpg_error (GPG_ERR_BAD_DATA);
415       log_debug ("%s:%d: strtol failed for TOFU DB data; returned string"
416                  " (string='%.10s%s'; tail='%.10s%s'): %s\n",
417                  __FILE__, line,
418                  string, string && strlen(string) > 10 ? "..." : "",
419                  tail, tail && strlen(tail) > 10 ? "..." : "",
420                  gpg_strerror (err));
421       *r_value = fallback;
422     }
423   else
424     err = 0;
425
426   return err;
427 }
428
429
430 /* Wrapper around strtoul which prints a warning in case of a
431  * conversion error.  On success the converted value is stored at
432  * R_VALUE and 0 is returned; on error FALLBACK is stored at R_VALUE
433  * and an error code is returned.  */
434 static gpg_error_t
435 string_to_ulong (unsigned long *r_value, const char *string,
436                  unsigned long fallback, int line)
437 {
438   gpg_error_t err;
439   char *tail = NULL;
440
441   gpg_err_set_errno (0);
442   *r_value = strtoul (string, &tail, 0);
443   if (errno || !(!strcmp (tail, ".0") || !*tail))
444     {
445       err = errno? gpg_error_from_errno (errno) : gpg_error (GPG_ERR_BAD_DATA);
446       log_debug ("%s:%d: strtoul failed for TOFU DB data; returned string"
447                  " (string='%.10s%s'; tail='%.10s%s'): %s\n",
448                  __FILE__, line,
449                  string, string && strlen(string) > 10 ? "..." : "",
450                  tail, tail && strlen(tail) > 10 ? "..." : "",
451                  gpg_strerror (err));
452       *r_value = fallback;
453     }
454   else
455     err = 0;
456
457   return err;
458 }
459
460
461
462 /* Collect results of a select count (*) ...; style query.  Aborts if
463    the argument is not a valid integer (or real of the form X.0).  */
464 static int
465 get_single_unsigned_long_cb (void *cookie, int argc, char **argv,
466                              char **azColName)
467 {
468   unsigned long int *count = cookie;
469
470   (void) azColName;
471
472   log_assert (argc == 1);
473
474   if (string_to_ulong (count, argv[0], 0, __LINE__))
475     return 1; /* Abort.  */
476   return 0;
477 }
478
479 static int
480 get_single_unsigned_long_cb2 (void *cookie, int argc, char **argv,
481                              char **azColName, sqlite3_stmt *stmt)
482 {
483   (void) stmt;
484   return get_single_unsigned_long_cb (cookie, argc, argv, azColName);
485 }
486
487 /* We expect a single integer column whose name is "version".  COOKIE
488    must point to an int.  This function always aborts.  On error or a
489    if the version is bad, sets *VERSION to -1.  */
490 static int
491 version_check_cb (void *cookie, int argc, char **argv, char **azColName)
492 {
493   int *version = cookie;
494
495   if (argc != 1 || strcmp (azColName[0], "version") != 0)
496     {
497       *version = -1;
498       return 1;
499     }
500
501   if (strcmp (argv[0], "1") == 0)
502     *version = 1;
503   else
504     {
505       log_error (_("unsupported TOFU database version: %s\n"), argv[0]);
506       *version = -1;
507     }
508
509   /* Don't run again.  */
510   return 1;
511 }
512
513 static int
514 check_utks (sqlite3 *db)
515 {
516   int rc;
517   char *err = NULL;
518   struct key_item *utks;
519   struct key_item *ki;
520   int utk_count;
521   char *utks_string = NULL;
522   char keyid_str[16+1];
523   long utks_unchanged = 0;
524
525   /* An early version of the v1 format did not include the list of
526    * known ultimately trusted keys.
527    *
528    * This list is used to detect when the set of ultimately trusted
529    * keys changes.  We need to detect this to invalidate the effective
530    * policy, which can change if an ultimately trusted key is added or
531    * removed.  */
532   rc = sqlite3_exec (db,
533                      "create table if not exists ultimately_trusted_keys"
534                      " (keyid);\n",
535                      NULL, NULL, &err);
536   if (rc)
537     {
538       log_error (_("error creating 'ultimately_trusted_keys' TOFU table: %s\n"),
539                  err);
540       sqlite3_free (err);
541       goto out;
542     }
543
544
545   utks = tdb_utks ();
546   for (ki = utks, utk_count = 0; ki; ki = ki->next, utk_count ++)
547     ;
548
549   if (utk_count)
550     {
551       /* Build a list of keyids of the form "XXX","YYY","ZZZ".  */
552       int len = (1 + 16 + 1 + 1) * utk_count;
553       int o = 0;
554
555       utks_string = xmalloc (len);
556       *utks_string = 0;
557       for (ki = utks, utk_count = 0; ki; ki = ki->next, utk_count ++)
558         {
559           utks_string[o ++] = '\'';
560           format_keyid (ki->kid, KF_LONG,
561                         keyid_str, sizeof (keyid_str));
562           memcpy (&utks_string[o], keyid_str, 16);
563           o += 16;
564           utks_string[o ++] = '\'';
565           utks_string[o ++] = ',';
566         }
567       utks_string[o - 1] = 0;
568       log_assert (o == len);
569     }
570
571   rc = gpgsql_exec_printf
572     (db, get_single_unsigned_long_cb, &utks_unchanged, &err,
573      "select"
574      /* Removed UTKs?  (Known UTKs in current UTKs.)  */
575      "  ((select count(*) from ultimately_trusted_keys"
576      "     where (keyid in (%s))) == %d)"
577      " and"
578      /* New UTKs?  */
579      "  ((select count(*) from ultimately_trusted_keys"
580      "     where keyid not in (%s)) == 0);",
581      utks_string ? utks_string : "",
582      utk_count,
583      utks_string ? utks_string : "");
584   xfree (utks_string);
585   if (rc)
586     {
587       log_error (_("TOFU DB error"));
588       print_further_info ("checking if ultimately trusted keys changed: %s",
589                          err);
590       sqlite3_free (err);
591       goto out;
592     }
593
594   if (utks_unchanged)
595     goto out;
596
597   if (DBG_TRUST)
598     log_debug ("TOFU: ultimately trusted keys changed.\n");
599
600   /* Given that the set of ultimately trusted keys
601    * changed, clear any cached policies.  */
602   rc = gpgsql_exec_printf
603     (db, NULL, NULL, &err,
604      "update bindings set effective_policy = %d;",
605      TOFU_POLICY_NONE);
606   if (rc)
607     {
608       log_error (_("TOFU DB error"));
609       print_further_info ("clearing cached policies: %s", err);
610       sqlite3_free (err);
611       goto out;
612     }
613
614   /* Now, update the UTK table.  */
615   rc = sqlite3_exec (db,
616                      "drop table ultimately_trusted_keys;",
617                      NULL, NULL, &err);
618   if (rc)
619     {
620       log_error (_("TOFU DB error"));
621       print_further_info ("dropping ultimately_trusted_keys: %s", err);
622       sqlite3_free (err);
623       goto out;
624     }
625
626   rc = sqlite3_exec (db,
627                      "create table if not exists"
628                      " ultimately_trusted_keys (keyid);\n",
629                      NULL, NULL, &err);
630   if (rc)
631     {
632       log_error (_("TOFU DB error"));
633       print_further_info ("creating ultimately_trusted_keys: %s", err);
634       sqlite3_free (err);
635       goto out;
636     }
637
638   for (ki = utks; ki; ki = ki->next)
639     {
640       format_keyid (ki->kid, KF_LONG,
641                     keyid_str, sizeof (keyid_str));
642       rc = gpgsql_exec_printf
643         (db, NULL, NULL, &err,
644          "insert into ultimately_trusted_keys values ('%s');",
645          keyid_str);
646       if (rc)
647         {
648           log_error (_("TOFU DB error"));
649           print_further_info ("updating ultimately_trusted_keys: %s",
650                               err);
651           sqlite3_free (err);
652           goto out;
653         }
654     }
655
656  out:
657   return rc;
658 }
659
660 /* If the DB is new, initialize it.  Otherwise, check the DB's
661    version.
662
663    Return 0 if the database is okay and 1 otherwise.  */
664 static int
665 initdb (sqlite3 *db)
666 {
667   char *err = NULL;
668   int rc;
669   unsigned long int count;
670   int version = -1;
671
672   rc = sqlite3_exec (db, "begin transaction;", NULL, NULL, &err);
673   if (rc)
674     {
675       log_error (_("error beginning transaction on TOFU database: %s\n"),
676                  err);
677       sqlite3_free (err);
678       return 1;
679     }
680
681   /* If the DB has no tables, then assume this is a new DB that needs
682      to be initialized.  */
683   rc = sqlite3_exec (db,
684                      "select count(*) from sqlite_master where type='table';",
685                      get_single_unsigned_long_cb, &count, &err);
686   if (rc)
687     {
688       log_error (_("error reading TOFU database: %s\n"), err);
689       print_further_info ("query available tables");
690       sqlite3_free (err);
691       goto out;
692     }
693   else if (count != 0)
694     /* Assume that the DB is already initialized.  Make sure the
695        version is okay.  */
696     {
697       rc = sqlite3_exec (db, "select version from version;", version_check_cb,
698                          &version, &err);
699       if (rc == SQLITE_ABORT && version == 1)
700         /* Happy, happy, joy, joy.  */
701         {
702           sqlite3_free (err);
703           rc = 0;
704           goto out;
705         }
706       else if (rc == SQLITE_ABORT && version == -1)
707         /* Unsupported version.  */
708         {
709           /* An error message was already displayed.  */
710           sqlite3_free (err);
711           goto out;
712         }
713       else if (rc)
714         /* Some error.  */
715         {
716           log_error (_("error determining TOFU database's version: %s\n"), err);
717           sqlite3_free (err);
718           goto out;
719         }
720       else
721         {
722           /* Unexpected success.  This can only happen if there are no
723              rows.  (select returned 0, but expected ABORT.)  */
724           log_error (_("error determining TOFU database's version: %s\n"),
725                      gpg_strerror (GPG_ERR_NO_DATA));
726           rc = 1;
727           goto out;
728         }
729     }
730
731   /* Create the version table.  */
732   rc = sqlite3_exec (db,
733                      "create table version (version INTEGER);",
734                      NULL, NULL, &err);
735   if (rc)
736     {
737       log_error (_("error initializing TOFU database: %s\n"), err);
738       print_further_info ("create version");
739       sqlite3_free (err);
740       goto out;
741     }
742
743   /* Initialize the version table, which contains a single integer
744      value.  */
745   rc = sqlite3_exec (db,
746                      "insert into version values (1);",
747                      NULL, NULL, &err);
748   if (rc)
749     {
750       log_error (_("error initializing TOFU database: %s\n"), err);
751       print_further_info ("insert version");
752       sqlite3_free (err);
753       goto out;
754     }
755
756   /* The list of <fingerprint, email> bindings and auxiliary data.
757    *
758    *  OID is a unique ID identifying this binding (and used by the
759    *    signatures table, see below).  Note: OIDs will never be
760    *    reused.
761    *
762    *  FINGERPRINT: The key's fingerprint.
763    *
764    *  EMAIL: The normalized email address.
765    *
766    *  USER_ID: The unmodified user id from which EMAIL was extracted.
767    *
768    *  TIME: The time this binding was first observed.
769    *
770    *  POLICY: The trust policy (TOFU_POLICY_BAD, etc. as an integer).
771    *
772    *  CONFLICT is either NULL or a fingerprint.  Assume that we have
773    *    a binding <0xdeadbeef, foo@example.com> and then we observe
774    *    <0xbaddecaf, foo@example.com>.  There two bindings conflict
775    *    (they have the same email address).  When we observe the
776    *    latter binding, we warn the user about the conflict and ask
777    *    for a policy decision about the new binding.  We also change
778    *    the old binding's policy to ask if it was auto.  So that we
779    *     know why this occurred, we also set conflict to 0xbaddecaf.
780    */
781   rc = gpgsql_exec_printf
782       (db, NULL, NULL, &err,
783        "create table bindings\n"
784        " (oid INTEGER PRIMARY KEY AUTOINCREMENT,\n"
785        "  fingerprint TEXT, email TEXT, user_id TEXT, time INTEGER,\n"
786        "  policy INTEGER CHECK (policy in (%d, %d, %d, %d, %d)),\n"
787        "  conflict STRING,\n"
788        "  unique (fingerprint, email));\n"
789        "create index bindings_fingerprint_email\n"
790        " on bindings (fingerprint, email);\n"
791        "create index bindings_email on bindings (email);\n",
792        TOFU_POLICY_AUTO, TOFU_POLICY_GOOD, TOFU_POLICY_UNKNOWN,
793        TOFU_POLICY_BAD, TOFU_POLICY_ASK);
794   if (rc)
795     {
796       log_error (_("error initializing TOFU database: %s\n"), err);
797       print_further_info ("create bindings");
798       sqlite3_free (err);
799       goto out;
800     }
801
802   /* The signatures that we have observed.
803    *
804    * BINDING refers to a record in the bindings table, which
805    * describes the binding (i.e., this is a foreign key that
806    * references bindings.oid).
807    *
808    * SIG_DIGEST is the digest stored in the signature.
809    *
810    * SIG_TIME is the timestamp stored in the signature.
811    *
812    * ORIGIN is a free-form string that describes who fed this
813    * signature to GnuPG (e.g., email:claws).
814    *
815    * TIME is the time this signature was registered.  */
816   rc = sqlite3_exec (db,
817                          "create table signatures "
818                          " (binding INTEGER NOT NULL, sig_digest TEXT,"
819                          "  origin TEXT, sig_time INTEGER, time INTEGER,"
820                          "  primary key (binding, sig_digest, origin));",
821                          NULL, NULL, &err);
822   if (rc)
823     {
824       log_error (_("error initializing TOFU database: %s\n"), err);
825       print_further_info ("create signatures");
826       sqlite3_free (err);
827       goto out;
828     }
829
830  out:
831   if (! rc)
832     {
833       /* Early version of the v1 format did not include the encryption
834          table.  Add it.  */
835       rc = sqlite3_exec (db,
836                          "create table if not exists encryptions"
837                          " (binding INTEGER NOT NULL,"
838                          "  time INTEGER);"
839                          "create index if not exists encryptions_binding"
840                          " on encryptions (binding);\n",
841                          NULL, NULL, &err);
842       if (rc)
843         {
844           log_error (_("error creating 'encryptions' TOFU table: %s\n"),
845                      err);
846           sqlite3_free (err);
847         }
848     }
849   if (! rc)
850     {
851       /* The effective policy for a binding.  If a key is ultimately
852        * trusted, then the effective policy of all of its bindings is
853        * good.  Likewise if a key is signed by an ultimately trusted
854        * key, etc.  If the effective policy is NONE, then we need to
855        * recompute the effective policy.  Otherwise, the effective
856        * policy is considered to be up to date, i.e., effective_policy
857        * is a cache of the computed policy.  */
858       rc = gpgsql_exec_printf
859         (db, NULL, NULL, &err,
860          "alter table bindings"
861          " add column effective_policy INTEGER"
862          " DEFAULT %d"
863          " CHECK (effective_policy in (%d, %d, %d, %d, %d, %d));",
864          TOFU_POLICY_NONE,
865          TOFU_POLICY_NONE, TOFU_POLICY_AUTO, TOFU_POLICY_GOOD,
866          TOFU_POLICY_UNKNOWN, TOFU_POLICY_BAD, TOFU_POLICY_ASK);
867       if (rc)
868         {
869           if (rc == SQLITE_ERROR)
870             /* Almost certainly "duplicate column name", which we can
871              * safely ignore.  */
872             rc = 0;
873           else
874             log_error (_("adding column effective_policy to bindings DB: %s\n"),
875                        err);
876           sqlite3_free (err);
877         }
878     }
879
880   if (! rc)
881     rc = check_utks (db);
882
883   if (rc)
884     {
885       rc = sqlite3_exec (db, "rollback;", NULL, NULL, &err);
886       if (rc)
887         {
888           log_error (_("error rolling back transaction on TOFU database: %s\n"),
889                      err);
890           sqlite3_free (err);
891         }
892       return 1;
893     }
894   else
895     {
896       rc = sqlite3_exec (db, "end transaction;", NULL, NULL, &err);
897       if (rc)
898         {
899           log_error (_("error committing transaction on TOFU database: %s\n"),
900                      err);
901           sqlite3_free (err);
902           return 1;
903         }
904       return 0;
905     }
906 }
907
908 static int
909 busy_handler (void *cookie, int call_count)
910 {
911   ctrl_t ctrl = cookie;
912   tofu_dbs_t dbs = ctrl->tofu.dbs;
913
914   (void) call_count;
915
916   /* Update the want-lock-file time stamp (specifically, the ctime) so
917    * that the current owner knows that we (well, someone) want the
918    * lock.  */
919   if (dbs)
920     {
921       /* Note: we don't fail if we can't create the lock file: this
922        * process will have to wait a bit longer, but otherwise nothing
923        * horrible should happen.  */
924
925       estream_t fp;
926
927       fp = es_fopen (dbs->want_lock_file, "w");
928       if (! fp)
929         log_debug ("TOFU: Error opening '%s': %s\n",
930                    dbs->want_lock_file, strerror (errno));
931       else
932         es_fclose (fp);
933     }
934
935   /* Call again.  */
936   return 1;
937 }
938
939 /* Create a new DB handle.  Returns NULL on error.  */
940 /* FIXME: Change to return an error code for better reporting by the
941    caller.  */
942 static tofu_dbs_t
943 opendbs (ctrl_t ctrl)
944 {
945   char *filename;
946   sqlite3 *db;
947   int rc;
948
949   if (!ctrl->tofu.dbs)
950     {
951       filename = make_filename (gnupg_homedir (), "tofu.db", NULL);
952
953       rc = sqlite3_open (filename, &db);
954       if (rc)
955         {
956           log_error (_("error opening TOFU database '%s': %s\n"),
957                      filename, sqlite3_errmsg (db));
958           /* Even if an error occurs, DB is guaranteed to be valid.  */
959           sqlite3_close (db);
960           db = NULL;
961         }
962
963       /* If a DB is locked wait up to 5 seconds for the lock to be cleared
964          before failing.  */
965       if (db)
966         {
967           sqlite3_busy_timeout (db, 5 * 1000);
968           sqlite3_busy_handler (db, busy_handler, ctrl);
969         }
970
971       if (db && initdb (db))
972         {
973           sqlite3_close (db);
974           db = NULL;
975         }
976
977       if (db)
978         {
979           ctrl->tofu.dbs = xmalloc_clear (sizeof *ctrl->tofu.dbs);
980           ctrl->tofu.dbs->db = db;
981           ctrl->tofu.dbs->want_lock_file = xasprintf ("%s-want-lock", filename);
982         }
983
984       xfree (filename);
985     }
986   else
987     log_assert (ctrl->tofu.dbs->db);
988
989   return ctrl->tofu.dbs;
990 }
991
992
993 /* Release all of the resources associated with the DB handle.  */
994 void
995 tofu_closedbs (ctrl_t ctrl)
996 {
997   tofu_dbs_t dbs;
998   sqlite3_stmt **statements;
999
1000   dbs = ctrl->tofu.dbs;
1001   if (!dbs)
1002     return;  /* Not initialized.  */
1003
1004   log_assert (dbs->in_transaction == 0);
1005
1006   end_transaction (ctrl, 2);
1007
1008   /* Arghh, that is a surprising use of the struct.  */
1009   for (statements = (void *) &dbs->s;
1010        (void *) statements < (void *) &(&dbs->s)[1];
1011        statements ++)
1012     sqlite3_finalize (*statements);
1013
1014   sqlite3_close (dbs->db);
1015   xfree (dbs->want_lock_file);
1016   xfree (dbs);
1017   ctrl->tofu.dbs = NULL;
1018 }
1019
1020
1021 /* Collect results of a select min (foo) ...; style query.  Aborts if
1022    the argument is not a valid integer (or real of the form X.0).  */
1023 static int
1024 get_single_long_cb (void *cookie, int argc, char **argv, char **azColName)
1025 {
1026   long *count = cookie;
1027
1028   (void) azColName;
1029
1030   log_assert (argc == 1);
1031
1032   if (string_to_long (count, argv[0], 0, __LINE__))
1033     return 1; /* Abort.  */
1034
1035   return 0;
1036 }
1037
1038 static int
1039 get_single_long_cb2 (void *cookie, int argc, char **argv, char **azColName,
1040                      sqlite3_stmt *stmt)
1041 {
1042   (void) stmt;
1043   return get_single_long_cb (cookie, argc, argv, azColName);
1044 }
1045
1046 /* Record (or update) a trust policy about a (possibly new)
1047    binding.
1048
1049    If SHOW_OLD is set, the binding's old policy is displayed.  */
1050 static gpg_error_t
1051 record_binding (tofu_dbs_t dbs, const char *fingerprint, const char *email,
1052                 const char *user_id,
1053                 enum tofu_policy policy, enum tofu_policy effective_policy,
1054                 const char *conflict, int set_conflict,
1055                 int show_old, time_t now)
1056 {
1057   char *fingerprint_pp = format_hexfingerprint (fingerprint, NULL, 0);
1058   gpg_error_t rc;
1059   char *err = NULL;
1060
1061   if (! (policy == TOFU_POLICY_AUTO
1062          || policy == TOFU_POLICY_GOOD
1063          || policy == TOFU_POLICY_UNKNOWN
1064          || policy == TOFU_POLICY_BAD
1065          || policy == TOFU_POLICY_ASK))
1066     log_bug ("%s: Bad value for policy (%d)!\n", __func__, policy);
1067
1068
1069   if (DBG_TRUST || show_old)
1070     {
1071       /* Get the old policy.  Since this is just for informational
1072        * purposes, there is no need to start a transaction or to die
1073        * if there is a failure.  */
1074
1075       /* policy_old needs to be a long and not an enum tofu_policy,
1076          because we pass it by reference to get_single_long_cb2, which
1077          expects a long.  */
1078       long policy_old = TOFU_POLICY_NONE;
1079
1080       rc = gpgsql_stepx
1081         (dbs->db, &dbs->s.record_binding_get_old_policy,
1082          get_single_long_cb2, &policy_old, &err,
1083          "select policy from bindings where fingerprint = ? and email = ?",
1084          GPGSQL_ARG_STRING, fingerprint, GPGSQL_ARG_STRING, email,
1085          GPGSQL_ARG_END);
1086       if (rc)
1087         {
1088           log_debug ("TOFU: Error reading from binding database"
1089                      " (reading policy for <key: %s, user id: %s>): %s\n",
1090                      fingerprint, email, err);
1091           sqlite3_free (err);
1092         }
1093
1094       if (policy_old != TOFU_POLICY_NONE)
1095         (show_old ? log_info : log_debug)
1096           ("Changing TOFU trust policy for binding"
1097            " <key: %s, user id: %s> from %s to %s.\n",
1098            fingerprint, show_old ? user_id : email,
1099            tofu_policy_str (policy_old),
1100            tofu_policy_str (policy));
1101       else
1102         (show_old ? log_info : log_debug)
1103           ("Setting TOFU trust policy for new binding"
1104            " <key: %s, user id: %s> to %s.\n",
1105            fingerprint, show_old ? user_id : email,
1106            tofu_policy_str (policy));
1107     }
1108
1109   if (opt.dry_run)
1110     {
1111       log_info ("TOFU database update skipped due to --dry-run\n");
1112       rc = 0;
1113       goto leave;
1114     }
1115
1116   rc = gpgsql_stepx
1117     (dbs->db, &dbs->s.record_binding_update, NULL, NULL, &err,
1118      "insert or replace into bindings\n"
1119      " (oid, fingerprint, email, user_id, time,"
1120      "  policy, conflict, effective_policy)\n"
1121      " values (\n"
1122      /* If we don't explicitly reuse the OID, then SQLite will
1123       * reallocate a new one.  We just need to search for the OID
1124       * based on the fingerprint and email since they are unique.  */
1125      "  (select oid from bindings where fingerprint = ? and email = ?),\n"
1126      "  ?, ?, ?, ?, ?,"
1127      /* If SET_CONFLICT is 0, then preserve conflict's current value.  */
1128      "  case ?"
1129      "    when 0 then"
1130      "      (select conflict from bindings where fingerprint = ? and email = ?)"
1131      "    else ?"
1132      "  end,"
1133      "  ?);",
1134      /* oid subquery.  */
1135      GPGSQL_ARG_STRING, fingerprint, GPGSQL_ARG_STRING, email,
1136      /* values 2 through 6.  */
1137      GPGSQL_ARG_STRING, fingerprint, GPGSQL_ARG_STRING, email,
1138      GPGSQL_ARG_STRING, user_id,
1139      GPGSQL_ARG_LONG_LONG, (long long) now,
1140      GPGSQL_ARG_INT, (int) policy,
1141      /* conflict subquery.  */
1142      GPGSQL_ARG_INT, set_conflict ? 1 : 0,
1143      GPGSQL_ARG_STRING, fingerprint, GPGSQL_ARG_STRING, email,
1144      GPGSQL_ARG_STRING, conflict ? conflict : "",
1145      GPGSQL_ARG_INT, (int) effective_policy,
1146      GPGSQL_ARG_END);
1147   if (rc)
1148     {
1149       log_error (_("error updating TOFU database: %s\n"), err);
1150       print_further_info (" insert bindings <key: %s, user id: %s> = %s",
1151                           fingerprint, email, tofu_policy_str (policy));
1152       sqlite3_free (err);
1153       goto leave;
1154     }
1155
1156  leave:
1157   xfree (fingerprint_pp);
1158   return rc;
1159 }
1160
1161
1162 /* Collect the strings returned by a query in a simple string list.
1163    Any NULL values are converted to the empty string.
1164
1165    If a result has 3 rows and each row contains two columns, then the
1166    results are added to the list as follows (the value is parentheses
1167    is the 1-based index in the final list):
1168
1169      row 1, col 2 (6)
1170      row 1, col 1 (5)
1171      row 2, col 2 (4)
1172      row 2, col 1 (3)
1173      row 3, col 2 (2)
1174      row 3, col 1 (1)
1175
1176    This is because add_to_strlist pushes the results onto the front of
1177    the list.  The end result is that the rows are backwards, but the
1178    columns are in the expected order.  */
1179 static int
1180 strings_collect_cb (void *cookie, int argc, char **argv, char **azColName)
1181 {
1182   int i;
1183   strlist_t *strlist = cookie;
1184
1185   (void) azColName;
1186
1187   for (i = argc - 1; i >= 0; i --)
1188     add_to_strlist (strlist, argv[i] ? argv[i] : "");
1189
1190   return 0;
1191 }
1192
1193 static int
1194 strings_collect_cb2 (void *cookie, int argc, char **argv, char **azColName,
1195                      sqlite3_stmt *stmt)
1196 {
1197   (void) stmt;
1198   return strings_collect_cb (cookie, argc, argv, azColName);
1199
1200 }
1201
1202 /* Auxiliary data structure to collect statistics about
1203    signatures.  */
1204 struct signature_stats
1205 {
1206   struct signature_stats *next;
1207
1208   /* The user-assigned policy for this binding.  */
1209   enum tofu_policy policy;
1210
1211   /* How long ago the signature was created (rounded to a multiple of
1212      TIME_AGO_UNIT_SMALL, etc.).  */
1213   long time_ago;
1214   /* Number of signatures during this time.  */
1215   unsigned long count;
1216
1217   /* If the corresponding key/user id has been expired / revoked.  */
1218   int is_expired;
1219   int is_revoked;
1220
1221   /* The key that generated this signature.  */
1222   char fingerprint[1];
1223 };
1224
1225 static void
1226 signature_stats_free (struct signature_stats *stats)
1227 {
1228   while (stats)
1229     {
1230       struct signature_stats *next = stats->next;
1231       xfree (stats);
1232       stats = next;
1233     }
1234 }
1235
1236 static void
1237 signature_stats_prepend (struct signature_stats **statsp,
1238                          const char *fingerprint,
1239                          enum tofu_policy policy,
1240                          long time_ago,
1241                          unsigned long count)
1242 {
1243   struct signature_stats *stats =
1244     xmalloc_clear (sizeof (*stats) + strlen (fingerprint));
1245
1246   stats->next = *statsp;
1247   *statsp = stats;
1248
1249   strcpy (stats->fingerprint, fingerprint);
1250   stats->policy = policy;
1251   stats->time_ago = time_ago;
1252   stats->count = count;
1253 }
1254
1255
1256 /* Process rows that contain the four columns:
1257
1258      <fingerprint, policy, time ago, count>.  */
1259 static int
1260 signature_stats_collect_cb (void *cookie, int argc, char **argv,
1261                             char **azColName, sqlite3_stmt *stmt)
1262 {
1263   struct signature_stats **statsp = cookie;
1264   int i = 0;
1265   enum tofu_policy policy;
1266   long time_ago;
1267   unsigned long count;
1268   long along;
1269
1270   (void) azColName;
1271   (void) stmt;
1272
1273   i ++;
1274
1275   if (string_to_long (&along, argv[i], 0, __LINE__))
1276     return 1;  /* Abort */
1277   policy = along;
1278   i ++;
1279
1280   if (! argv[i])
1281     time_ago = 0;
1282   else
1283     {
1284       if (string_to_long (&time_ago, argv[i], 0, __LINE__))
1285         return 1; /* Abort.  */
1286     }
1287   i ++;
1288
1289   /* If time_ago is NULL, then we had no messages, but we still have a
1290      single row, which count(*) turns into 1.  */
1291   if (! argv[i - 1])
1292     count = 0;
1293   else
1294     {
1295       if (string_to_ulong (&count, argv[i], 0, __LINE__))
1296         return 1; /* Abort */
1297     }
1298   i ++;
1299
1300   log_assert (argc == i);
1301
1302   signature_stats_prepend (statsp, argv[0], policy, time_ago, count);
1303
1304   return 0;
1305 }
1306
1307 /* Format the first part of a conflict message and return that as a
1308  * malloced string. Returns NULL on error. */
1309 static char *
1310 format_conflict_msg_part1 (int policy, strlist_t conflict_set,
1311                            const char *email)
1312 {
1313   estream_t fp;
1314   char *fingerprint;
1315   char *tmpstr, *text;
1316
1317   log_assert (conflict_set);
1318   fingerprint = conflict_set->d;
1319
1320   fp = es_fopenmem (0, "rw,samethread");
1321   if (!fp)
1322     log_fatal ("error creating memory stream: %s\n",
1323                gpg_strerror (gpg_error_from_syserror()));
1324
1325   if (policy == TOFU_POLICY_NONE)
1326     {
1327       es_fprintf (fp,
1328                   _("This is the first time the email address \"%s\" is "
1329                     "being used with key %s."),
1330                   email, fingerprint);
1331       es_fputs ("  ", fp);
1332     }
1333   else if (policy == TOFU_POLICY_ASK && conflict_set->next)
1334     {
1335       int conflicts = strlist_length (conflict_set);
1336       es_fprintf
1337         (fp, ngettext("The email address \"%s\" is associated with %d key!",
1338                       "The email address \"%s\" is associated with %d keys!",
1339                       conflicts),
1340          email, conflicts);
1341       if (opt.verbose)
1342         es_fprintf (fp,
1343                     _("  Since this binding's policy was 'auto', it has been "
1344                       "changed to 'ask'."));
1345       es_fputs ("  ", fp);
1346     }
1347
1348   es_fprintf (fp,
1349               _("Please indicate whether this email address should"
1350                 " be associated with key %s or whether you think someone"
1351                 " is impersonating \"%s\"."),
1352               fingerprint, email);
1353   es_fputc ('\n', fp);
1354
1355   es_fputc (0, fp);
1356   if (es_fclose_snatch (fp, (void **)&tmpstr, NULL))
1357     log_fatal ("error snatching memory stream\n");
1358   text = format_text (tmpstr, 72, 80);
1359   es_free (tmpstr);
1360
1361   return text;
1362 }
1363
1364
1365 /* Return 1 if A signed B and B signed A.  */
1366 static int
1367 cross_sigs (const char *email, kbnode_t a, kbnode_t b)
1368 {
1369   int i;
1370
1371   PKT_public_key *a_pk = a->pkt->pkt.public_key;
1372   PKT_public_key *b_pk = b->pkt->pkt.public_key;
1373
1374   char a_keyid[33];
1375   char b_keyid[33];
1376
1377   if (DBG_TRUST)
1378     {
1379       format_keyid (pk_main_keyid (a_pk),
1380                     KF_LONG, a_keyid, sizeof (a_keyid));
1381       format_keyid (pk_main_keyid (b_pk),
1382                     KF_LONG, b_keyid, sizeof (b_keyid));
1383     }
1384
1385   for (i = 0; i < 2; i ++)
1386     {
1387       /* See if SIGNER signed SIGNEE.  */
1388
1389       kbnode_t signer = i == 0 ? a : b;
1390       kbnode_t signee = i == 0 ? b : a;
1391
1392       PKT_public_key *signer_pk = signer->pkt->pkt.public_key;
1393       u32 *signer_kid = pk_main_keyid (signer_pk);
1394       kbnode_t n;
1395
1396       int saw_email = 0;
1397
1398       /* Iterate over SIGNEE's keyblock and see if there is a valid
1399          signature from SIGNER.  */
1400       for (n = signee; n; n = n->next)
1401         {
1402           PKT_signature *sig;
1403
1404           if (n->pkt->pkttype == PKT_USER_ID)
1405             {
1406               if (saw_email)
1407                 /* We're done: we've processed all signatures on the
1408                    user id.  */
1409                 break;
1410               else
1411                 {
1412                   /* See if this is the matching user id.  */
1413                   PKT_user_id *user_id = n->pkt->pkt.user_id;
1414                   char *email2 = email_from_user_id (user_id->name);
1415
1416                   if (strcmp (email, email2) == 0)
1417                     saw_email = 1;
1418
1419                   xfree (email2);
1420                 }
1421             }
1422
1423           if (! saw_email)
1424             continue;
1425
1426           if (n->pkt->pkttype != PKT_SIGNATURE)
1427             continue;
1428
1429           sig = n->pkt->pkt.signature;
1430
1431           if (! (sig->sig_class == 0x10
1432                  || sig->sig_class == 0x11
1433                  || sig->sig_class == 0x12
1434                  || sig->sig_class == 0x13))
1435             /* Not a signature over a user id.  */
1436             continue;
1437
1438           /* SIG is on SIGNEE's keyblock.  If SIG was generated by the
1439              signer, then it's a match.  */
1440           if (keyid_cmp (sig->keyid, signer_kid) == 0)
1441             /* Match!  */
1442             break;
1443         }
1444       if (! n)
1445         /* We didn't find a signature from signer over signee.  */
1446         {
1447           if (DBG_TRUST)
1448             log_debug ("No cross sig between %s and %s\n",
1449                        a_keyid, b_keyid);
1450           return 0;
1451         }
1452     }
1453
1454   /* A signed B and B signed A.  */
1455   if (DBG_TRUST)
1456     log_debug ("Cross sig between %s and %s\n",
1457                a_keyid, b_keyid);
1458
1459   return 1;
1460 }
1461
1462 /* Return whether the key was signed by an ultimately trusted key.  */
1463 static int
1464 signed_by_utk (const char *email, kbnode_t a)
1465 {
1466   kbnode_t n;
1467   int saw_email = 0;
1468
1469   for (n = a; n; n = n->next)
1470     {
1471       PKT_signature *sig;
1472
1473       if (n->pkt->pkttype == PKT_USER_ID)
1474         {
1475           if (saw_email)
1476             /* We're done: we've processed all signatures on the
1477                user id.  */
1478             break;
1479           else
1480             {
1481               /* See if this is the matching user id.  */
1482               PKT_user_id *user_id = n->pkt->pkt.user_id;
1483               char *email2 = email_from_user_id (user_id->name);
1484
1485               if (strcmp (email, email2) == 0)
1486                 saw_email = 1;
1487
1488               xfree (email2);
1489             }
1490         }
1491
1492       if (! saw_email)
1493         continue;
1494
1495       if (n->pkt->pkttype != PKT_SIGNATURE)
1496         continue;
1497
1498       sig = n->pkt->pkt.signature;
1499
1500       if (! (sig->sig_class == 0x10
1501              || sig->sig_class == 0x11
1502              || sig->sig_class == 0x12
1503              || sig->sig_class == 0x13))
1504         /* Not a signature over a user id.  */
1505         continue;
1506
1507       /* SIG is on SIGNEE's keyblock.  If SIG was generated by the
1508          signer, then it's a match.  */
1509       if (tdb_keyid_is_utk (sig->keyid))
1510         {
1511           /* Match!  */
1512           if (DBG_TRUST)
1513             log_debug ("TOFU: %s is signed by an ultimately trusted key.\n",
1514                        pk_keyid_str (a->pkt->pkt.public_key));
1515
1516           return 1;
1517         }
1518     }
1519
1520   if (DBG_TRUST)
1521     log_debug ("TOFU: %s is NOT signed by an ultimately trusted key.\n",
1522                pk_keyid_str (a->pkt->pkt.public_key));
1523
1524   return 0;
1525 }
1526
1527
1528 enum
1529   {
1530     BINDING_NEW = 1 << 0,
1531     BINDING_CONFLICT = 1 << 1,
1532     BINDING_EXPIRED = 1 << 2,
1533     BINDING_REVOKED = 1 << 3
1534   };
1535
1536
1537 /* Ask the user about the binding.  There are three ways we could end
1538  * up here:
1539  *
1540  *   - This is a new binding and there is a conflict
1541  *     (policy == TOFU_POLICY_NONE && conflict_set_count > 1),
1542  *
1543  *   - This is a new binding and opt.tofu_default_policy is set to
1544  *     ask.  (policy == TOFU_POLICY_NONE && opt.tofu_default_policy ==
1545  *     TOFU_POLICY_ASK), or,
1546  *
1547  *   - The policy is ask (the user deferred last time) (policy ==
1548  *     TOFU_POLICY_ASK).
1549  *
1550  * Note: this function must not be called while in a transaction!
1551  *
1552  * CONFLICT_SET includes all of the conflicting bindings
1553  * with FINGERPRINT first.  FLAGS is a bit-wise or of
1554  * BINDING_NEW, etc.
1555  */
1556 static void
1557 ask_about_binding (ctrl_t ctrl,
1558                    enum tofu_policy *policy,
1559                    int *trust_level,
1560                    strlist_t conflict_set,
1561                    const char *fingerprint,
1562                    const char *email,
1563                    const char *user_id,
1564                    time_t now)
1565 {
1566   tofu_dbs_t dbs;
1567   strlist_t iter;
1568   int conflict_set_count = strlist_length (conflict_set);
1569   char *sqerr = NULL;
1570   int rc;
1571   estream_t fp;
1572   strlist_t other_user_ids = NULL;
1573   struct signature_stats *stats = NULL;
1574   struct signature_stats *stats_iter = NULL;
1575   char *prompt = NULL;
1576   const char *choices;
1577
1578   dbs = ctrl->tofu.dbs;
1579   log_assert (dbs);
1580   log_assert (dbs->in_transaction == 0);
1581
1582   fp = es_fopenmem (0, "rw,samethread");
1583   if (!fp)
1584     log_fatal ("error creating memory stream: %s\n",
1585                gpg_strerror (gpg_error_from_syserror()));
1586
1587   {
1588     char *text = format_conflict_msg_part1 (*policy, conflict_set, email);
1589     if (!text) /* FIXME: Return the error all the way up.  */
1590       log_fatal ("format failed: %s\n",
1591                  gpg_strerror (gpg_error_from_syserror()));
1592
1593     es_fputs (text, fp);
1594     es_fputc ('\n', fp);
1595     xfree (text);
1596   }
1597
1598   begin_transaction (ctrl, 0);
1599
1600   /* Find other user ids associated with this key and whether the
1601    * bindings are marked as good or bad.  */
1602   rc = gpgsql_stepx
1603     (dbs->db, &dbs->s.get_trust_gather_other_user_ids,
1604      strings_collect_cb2, &other_user_ids, &sqerr,
1605      "select user_id, policy from bindings where fingerprint = ?;",
1606      GPGSQL_ARG_STRING, fingerprint, GPGSQL_ARG_END);
1607   if (rc)
1608     {
1609       log_error (_("error gathering other user IDs: %s\n"), sqerr);
1610       sqlite3_free (sqerr);
1611       sqerr = NULL;
1612       rc = gpg_error (GPG_ERR_GENERAL);
1613     }
1614
1615   if (other_user_ids)
1616     {
1617       strlist_t strlist_iter;
1618
1619       es_fprintf (fp, _("This key's user IDs:\n"));
1620       for (strlist_iter = other_user_ids;
1621            strlist_iter;
1622            strlist_iter = strlist_iter->next)
1623         {
1624           char *other_user_id = strlist_iter->d;
1625           char *other_thing;
1626           enum tofu_policy other_policy;
1627
1628           log_assert (strlist_iter->next);
1629           strlist_iter = strlist_iter->next;
1630           other_thing = strlist_iter->d;
1631
1632           other_policy = atoi (other_thing);
1633
1634           es_fprintf (fp, "  %s (", other_user_id);
1635           es_fprintf (fp, _("policy: %s"), tofu_policy_str (other_policy));
1636           es_fprintf (fp, ")\n");
1637         }
1638       es_fprintf (fp, "\n");
1639
1640       free_strlist (other_user_ids);
1641     }
1642
1643   /* Get the stats for all the keys in CONFLICT_SET.  */
1644   strlist_rev (&conflict_set);
1645   for (iter = conflict_set; iter && ! rc; iter = iter->next)
1646     {
1647 #define STATS_SQL(table, time, sign)                         \
1648          "select fingerprint, policy, time_ago, count(*)\n" \
1649          " from\n" \
1650          "  (select bindings.*,\n" \
1651          "     "sign" case\n" \
1652          "       when delta ISNULL then 1\n" \
1653          /* From the future (but if its just a couple of hours in the \
1654           * future don't turn it into a warning)?  Or should we use \
1655           * small, medium or large units?  (Note: whatever we do, we \
1656           * keep the value in seconds.  Then when we group, everything \
1657           * that rounds to the same number of seconds is grouped.)  */ \
1658          "      when delta < -("STRINGIFY (TIME_AGO_FUTURE_IGNORE)") then 2\n" \
1659          "      when delta < ("STRINGIFY (TIME_AGO_SMALL_THRESHOLD)")\n" \
1660          "       then 3\n" \
1661          "      when delta < ("STRINGIFY (TIME_AGO_MEDIUM_THRESHOLD)")\n" \
1662          "       then 4\n" \
1663          "      when delta < ("STRINGIFY (TIME_AGO_LARGE_THRESHOLD)")\n" \
1664          "       then 5\n" \
1665          "      else 6\n" \
1666          "     end time_ago,\n" \
1667          "    delta time_ago_raw\n" \
1668          "   from bindings\n" \
1669          "   left join\n" \
1670          "     (select *,\n" \
1671          "        cast(? - " time " as real) delta\n" \
1672          "       from " table ") ss\n" \
1673          "    on ss.binding = bindings.oid)\n" \
1674          " where email = ? and fingerprint = ?\n" \
1675          " group by time_ago\n" \
1676          /* Make sure the current key is first.  */ \
1677          " order by time_ago desc;\n"
1678
1679       /* Use the time when we saw the signature, not when the
1680          signature was created as that can be forged.  */
1681       rc = gpgsql_stepx
1682         (dbs->db, &dbs->s.get_trust_gather_signature_stats,
1683          signature_stats_collect_cb, &stats, &sqerr,
1684          STATS_SQL ("signatures", "time", ""),
1685          GPGSQL_ARG_LONG_LONG, (long long) now,
1686          GPGSQL_ARG_STRING, email,
1687          GPGSQL_ARG_STRING, iter->d,
1688          GPGSQL_ARG_END);
1689       if (rc)
1690         {
1691           rc = gpg_error (GPG_ERR_GENERAL);
1692           break;
1693         }
1694
1695       if (!stats || strcmp (iter->d, stats->fingerprint) != 0)
1696         /* No stats for this binding.  Add a dummy entry.  */
1697         signature_stats_prepend (&stats, iter->d, TOFU_POLICY_AUTO, 1, 1);
1698
1699       rc = gpgsql_stepx
1700         (dbs->db, &dbs->s.get_trust_gather_encryption_stats,
1701          signature_stats_collect_cb, &stats, &sqerr,
1702          STATS_SQL ("encryptions", "time", "-"),
1703          GPGSQL_ARG_LONG_LONG, (long long) now,
1704          GPGSQL_ARG_STRING, email,
1705          GPGSQL_ARG_STRING, iter->d,
1706          GPGSQL_ARG_END);
1707       if (rc)
1708         {
1709           rc = gpg_error (GPG_ERR_GENERAL);
1710           break;
1711         }
1712
1713 #undef STATS_SQL
1714
1715       if (!stats || strcmp (iter->d, stats->fingerprint) != 0
1716           || stats->time_ago > 0)
1717         /* No stats for this binding.  Add a dummy entry.  */
1718         signature_stats_prepend (&stats, iter->d, TOFU_POLICY_AUTO, -1, 1);
1719     }
1720   end_transaction (ctrl, 0);
1721   strlist_rev (&conflict_set);
1722   if (rc)
1723     {
1724       strlist_t strlist_iter;
1725
1726       log_error (_("error gathering signature stats: %s\n"), sqerr);
1727       sqlite3_free (sqerr);
1728       sqerr = NULL;
1729
1730       es_fprintf (fp, ngettext("The email address \"%s\" is"
1731                                " associated with %d key:\n",
1732                                "The email address \"%s\" is"
1733                                " associated with %d keys:\n",
1734                                conflict_set_count),
1735                   email, conflict_set_count);
1736       for (strlist_iter = conflict_set;
1737            strlist_iter;
1738            strlist_iter = strlist_iter->next)
1739         es_fprintf (fp, "  %s\n", strlist_iter->d);
1740     }
1741   else
1742     {
1743       char *key = NULL;
1744       strlist_t binding;
1745       int seen_in_past = 0;
1746       int encrypted = 1;
1747
1748       es_fprintf (fp, _("Statistics for keys"
1749                         " with the email address \"%s\":\n"),
1750                   email);
1751       for (stats_iter = stats; stats_iter; stats_iter = stats_iter->next)
1752         {
1753 #if 0
1754           log_debug ("%s: time_ago: %ld; count: %ld\n",
1755                      stats_iter->fingerprint,
1756                      stats_iter->time_ago,
1757                      stats_iter->count);
1758 #endif
1759
1760           if (stats_iter->time_ago > 0 && encrypted)
1761             {
1762               /* We've change from the encrypted stats to the verified
1763                * stats.  Reset SEEN_IN_PAST.  */
1764               encrypted = 0;
1765               seen_in_past = 0;
1766             }
1767
1768           if (! key || strcmp (key, stats_iter->fingerprint))
1769             {
1770               int this_key;
1771               char *key_pp;
1772
1773               key = stats_iter->fingerprint;
1774               this_key = strcmp (key, fingerprint) == 0;
1775               key_pp = format_hexfingerprint (key, NULL, 0);
1776               es_fprintf (fp, "  %s (", key_pp);
1777
1778               /* Find the associated binding.  */
1779               for (binding = conflict_set;
1780                    binding;
1781                    binding = binding->next)
1782                 if (strcmp (key, binding->d) == 0)
1783                   break;
1784               log_assert (binding);
1785
1786               if ((binding->flags & BINDING_REVOKED))
1787                 {
1788                   es_fprintf (fp, _("revoked"));
1789                   es_fprintf (fp, ", ");
1790                 }
1791               else if ((binding->flags & BINDING_EXPIRED))
1792                 {
1793                   es_fprintf (fp, _("expired"));
1794                   es_fprintf (fp, ", ");
1795                 }
1796
1797               if (this_key)
1798                 es_fprintf (fp, _("this key"));
1799               else
1800                 es_fprintf (fp, _("policy: %s"),
1801                             tofu_policy_str (stats_iter->policy));
1802               es_fputs ("):\n", fp);
1803               xfree (key_pp);
1804
1805               seen_in_past = 0;
1806
1807               show_statistics (dbs, stats_iter->fingerprint, email,
1808                                TOFU_POLICY_ASK, NULL, 1, now);
1809             }
1810
1811           if (labs(stats_iter->time_ago) == 1)
1812             {
1813               /* The 1 in this case is the NULL entry.  */
1814               log_assert (stats_iter->count == 1);
1815               stats_iter->count = 0;
1816             }
1817           seen_in_past += stats_iter->count;
1818
1819           es_fputs ("    ", fp);
1820
1821           if (!stats_iter->count)
1822             {
1823               if (stats_iter->time_ago > 0)
1824                 es_fprintf (fp, ngettext("Verified %d message.",
1825                                          "Verified %d messages.",
1826                                          seen_in_past), seen_in_past);
1827               else
1828                 es_fprintf (fp, ngettext("Encrypted %d message.",
1829                                          "Encrypted %d messages.",
1830                                          seen_in_past), seen_in_past);
1831             }
1832           else if (labs(stats_iter->time_ago) == 2)
1833             {
1834               if (stats_iter->time_ago > 0)
1835                 es_fprintf (fp, ngettext("Verified %d message in the future.",
1836                                          "Verified %d messages in the future.",
1837                                          seen_in_past), seen_in_past);
1838               else
1839                 es_fprintf (fp, ngettext("Encrypted %d message in the future.",
1840                                          "Encrypted %d messages in the future.",
1841                                          seen_in_past), seen_in_past);
1842               /* Reset it.  */
1843               seen_in_past = 0;
1844             }
1845           else
1846             {
1847               if (labs(stats_iter->time_ago) == 3)
1848                 {
1849                   int days = 1 + stats_iter->time_ago / TIME_AGO_UNIT_SMALL;
1850                   if (stats_iter->time_ago > 0)
1851                     es_fprintf
1852                       (fp,
1853                        ngettext("Messages verified over the past %d day: %d.",
1854                                 "Messages verified over the past %d days: %d.",
1855                                 days), days, seen_in_past);
1856                   else
1857                     es_fprintf
1858                       (fp,
1859                        ngettext("Messages encrypted over the past %d day: %d.",
1860                                 "Messages encrypted over the past %d days: %d.",
1861                                 days), days, seen_in_past);
1862                 }
1863               else if (labs(stats_iter->time_ago) == 4)
1864                 {
1865                   int months = 1 + stats_iter->time_ago / TIME_AGO_UNIT_MEDIUM;
1866                   if (stats_iter->time_ago > 0)
1867                     es_fprintf
1868                       (fp,
1869                        ngettext("Messages verified over the past %d month: %d.",
1870                                 "Messages verified over the past %d months: %d.",
1871                                 months), months, seen_in_past);
1872                   else
1873                     es_fprintf
1874                       (fp,
1875                        ngettext("Messages encrypted over the past %d month: %d.",
1876                                 "Messages encrypted over the past %d months: %d.",
1877                                 months), months, seen_in_past);
1878                 }
1879               else if (labs(stats_iter->time_ago) == 5)
1880                 {
1881                   int years = 1 + stats_iter->time_ago / TIME_AGO_UNIT_LARGE;
1882                   if (stats_iter->time_ago > 0)
1883                     es_fprintf
1884                       (fp,
1885                        ngettext("Messages verified over the past %d year: %d.",
1886                                 "Messages verified over the past %d years: %d.",
1887                                 years), years, seen_in_past);
1888                   else
1889                     es_fprintf
1890                       (fp,
1891                        ngettext("Messages encrypted over the past %d year: %d.",
1892                                 "Messages encrypted over the past %d years: %d.",
1893                                 years), years, seen_in_past);
1894                 }
1895               else if (labs(stats_iter->time_ago) == 6)
1896                 {
1897                   if (stats_iter->time_ago > 0)
1898                     es_fprintf
1899                       (fp, _("Messages verified in the past: %d."),
1900                        seen_in_past);
1901                   else
1902                     es_fprintf
1903                       (fp, _("Messages encrypted in the past: %d."),
1904                        seen_in_past);
1905                 }
1906               else
1907                 log_assert (! "Broken SQL.\n");
1908             }
1909           es_fputs ("\n", fp);
1910         }
1911     }
1912
1913   if (conflict_set_count > 1 || (conflict_set->flags & BINDING_CONFLICT))
1914     {
1915       /* This is a conflict.  */
1916
1917       /* TRANSLATORS: Please translate the text found in the source
1918        * file below.  We don't directly internationalize that text so
1919        * that we can tweak it without breaking translations.  */
1920       const char *text = _("TOFU detected a binding conflict");
1921       char *textbuf;
1922       if (!strcmp (text, "TOFU detected a binding conflict"))
1923         {
1924           /* No translation.  Use the English text.  */
1925           text =
1926             "Normally, an email address is associated with a single key.  "
1927             "However, people sometimes generate a new key if "
1928             "their key is too old or they think it might be compromised.  "
1929             "Alternatively, a new key may indicate a man-in-the-middle "
1930             "attack!  Before accepting this association, you should talk to or "
1931             "call the person to make sure this new key is legitimate.";
1932         }
1933       textbuf = format_text (text, 72, 80);
1934       es_fprintf (fp, "\n%s\n", textbuf? textbuf : "[OUT OF CORE!]");
1935       xfree (textbuf);
1936     }
1937
1938   es_fputc ('\n', fp);
1939
1940   /* Add a NUL terminator.  */
1941   es_fputc (0, fp);
1942   if (es_fclose_snatch (fp, (void **) &prompt, NULL))
1943     log_fatal ("error snatching memory stream\n");
1944
1945   /* I think showing the large message once is sufficient.  If we
1946    * would move it right before the cpr_get many lines will scroll
1947    * away and the user might not realize that he merely entered a
1948    * wrong choice (because he does not see that either).  As a small
1949    * benefit we allow C-L to redisplay everything.  */
1950   tty_printf ("%s", prompt);
1951
1952   /* Suspend any transaction: it could take a while until the user
1953      responds.  */
1954   tofu_suspend_batch_transaction (ctrl);
1955   while (1)
1956     {
1957       char *response;
1958
1959       /* TRANSLATORS: Two letters (normally the lower and upper case
1960        * version of the hotkey) for each of the five choices.  If
1961        * there is only one choice in your language, repeat it.  */
1962       choices = _("gG" "aA" "uU" "rR" "bB");
1963       if (strlen (choices) != 10)
1964         log_bug ("Bad TOFU conflict translation!  Please report.");
1965
1966       response = cpr_get
1967         ("tofu.conflict",
1968          _("(G)ood, (A)ccept once, (U)nknown, (R)eject once, (B)ad? "));
1969       trim_spaces (response);
1970       cpr_kill_prompt ();
1971       if (*response == CONTROL_L)
1972         tty_printf ("%s", prompt);
1973       else if (!response[0])
1974         /* Default to unknown.  Don't save it.  */
1975         {
1976           tty_printf (_("Defaulting to unknown.\n"));
1977           *policy = TOFU_POLICY_UNKNOWN;
1978           break;
1979         }
1980       else if (!response[1])
1981         {
1982           char *choice = strchr (choices, *response);
1983
1984           if (choice)
1985             {
1986               int c = ((size_t) choice - (size_t) choices) / 2;
1987
1988               switch (c)
1989                 {
1990                 case 0: /* Good.  */
1991                   *policy = TOFU_POLICY_GOOD;
1992                   *trust_level = tofu_policy_to_trust_level (*policy);
1993                   break;
1994                 case 1: /* Accept once.  */
1995                   *policy = TOFU_POLICY_ASK;
1996                   *trust_level = tofu_policy_to_trust_level (TOFU_POLICY_GOOD);
1997                   break;
1998                 case 2: /* Unknown.  */
1999                   *policy = TOFU_POLICY_UNKNOWN;
2000                   *trust_level = tofu_policy_to_trust_level (*policy);
2001                   break;
2002                 case 3: /* Reject once.  */
2003                   *policy = TOFU_POLICY_ASK;
2004                   *trust_level = tofu_policy_to_trust_level (TOFU_POLICY_BAD);
2005                   break;
2006                 case 4: /* Bad.  */
2007                   *policy = TOFU_POLICY_BAD;
2008                   *trust_level = tofu_policy_to_trust_level (*policy);
2009                   break;
2010                 default:
2011                   log_bug ("c should be between 0 and 4 but it is %d!", c);
2012                 }
2013
2014               if (record_binding (dbs, fingerprint, email, user_id,
2015                                   *policy, TOFU_POLICY_NONE, NULL, 0, 0, now))
2016                 {
2017                   /* If there's an error registering the
2018                    * binding, don't save the signature.  */
2019                   *trust_level = _tofu_GET_TRUST_ERROR;
2020                 }
2021               break;
2022             }
2023         }
2024       xfree (response);
2025     }
2026
2027   tofu_resume_batch_transaction (ctrl);
2028
2029   xfree (prompt);
2030
2031   signature_stats_free (stats);
2032 }
2033
2034 /* Return the set of keys that conflict with the binding <fingerprint,
2035    email> (including the binding itself, which will be first in the
2036    list).  For each returned key also sets BINDING_NEW, etc.  */
2037 static strlist_t
2038 build_conflict_set (ctrl_t ctrl, tofu_dbs_t dbs,
2039                     PKT_public_key *pk, const char *fingerprint,
2040                     const char *email)
2041 {
2042   gpg_error_t rc;
2043   char *sqerr;
2044   strlist_t conflict_set = NULL;
2045   int conflict_set_count;
2046   strlist_t iter;
2047   kbnode_t *kb_all;
2048   KEYDB_HANDLE hd;
2049   int i;
2050
2051   /* Get the fingerprints of any bindings that share the email address
2052    * and whether the bindings have a known conflict.
2053    *
2054    * Note: if the binding in question is in the DB, it will also be
2055    * returned.  Thus, if the result set is empty, then <email,
2056    * fingerprint> is a new binding.  */
2057   rc = gpgsql_stepx
2058     (dbs->db, &dbs->s.get_trust_bindings_with_this_email,
2059      strings_collect_cb2, &conflict_set, &sqerr,
2060      "select"
2061      /* A binding should only appear once, but try not to break in the
2062       * case of corruption.  */
2063      "  fingerprint || case sum(conflict NOTNULL) when 0 then '' else '!' end"
2064      " from bindings where email = ?"
2065      "  group by fingerprint"
2066      /* Make sure the current key comes first in the result list (if
2067         it is present).  */
2068      "  order by fingerprint = ? asc, fingerprint desc;",
2069      GPGSQL_ARG_STRING, email,
2070      GPGSQL_ARG_STRING, fingerprint,
2071      GPGSQL_ARG_END);
2072   if (rc)
2073     {
2074       log_error (_("error reading TOFU database: %s\n"), sqerr);
2075       print_further_info ("listing fingerprints");
2076       sqlite3_free (sqerr);
2077       rc = gpg_error (GPG_ERR_GENERAL);
2078       return NULL;
2079     }
2080
2081   /* Set BINDING_CONFLICT if the binding has a known conflict.  This
2082    * allows us to distinguish between bindings where the user
2083    * explicitly set the policy to ask and bindings where we set the
2084    * policy to ask due to a conflict.  */
2085   for (iter = conflict_set; iter; iter = iter->next)
2086     {
2087       int l = strlen (iter->d);
2088       if (!(l == 2 * MAX_FINGERPRINT_LEN
2089             || l == 2 * MAX_FINGERPRINT_LEN + 1))
2090         {
2091           log_error (_("TOFU db corruption detected.\n"));
2092           print_further_info ("fingerprint '%s' is not %d characters long",
2093                               iter->d, 2 * MAX_FINGERPRINT_LEN);
2094         }
2095
2096       if (l >= 1 && iter->d[l - 1] == '!')
2097         {
2098           iter->flags |= BINDING_CONFLICT;
2099           /* Remove the !.  */
2100           iter->d[l - 1] = 0;
2101         }
2102     }
2103
2104   /* If the current binding has not yet been recorded, add it to the
2105    * list.  (The order by above ensures that if it is present, it will
2106    * be first.)  */
2107   if (! (conflict_set && strcmp (conflict_set->d, fingerprint) == 0))
2108     {
2109       add_to_strlist (&conflict_set, fingerprint);
2110       conflict_set->flags |= BINDING_NEW;
2111     }
2112
2113   conflict_set_count = strlist_length (conflict_set);
2114
2115   /* Eliminate false conflicts.  */
2116
2117   if (conflict_set_count == 1)
2118     /* We only have a single key.  There are no false conflicts to
2119        eliminate.  But, we do need to set the flags.  */
2120     {
2121       if (pk->has_expired)
2122         conflict_set->flags |= BINDING_EXPIRED;
2123       if (pk->flags.revoked)
2124         conflict_set->flags |= BINDING_REVOKED;
2125
2126       return conflict_set;
2127     }
2128
2129   /* If two keys have cross signatures, then they are controlled by
2130    * the same person and thus are not in conflict.  */
2131   kb_all = xcalloc (sizeof (kb_all[0]), conflict_set_count);
2132   hd = keydb_new ();
2133   for (i = 0, iter = conflict_set;
2134        i < conflict_set_count;
2135        i ++, iter = iter->next)
2136     {
2137       char *fp = iter->d;
2138       KEYDB_SEARCH_DESC desc;
2139       kbnode_t kb;
2140       PKT_public_key *binding_pk;
2141       kbnode_t n;
2142       int found_user_id;
2143
2144       rc = keydb_search_reset (hd);
2145       if (rc)
2146         {
2147           log_error (_("resetting keydb: %s\n"),
2148                      gpg_strerror (rc));
2149           continue;
2150         }
2151
2152       rc = classify_user_id (fp, &desc, 0);
2153       if (rc)
2154         {
2155           log_error (_("error parsing key specification '%s': %s\n"),
2156                      fp, gpg_strerror (rc));
2157           continue;
2158         }
2159
2160       rc = keydb_search (hd, &desc, 1, NULL);
2161       if (rc)
2162         {
2163           /* Note: it is entirely possible that we don't have the key
2164              corresponding to an entry in the TOFU DB.  This can
2165              happen if we merge two TOFU DBs, but not the key
2166              rings.  */
2167           log_info (_("key \"%s\" not found: %s\n"),
2168                     fp, gpg_strerror (rc));
2169           continue;
2170         }
2171
2172       rc = keydb_get_keyblock (hd, &kb);
2173       if (rc)
2174         {
2175           log_error (_("error reading keyblock: %s\n"),
2176                      gpg_strerror (rc));
2177           print_further_info ("fingerprint: %s", fp);
2178           continue;
2179         }
2180
2181       merge_keys_and_selfsig (ctrl, kb);
2182
2183       log_assert (kb->pkt->pkttype == PKT_PUBLIC_KEY);
2184
2185       kb_all[i] = kb;
2186
2187       /* Since we have the key block, use this opportunity to figure
2188        * out if the binding is expired or revoked.  */
2189       binding_pk = kb->pkt->pkt.public_key;
2190
2191       /* The binding is always expired/revoked if the key is
2192        * expired/revoked.  */
2193       if (binding_pk->has_expired)
2194         iter->flags |= BINDING_EXPIRED;
2195       if (binding_pk->flags.revoked)
2196         iter->flags |= BINDING_REVOKED;
2197
2198       /* The binding is also expired/revoked if the user id is
2199        * expired/revoked.  */
2200       n = kb;
2201       found_user_id = 0;
2202       while ((n = find_next_kbnode (n, PKT_USER_ID)) && ! found_user_id)
2203         {
2204           PKT_user_id *user_id2 = n->pkt->pkt.user_id;
2205           char *email2;
2206
2207           if (user_id2->attrib_data)
2208             continue;
2209
2210           email2 = email_from_user_id (user_id2->name);
2211
2212           if (strcmp (email, email2) == 0)
2213             {
2214               found_user_id = 1;
2215
2216               if (user_id2->flags.revoked)
2217                 iter->flags |= BINDING_REVOKED;
2218               if (user_id2->flags.expired)
2219                 iter->flags |= BINDING_EXPIRED;
2220             }
2221
2222           xfree (email2);
2223         }
2224
2225       if (! found_user_id)
2226         {
2227           log_info (_("TOFU db corruption detected.\n"));
2228           print_further_info ("user id '%s' not on key block '%s'",
2229                               email, fingerprint);
2230         }
2231     }
2232   keydb_release (hd);
2233
2234   /* Now that we have the key blocks, check for cross sigs.  */
2235   {
2236     int j;
2237     strlist_t *prevp;
2238     strlist_t iter_next;
2239     int *die;
2240
2241     log_assert (conflict_set_count > 0);
2242     die = xtrycalloc (conflict_set_count, sizeof *die);
2243     if (!die)
2244       {
2245         /*err = gpg_error_from_syserror ();*/
2246         xoutofcore (); /* Fixme: Let the function return an error.  */
2247       }
2248
2249     for (i = 0; i < conflict_set_count; i ++)
2250       {
2251         /* Look for cross sigs between this key (i == 0) or a key
2252          * that has cross sigs with i == 0 (i.e., transitively) */
2253         if (! (i == 0 || die[i]))
2254           continue;
2255
2256         for (j = i + 1; j < conflict_set_count; j ++)
2257           /* Be careful: we might not have a key block for a key.  */
2258           if (kb_all[i] && kb_all[j] && cross_sigs (email, kb_all[i], kb_all[j]))
2259             die[j] = 1;
2260       }
2261
2262     /* Free unconflicting bindings (and all of the key blocks).  */
2263     for (iter = conflict_set, prevp = &conflict_set, i = 0;
2264          iter;
2265          iter = iter_next, i ++)
2266       {
2267         iter_next = iter->next;
2268
2269         release_kbnode (kb_all[i]);
2270
2271         if (die[i])
2272           {
2273             *prevp = iter_next;
2274             iter->next = NULL;
2275             free_strlist (iter);
2276             conflict_set_count --;
2277           }
2278         else
2279           {
2280             prevp = &iter->next;
2281           }
2282       }
2283
2284     /* We shouldn't have removed the head.  */
2285     log_assert (conflict_set);
2286     log_assert (conflict_set_count >= 1);
2287     xfree (die);
2288   }
2289   xfree (kb_all);
2290
2291   if (DBG_TRUST)
2292     {
2293       log_debug ("binding <key: %s, email: %s> conflicts:\n",
2294                  fingerprint, email);
2295       for (iter = conflict_set; iter; iter = iter->next)
2296         {
2297           log_debug ("  %s:%s%s%s%s\n",
2298                      iter->d,
2299                      (iter->flags & BINDING_NEW) ? " new" : "",
2300                      (iter->flags & BINDING_CONFLICT) ? " known_conflict" : "",
2301                      (iter->flags & BINDING_EXPIRED) ? " expired" : "",
2302                      (iter->flags & BINDING_REVOKED) ? " revoked" : "");
2303         }
2304     }
2305
2306   return conflict_set;
2307 }
2308
2309
2310 /* Return the effective policy for the binding <FINGERPRINT, EMAIL>
2311  * (email has already been normalized).  Returns
2312  * _tofu_GET_POLICY_ERROR if an error occurs.  Returns any conflict
2313  * information in *CONFLICT_SETP if CONFLICT_SETP is not NULL and the
2314  * returned policy is TOFU_POLICY_ASK (consequently, if there is a
2315  * conflict, but the user set the policy to good *CONFLICT_SETP will
2316  * empty).  Note: as per build_conflict_set, which is used to build
2317  * the conflict information, the conflict information includes the
2318  * current user id as the first element of the linked list.
2319  *
2320  * This function registers the binding in the bindings table if it has
2321  * not yet been registered.
2322  */
2323 static enum tofu_policy
2324 get_policy (ctrl_t ctrl, tofu_dbs_t dbs, PKT_public_key *pk,
2325             const char *fingerprint, const char *user_id, const char *email,
2326             strlist_t *conflict_setp, time_t now)
2327 {
2328   int rc;
2329   char *err = NULL;
2330   strlist_t results = NULL;
2331   enum tofu_policy policy = _tofu_GET_POLICY_ERROR;
2332   enum tofu_policy effective_policy_orig = TOFU_POLICY_NONE;
2333   enum tofu_policy effective_policy = _tofu_GET_POLICY_ERROR;
2334   long along;
2335   char *conflict_orig = NULL;
2336   char *conflict = NULL;
2337   strlist_t conflict_set = NULL;
2338   int conflict_set_count;
2339
2340   /* Check if the <FINGERPRINT, EMAIL> binding is known
2341      (TOFU_POLICY_NONE cannot appear in the DB.  Thus, if POLICY is
2342      still TOFU_POLICY_NONE after executing the query, then the
2343      result set was empty.)  */
2344   rc = gpgsql_stepx (dbs->db, &dbs->s.get_policy_select_policy_and_conflict,
2345                       strings_collect_cb2, &results, &err,
2346                       "select policy, conflict, effective_policy from bindings\n"
2347                       " where fingerprint = ? and email = ?",
2348                       GPGSQL_ARG_STRING, fingerprint,
2349                       GPGSQL_ARG_STRING, email,
2350                       GPGSQL_ARG_END);
2351   if (rc)
2352     {
2353       log_error (_("error reading TOFU database: %s\n"), err);
2354       print_further_info ("reading the policy");
2355       sqlite3_free (err);
2356       rc = gpg_error (GPG_ERR_GENERAL);
2357       goto out;
2358     }
2359
2360   if (strlist_length (results) == 0)
2361     {
2362       /* No results.  Use the defaults.  */
2363       policy = TOFU_POLICY_NONE;
2364       effective_policy = TOFU_POLICY_NONE;
2365     }
2366   else if (strlist_length (results) == 3)
2367     {
2368       /* Parse and sanity check the results.  */
2369
2370       if (string_to_long (&along, results->d, 0, __LINE__))
2371         {
2372           log_error (_("error reading TOFU database: %s\n"),
2373                      gpg_strerror (GPG_ERR_BAD_DATA));
2374           print_further_info ("bad value for policy: %s", results->d);
2375           goto out;
2376         }
2377       policy = along;
2378
2379       if (! (policy == TOFU_POLICY_AUTO
2380              || policy == TOFU_POLICY_GOOD
2381              || policy == TOFU_POLICY_UNKNOWN
2382              || policy == TOFU_POLICY_BAD
2383              || policy == TOFU_POLICY_ASK))
2384         {
2385           log_error (_("error reading TOFU database: %s\n"),
2386                      gpg_strerror (GPG_ERR_DB_CORRUPTED));
2387           print_further_info ("invalid value for policy (%d)", policy);
2388           effective_policy = _tofu_GET_POLICY_ERROR;
2389           goto out;
2390         }
2391
2392       if (*results->next->d)
2393         conflict = xstrdup (results->next->d);
2394
2395       if (string_to_long (&along, results->next->next->d, 0, __LINE__))
2396         {
2397           log_error (_("error reading TOFU database: %s\n"),
2398                      gpg_strerror (GPG_ERR_BAD_DATA));
2399           print_further_info ("bad value for effective policy: %s",
2400                               results->next->next->d);
2401           goto out;
2402         }
2403       effective_policy = along;
2404
2405       if (! (effective_policy == TOFU_POLICY_NONE
2406              || effective_policy == TOFU_POLICY_AUTO
2407              || effective_policy == TOFU_POLICY_GOOD
2408              || effective_policy == TOFU_POLICY_UNKNOWN
2409              || effective_policy == TOFU_POLICY_BAD
2410              || effective_policy == TOFU_POLICY_ASK))
2411         {
2412           log_error (_("error reading TOFU database: %s\n"),
2413                      gpg_strerror (GPG_ERR_DB_CORRUPTED));
2414           print_further_info ("invalid value for effective_policy (%d)",
2415                               effective_policy);
2416           effective_policy = _tofu_GET_POLICY_ERROR;
2417           goto out;
2418         }
2419     }
2420   else
2421     {
2422       /* The result has the wrong form.  */
2423
2424       log_error (_("error reading TOFU database: %s\n"),
2425                  gpg_strerror (GPG_ERR_BAD_DATA));
2426       print_further_info ("reading policy: expected 3 columns, got %d\n",
2427                           strlist_length (results));
2428       goto out;
2429     }
2430
2431   /* Save the effective policy and conflict so we know if we changed
2432    * them.  */
2433   effective_policy_orig = effective_policy;
2434   conflict_orig = conflict;
2435
2436   /* Unless there is a conflict, if the effective policy is cached,
2437    * just return it.  The reason we don't do this when there is a
2438    * conflict is because of the following scenario: assume A and B
2439    * conflict and B has signed A's key.  Now, later we import A's
2440    * signature on B.  We need to recheck A, but the signature was on
2441    * B, i.e., when B changes, we invalidate B's effective policy, but
2442    * we also need to invalidate A's effective policy.  Instead, we
2443    * assume that conflicts are rare and don't optimize for them, which
2444    * would complicate the code.  */
2445   if (effective_policy != TOFU_POLICY_NONE && !conflict)
2446     goto out;
2447
2448   /* If the user explicitly set the policy, then respect that.  */
2449   if (policy != TOFU_POLICY_AUTO && policy != TOFU_POLICY_NONE)
2450     {
2451       effective_policy = policy;
2452       goto out;
2453     }
2454
2455   /* Unless proven wrong, assume the effective policy is 'auto'.  */
2456   effective_policy = TOFU_POLICY_AUTO;
2457
2458   /* See if the key is ultimately trusted.  */
2459   {
2460     u32 kid[2];
2461
2462     keyid_from_pk (pk, kid);
2463     if (tdb_keyid_is_utk (kid))
2464       {
2465         effective_policy = TOFU_POLICY_GOOD;
2466         goto out;
2467       }
2468   }
2469
2470   /* See if the key is signed by an ultimately trusted key.  */
2471   {
2472     int fingerprint_raw_len = strlen (fingerprint) / 2;
2473     char fingerprint_raw[20];
2474     int len = 0;
2475
2476     if (fingerprint_raw_len != sizeof fingerprint_raw
2477         || ((len = hex2bin (fingerprint,
2478                             fingerprint_raw, fingerprint_raw_len))
2479             != strlen (fingerprint)))
2480       {
2481         if (DBG_TRUST)
2482           log_debug ("TOFU: Bad fingerprint: %s (len: %zu, parsed: %d)\n",
2483                      fingerprint, strlen (fingerprint), len);
2484       }
2485     else
2486       {
2487         int lookup_err;
2488         kbnode_t kb;
2489
2490         lookup_err = get_pubkey_byfprint (ctrl, NULL, &kb,
2491                                           fingerprint_raw,
2492                                           fingerprint_raw_len);
2493         if (lookup_err)
2494           {
2495             if (DBG_TRUST)
2496               log_debug ("TOFU: Looking up %s: %s\n",
2497                          fingerprint, gpg_strerror (lookup_err));
2498           }
2499         else
2500           {
2501             int is_signed_by_utk = signed_by_utk (email, kb);
2502             release_kbnode (kb);
2503             if (is_signed_by_utk)
2504               {
2505                 effective_policy = TOFU_POLICY_GOOD;
2506                 goto out;
2507               }
2508           }
2509       }
2510   }
2511
2512   /* Check for any conflicts / see if a previously discovered conflict
2513    * disappeared.  The latter can happen if the conflicting bindings
2514    * are now cross signed, for instance.  */
2515
2516   conflict_set = build_conflict_set (ctrl, dbs, pk, fingerprint, email);
2517   conflict_set_count = strlist_length (conflict_set);
2518   if (conflict_set_count == 0)
2519     {
2520       /* build_conflict_set should always at least return the current
2521          binding.  Something went wrong.  */
2522       effective_policy = _tofu_GET_POLICY_ERROR;
2523       goto out;
2524     }
2525
2526   if (conflict_set_count == 1
2527       && (conflict_set->flags & BINDING_NEW))
2528     {
2529       /* We've never observed a binding with this email address and we
2530        * have a default policy, which is not to ask the user.  */
2531
2532       /* If we've seen this binding, then we've seen this email and
2533        * policy couldn't possibly be TOFU_POLICY_NONE.  */
2534       log_assert (policy == TOFU_POLICY_NONE);
2535
2536       if (DBG_TRUST)
2537         log_debug ("TOFU: New binding <key: %s, user id: %s>, no conflict.\n",
2538                    fingerprint, email);
2539
2540       effective_policy = TOFU_POLICY_AUTO;
2541       goto out;
2542     }
2543
2544   if (conflict_set_count == 1
2545       && (conflict_set->flags & BINDING_CONFLICT))
2546     {
2547       /* No known conflicts now, but there was a conflict.  This means
2548        * at some point, there was a conflict and we changed this
2549        * binding's policy to ask and set the conflicting key.  The
2550        * conflict can go away if there is not a cross sig between the
2551        * two keys.  In this case, just silently clear the conflict and
2552        * reset the policy to auto.  */
2553
2554       if (DBG_TRUST)
2555         log_debug ("TOFU: binding <key: %s, user id: %s> had a conflict, but it's been resolved (probably via  cross sig).\n",
2556                    fingerprint, email);
2557
2558       effective_policy = TOFU_POLICY_AUTO;
2559       conflict = NULL;
2560
2561       goto out;
2562     }
2563
2564   if (conflict_set_count == 1)
2565     {
2566       /* No conflicts and never marked as conflicting.  */
2567
2568       log_assert (!conflict);
2569
2570       effective_policy = TOFU_POLICY_AUTO;
2571
2572       goto out;
2573     }
2574
2575   /* There is a conflicting key.  */
2576   log_assert (conflict_set_count > 1);
2577   effective_policy = TOFU_POLICY_ASK;
2578   conflict = xstrdup (conflict_set->next->d);
2579
2580  out:
2581   log_assert (policy == _tofu_GET_POLICY_ERROR
2582               || policy == TOFU_POLICY_NONE
2583               || policy == TOFU_POLICY_AUTO
2584               || policy == TOFU_POLICY_GOOD
2585               || policy == TOFU_POLICY_UNKNOWN
2586               || policy == TOFU_POLICY_BAD
2587               || policy == TOFU_POLICY_ASK);
2588   /* Everything but NONE.  */
2589   log_assert (effective_policy == _tofu_GET_POLICY_ERROR
2590               || effective_policy == TOFU_POLICY_AUTO
2591               || effective_policy == TOFU_POLICY_GOOD
2592               || effective_policy == TOFU_POLICY_UNKNOWN
2593               || effective_policy == TOFU_POLICY_BAD
2594               || effective_policy == TOFU_POLICY_ASK);
2595
2596   if (effective_policy != TOFU_POLICY_ASK && conflict)
2597     conflict = NULL;
2598
2599   /* If we don't have a record of this binding, its effective policy
2600    * changed, or conflict changed, update the DB.  */
2601   if (effective_policy != _tofu_GET_POLICY_ERROR
2602       && (/* New binding.  */
2603           policy == TOFU_POLICY_NONE
2604           /* effective_policy changed.  */
2605           || effective_policy != effective_policy_orig
2606           /* conflict changed.  */
2607           || (conflict != conflict_orig
2608               && (!conflict || !conflict_orig
2609                   || strcmp (conflict, conflict_orig) != 0))))
2610     {
2611       if (record_binding (dbs, fingerprint, email, user_id,
2612                           policy == TOFU_POLICY_NONE ? TOFU_POLICY_AUTO : policy,
2613                           effective_policy, conflict, 1, 0, now) != 0)
2614         log_error (_("error setting TOFU binding's policy"
2615                      " to %s\n"), tofu_policy_str (policy));
2616     }
2617
2618   /* If the caller wants the set of conflicts, return it.  */
2619   if (effective_policy == TOFU_POLICY_ASK && conflict_setp)
2620     {
2621       if (! conflict_set)
2622         conflict_set = build_conflict_set (ctrl, dbs, pk, fingerprint, email);
2623       *conflict_setp = conflict_set;
2624     }
2625   else
2626     {
2627       free_strlist (conflict_set);
2628
2629       if (conflict_setp)
2630         *conflict_setp = NULL;
2631     }
2632
2633   xfree (conflict_orig);
2634   if (conflict != conflict_orig)
2635     xfree (conflict);
2636   free_strlist (results);
2637
2638   return effective_policy;
2639 }
2640
2641
2642 /* Return the trust level (TRUST_NEVER, etc.) for the binding
2643  * <FINGERPRINT, EMAIL> (email is already normalized).  If no policy
2644  * is registered, returns TOFU_POLICY_NONE.  If an error occurs,
2645  * returns _tofu_GET_TRUST_ERROR.
2646  *
2647  * PK is the public key object for FINGERPRINT.
2648  *
2649  * USER_ID is the unadulterated user id.
2650  *
2651  * If MAY_ASK is set, then we may interact with the user.  This is
2652  * necessary if there is a conflict or the binding's policy is
2653  * TOFU_POLICY_ASK.  In the case of a conflict, we set the new
2654  * conflicting binding's policy to TOFU_POLICY_ASK.  In either case,
2655  * we return TRUST_UNDEFINED.  Note: if MAY_ASK is set, then this
2656  * function must not be called while in a transaction!  */
2657 static enum tofu_policy
2658 get_trust (ctrl_t ctrl, PKT_public_key *pk,
2659            const char *fingerprint, const char *email,
2660            const char *user_id, int may_ask,
2661            enum tofu_policy *policyp, strlist_t *conflict_setp,
2662            time_t now)
2663 {
2664   tofu_dbs_t dbs = ctrl->tofu.dbs;
2665   int in_transaction = 0;
2666   enum tofu_policy policy;
2667   int rc;
2668   char *sqerr = NULL;
2669   strlist_t conflict_set = NULL;
2670   int trust_level = TRUST_UNKNOWN;
2671   strlist_t iter;
2672
2673   log_assert (dbs);
2674
2675   if (may_ask)
2676     log_assert (dbs->in_transaction == 0);
2677
2678   if (opt.batch)
2679     may_ask = 0;
2680
2681   log_assert (pk_is_primary (pk));
2682
2683   /* Make sure _tofu_GET_TRUST_ERROR isn't equal to any of the trust
2684      levels.  */
2685   log_assert (_tofu_GET_TRUST_ERROR != TRUST_UNKNOWN
2686               && _tofu_GET_TRUST_ERROR != TRUST_EXPIRED
2687               && _tofu_GET_TRUST_ERROR != TRUST_UNDEFINED
2688               && _tofu_GET_TRUST_ERROR != TRUST_NEVER
2689               && _tofu_GET_TRUST_ERROR != TRUST_MARGINAL
2690               && _tofu_GET_TRUST_ERROR != TRUST_FULLY
2691               && _tofu_GET_TRUST_ERROR != TRUST_ULTIMATE);
2692
2693   begin_transaction (ctrl, 0);
2694   in_transaction = 1;
2695
2696   /* We need to call get_policy even if the key is ultimately trusted
2697    * to make sure the binding has been registered.  */
2698   policy = get_policy (ctrl, dbs, pk, fingerprint, user_id, email,
2699                        &conflict_set, now);
2700
2701   if (policy == TOFU_POLICY_ASK)
2702     /* The conflict set should always contain at least one element:
2703      * the current key.  */
2704     log_assert (conflict_set);
2705   else
2706     /* If the policy is not TOFU_POLICY_ASK, then conflict_set will be
2707      * NULL.  */
2708     log_assert (! conflict_set);
2709
2710   /* If the key is ultimately trusted, there is nothing to do.  */
2711   {
2712     u32 kid[2];
2713
2714     keyid_from_pk (pk, kid);
2715     if (tdb_keyid_is_utk (kid))
2716       {
2717         trust_level = TRUST_ULTIMATE;
2718         policy = TOFU_POLICY_GOOD;
2719         goto out;
2720       }
2721   }
2722
2723   if (policy == TOFU_POLICY_AUTO)
2724     {
2725       policy = opt.tofu_default_policy;
2726       if (DBG_TRUST)
2727         log_debug ("TOFU: binding <key: %s, user id: %s>'s policy is"
2728                    " auto (default: %s).\n",
2729                    fingerprint, email,
2730                    tofu_policy_str (opt.tofu_default_policy));
2731
2732       if (policy == TOFU_POLICY_ASK)
2733         /* The default policy is ASK, but there is no conflict (policy
2734          * was 'auto').  In this case, we need to make sure the
2735          * conflict set includes at least the current user id.  */
2736         {
2737           add_to_strlist (&conflict_set, fingerprint);
2738         }
2739     }
2740   switch (policy)
2741     {
2742     case TOFU_POLICY_AUTO:
2743     case TOFU_POLICY_GOOD:
2744     case TOFU_POLICY_UNKNOWN:
2745     case TOFU_POLICY_BAD:
2746       /* The saved judgement is auto -> auto, good, unknown or bad.
2747        * We don't need to ask the user anything.  */
2748       if (DBG_TRUST)
2749         log_debug ("TOFU: Known binding <key: %s, user id: %s>'s policy: %s\n",
2750                    fingerprint, email, tofu_policy_str (policy));
2751       trust_level = tofu_policy_to_trust_level (policy);
2752       goto out;
2753
2754     case TOFU_POLICY_ASK:
2755       /* We need to ask the user what to do.  */
2756       break;
2757
2758     case _tofu_GET_POLICY_ERROR:
2759       trust_level = _tofu_GET_TRUST_ERROR;
2760       goto out;
2761
2762     default:
2763       log_bug ("%s: Impossible value for policy (%d)\n", __func__, policy);
2764     }
2765
2766
2767   /* We get here if:
2768    *
2769    *   1. The saved policy is auto and the default policy is ask
2770    *      (get_policy() == TOFU_POLICY_AUTO
2771    *       && opt.tofu_default_policy == TOFU_POLICY_ASK)
2772    *
2773    *   2. The saved policy is ask (either last time the user selected
2774    *      accept once or reject once or there was a conflict and this
2775    *      binding's policy was changed from auto to ask)
2776    *      (policy == TOFU_POLICY_ASK).
2777    */
2778   log_assert (policy == TOFU_POLICY_ASK);
2779
2780   if (may_ask)
2781     {
2782       /* We can't be in a normal transaction in ask_about_binding.  */
2783       end_transaction (ctrl, 0);
2784       in_transaction = 0;
2785
2786       /* If we get here, we need to ask the user about the binding.  */
2787       ask_about_binding (ctrl,
2788                          &policy,
2789                          &trust_level,
2790                          conflict_set,
2791                          fingerprint,
2792                          email,
2793                          user_id,
2794                          now);
2795     }
2796   else
2797     {
2798       trust_level = TRUST_UNDEFINED;
2799     }
2800
2801   /* Mark any conflicting bindings that have an automatic policy as
2802    * now requiring confirmation.  Note: we do this after we ask for
2803    * confirmation so that when the current policy is printed, it is
2804    * correct.  */
2805   if (! in_transaction)
2806     {
2807       begin_transaction (ctrl, 0);
2808       in_transaction = 1;
2809     }
2810
2811   /* The conflict set should always contain at least one element:
2812    * the current key.  */
2813   log_assert (conflict_set);
2814
2815   for (iter = conflict_set->next; iter; iter = iter->next)
2816     {
2817       /* We don't immediately set the effective policy to 'ask,
2818          because  */
2819       rc = gpgsql_exec_printf
2820         (dbs->db, NULL, NULL, &sqerr,
2821          "update bindings set effective_policy = %d, conflict = %Q"
2822          " where email = %Q and fingerprint = %Q and effective_policy != %d;",
2823          TOFU_POLICY_NONE, fingerprint,
2824          email, iter->d, TOFU_POLICY_ASK);
2825       if (rc)
2826         {
2827           log_error (_("error changing TOFU policy: %s\n"), sqerr);
2828           print_further_info ("binding: <key: %s, user id: %s>",
2829                               fingerprint, user_id);
2830           sqlite3_free (sqerr);
2831           sqerr = NULL;
2832           rc = gpg_error (GPG_ERR_GENERAL);
2833         }
2834       else if (DBG_TRUST)
2835         log_debug ("Set %s to conflict with %s\n",
2836                    iter->d, fingerprint);
2837     }
2838
2839  out:
2840   if (in_transaction)
2841     end_transaction (ctrl, 0);
2842
2843   if (policyp)
2844     *policyp = policy;
2845
2846   if (conflict_setp)
2847     *conflict_setp = conflict_set;
2848   else
2849     free_strlist (conflict_set);
2850
2851   return trust_level;
2852 }
2853
2854
2855 /* Return a malloced string of the form
2856  *    "7~months"
2857  * The caller should replace all '~' in the returned string by a space
2858  * and also free the returned string.
2859  *
2860  * This is actually a bad hack which may not work correctly with all
2861  * languages.
2862  */
2863 static char *
2864 time_ago_str (long long int t)
2865 {
2866   /* It would be nice to use a macro to do this, but gettext
2867      works on the unpreprocessed code.  */
2868 #define MIN_SECS (60)
2869 #define HOUR_SECS (60 * MIN_SECS)
2870 #define DAY_SECS (24 * HOUR_SECS)
2871 #define WEEK_SECS (7 * DAY_SECS)
2872 #define MONTH_SECS (30 * DAY_SECS)
2873 #define YEAR_SECS (365 * DAY_SECS)
2874
2875   if (t > 2 * YEAR_SECS)
2876     {
2877       long long int c = t / YEAR_SECS;
2878       return xtryasprintf (ngettext("%lld~year", "%lld~years", c), c);
2879     }
2880   if (t > 2 * MONTH_SECS)
2881     {
2882       long long int c = t / MONTH_SECS;
2883       return xtryasprintf (ngettext("%lld~month", "%lld~months", c), c);
2884     }
2885   if (t > 2 * WEEK_SECS)
2886     {
2887       long long int c = t / WEEK_SECS;
2888       return xtryasprintf (ngettext("%lld~week", "%lld~weeks", c), c);
2889     }
2890   if (t > 2 * DAY_SECS)
2891     {
2892       long long int c = t / DAY_SECS;
2893       return xtryasprintf (ngettext("%lld~day", "%lld~days", c), c);
2894     }
2895   if (t > 2 * HOUR_SECS)
2896     {
2897       long long int c = t / HOUR_SECS;
2898       return xtryasprintf (ngettext("%lld~hour", "%lld~hours", c), c);
2899     }
2900   if (t > 2 * MIN_SECS)
2901     {
2902       long long int c = t / MIN_SECS;
2903       return xtryasprintf (ngettext("%lld~minute", "%lld~minutes", c), c);
2904     }
2905   return xtryasprintf (ngettext("%lld~second", "%lld~seconds", t), t);
2906 }
2907
2908
2909 /* If FP is NULL, write TOFU_STATS status line.  If FP is not NULL
2910  * write a "tfs" record to that stream. */
2911 static void
2912 write_stats_status (estream_t fp,
2913                     enum tofu_policy policy,
2914                     unsigned long signature_count,
2915                     unsigned long signature_first_seen,
2916                     unsigned long signature_most_recent,
2917                     unsigned long signature_days,
2918                     unsigned long encryption_count,
2919                     unsigned long encryption_first_done,
2920                     unsigned long encryption_most_recent,
2921                     unsigned long encryption_days)
2922 {
2923   int summary;
2924   int validity;
2925   unsigned long days;
2926
2927   /* Use the euclidean distance (m = sqrt(a^2 + b^2)) rather then the
2928      sum of the magnitudes (m = a + b) to ensure a balance between
2929      verified signatures and encrypted messages.  */
2930   days = sqrtu32 (signature_days * signature_days
2931                   + encryption_days * encryption_days);
2932
2933   if (days < 1)
2934     validity = 1; /* Key without history.  */
2935   else if (days < 2 * BASIC_TRUST_THRESHOLD)
2936     validity = 2; /* Key with too little history.  */
2937   else if (days < 2 * FULL_TRUST_THRESHOLD)
2938     validity = 3; /* Key with enough history for basic trust.  */
2939   else
2940     validity = 4; /* Key with a lot of history.  */
2941
2942   if (policy == TOFU_POLICY_ASK)
2943     summary = 0; /* Key requires attention.  */
2944   else
2945     summary = validity;
2946
2947   if (fp)
2948     {
2949       es_fprintf (fp, "tfs:1:%d:%lu:%lu:%s:%lu:%lu:%lu:%lu:%d:%lu:%lu:\n",
2950                   summary, signature_count, encryption_count,
2951                   tofu_policy_str (policy),
2952                   signature_first_seen, signature_most_recent,
2953                   encryption_first_done, encryption_most_recent,
2954                   validity, signature_days, encryption_days);
2955     }
2956   else
2957     {
2958       write_status_printf (STATUS_TOFU_STATS,
2959                            "%d %lu %lu %s %lu %lu %lu %lu %d %lu %lu",
2960                            summary,
2961                            signature_count,
2962                            encryption_count,
2963                            tofu_policy_str (policy),
2964                            signature_first_seen,
2965                            signature_most_recent,
2966                            encryption_first_done,
2967                            encryption_most_recent,
2968                            validity,
2969                            signature_days, encryption_days);
2970     }
2971 }
2972
2973 /* Note: If OUTFP is not NULL, this function merely prints a "tfs" record
2974  * to OUTFP.
2975  *
2976  * POLICY is the key's policy (as returned by get_policy).
2977  *
2978  * Returns 0 if ONLY_STATUS_FD is set.  Otherwise, returns whether
2979  * the caller should call show_warning after iterating over all user
2980  * ids.
2981  */
2982 static int
2983 show_statistics (tofu_dbs_t dbs,
2984                  const char *fingerprint, const char *email,
2985                  enum tofu_policy policy,
2986                  estream_t outfp, int only_status_fd, time_t now)
2987 {
2988   char *fingerprint_pp;
2989   int rc;
2990   strlist_t strlist = NULL;
2991   char *err = NULL;
2992
2993   unsigned long signature_first_seen = 0;
2994   unsigned long signature_most_recent = 0;
2995   unsigned long signature_count = 0;
2996   unsigned long signature_days = 0;
2997   unsigned long encryption_first_done = 0;
2998   unsigned long encryption_most_recent = 0;
2999   unsigned long encryption_count = 0;
3000   unsigned long encryption_days = 0;
3001
3002   int show_warning = 0;
3003
3004   if (only_status_fd && ! is_status_enabled ())
3005     return 0;
3006
3007   fingerprint_pp = format_hexfingerprint (fingerprint, NULL, 0);
3008
3009   /* Get the signature stats.  */
3010   rc = gpgsql_exec_printf
3011     (dbs->db, strings_collect_cb, &strlist, &err,
3012      "select count (*), coalesce (min (signatures.time), 0),\n"
3013      "  coalesce (max (signatures.time), 0)\n"
3014      " from signatures\n"
3015      " left join bindings on signatures.binding = bindings.oid\n"
3016      " where fingerprint = %Q and email = %Q;",
3017      fingerprint, email);
3018   if (rc)
3019     {
3020       log_error (_("error reading TOFU database: %s\n"), err);
3021       print_further_info ("getting signature statistics");
3022       sqlite3_free (err);
3023       rc = gpg_error (GPG_ERR_GENERAL);
3024       goto out;
3025     }
3026   rc = gpgsql_exec_printf
3027     (dbs->db, strings_collect_cb, &strlist, &err,
3028      "select count (*) from\n"
3029      "  (select round(signatures.time / (24 * 60 * 60)) day\n"
3030      "    from signatures\n"
3031      "    left join bindings on signatures.binding = bindings.oid\n"
3032      "    where fingerprint = %Q and email = %Q\n"
3033      "    group by day);",
3034      fingerprint, email);
3035   if (rc)
3036     {
3037       log_error (_("error reading TOFU database: %s\n"), err);
3038       print_further_info ("getting signature statistics (by day)");
3039       sqlite3_free (err);
3040       rc = gpg_error (GPG_ERR_GENERAL);
3041       goto out;
3042     }
3043
3044   if (strlist)
3045     {
3046       /* We expect exactly 4 elements.  */
3047       log_assert (strlist->next);
3048       log_assert (strlist->next->next);
3049       log_assert (strlist->next->next->next);
3050       log_assert (! strlist->next->next->next->next);
3051
3052       string_to_ulong (&signature_days, strlist->d, -1, __LINE__);
3053       string_to_ulong (&signature_count, strlist->next->d, -1, __LINE__);
3054       string_to_ulong (&signature_first_seen,
3055                        strlist->next->next->d, -1, __LINE__);
3056       string_to_ulong (&signature_most_recent,
3057                        strlist->next->next->next->d, -1, __LINE__);
3058
3059       free_strlist (strlist);
3060       strlist = NULL;
3061     }
3062
3063   /* Get the encryption stats.  */
3064   rc = gpgsql_exec_printf
3065     (dbs->db, strings_collect_cb, &strlist, &err,
3066      "select count (*), coalesce (min (encryptions.time), 0),\n"
3067      "  coalesce (max (encryptions.time), 0)\n"
3068      " from encryptions\n"
3069      " left join bindings on encryptions.binding = bindings.oid\n"
3070      " where fingerprint = %Q and email = %Q;",
3071      fingerprint, email);
3072   if (rc)
3073     {
3074       log_error (_("error reading TOFU database: %s\n"), err);
3075       print_further_info ("getting encryption statistics");
3076       sqlite3_free (err);
3077       rc = gpg_error (GPG_ERR_GENERAL);
3078       goto out;
3079     }
3080   rc = gpgsql_exec_printf
3081     (dbs->db, strings_collect_cb, &strlist, &err,
3082      "select count (*) from\n"
3083      "  (select round(encryptions.time / (24 * 60 * 60)) day\n"
3084      "    from encryptions\n"
3085      "    left join bindings on encryptions.binding = bindings.oid\n"
3086      "    where fingerprint = %Q and email = %Q\n"
3087      "    group by day);",
3088      fingerprint, email);
3089   if (rc)
3090     {
3091       log_error (_("error reading TOFU database: %s\n"), err);
3092       print_further_info ("getting encryption statistics (by day)");
3093       sqlite3_free (err);
3094       rc = gpg_error (GPG_ERR_GENERAL);
3095       goto out;
3096     }
3097
3098   if (strlist)
3099     {
3100       /* We expect exactly 4 elements.  */
3101       log_assert (strlist->next);
3102       log_assert (strlist->next->next);
3103       log_assert (strlist->next->next->next);
3104       log_assert (! strlist->next->next->next->next);
3105
3106       string_to_ulong (&encryption_days, strlist->d, -1, __LINE__);
3107       string_to_ulong (&encryption_count, strlist->next->d, -1, __LINE__);
3108       string_to_ulong (&encryption_first_done,
3109                        strlist->next->next->d, -1, __LINE__);
3110       string_to_ulong (&encryption_most_recent,
3111                        strlist->next->next->next->d, -1, __LINE__);
3112
3113       free_strlist (strlist);
3114       strlist = NULL;
3115     }
3116
3117   if (!outfp)
3118     write_status_text_and_buffer (STATUS_TOFU_USER, fingerprint,
3119                                   email, strlen (email), 0);
3120
3121   write_stats_status (outfp, policy,
3122                       signature_count,
3123                       signature_first_seen,
3124                       signature_most_recent,
3125                       signature_days,
3126                       encryption_count,
3127                       encryption_first_done,
3128                       encryption_most_recent,
3129                       encryption_days);
3130
3131   if (!outfp && !only_status_fd)
3132     {
3133       estream_t fp;
3134       char *msg;
3135
3136       fp = es_fopenmem (0, "rw,samethread");
3137       if (! fp)
3138         log_fatal ("error creating memory stream: %s\n",
3139                    gpg_strerror (gpg_error_from_syserror()));
3140
3141       if (signature_count == 0 && encryption_count == 0)
3142         {
3143           es_fprintf (fp,
3144                       _("%s: Verified 0~signatures and encrypted 0~messages."),
3145                       email);
3146         }
3147       else
3148         {
3149           if (signature_count == 0)
3150             es_fprintf (fp, _("%s: Verified 0 signatures."), email);
3151           else
3152             {
3153               /* TRANSLATORS: The final %s is replaced by a string like
3154                  "7~months". */
3155               char *ago_str = time_ago_str (now - signature_first_seen);
3156               es_fprintf
3157                 (fp,
3158                  ngettext("%s: Verified %ld~signature in the past %s.",
3159                           "%s: Verified %ld~signatures in the past %s.",
3160                           signature_count),
3161                  email, signature_count, ago_str);
3162               xfree (ago_str);
3163             }
3164
3165           es_fputs ("  ", fp);
3166
3167           if (encryption_count == 0)
3168             es_fprintf (fp, _("Encrypted 0 messages."));
3169           else
3170             {
3171               char *ago_str = time_ago_str (now - encryption_first_done);
3172
3173               /* TRANSLATORS: The final %s is replaced by a string like
3174                  "7~months". */
3175               es_fprintf (fp,
3176                           ngettext("Encrypted %ld~message in the past %s.",
3177                                    "Encrypted %ld~messages in the past %s.",
3178                                    encryption_count),
3179                           encryption_count, ago_str);
3180               xfree (ago_str);
3181             }
3182         }
3183
3184       if (opt.verbose)
3185         {
3186           es_fputs ("  ", fp);
3187           es_fprintf (fp, _("(policy: %s)"), tofu_policy_str (policy));
3188         }
3189       es_fputs ("\n", fp);
3190
3191
3192       {
3193         char *tmpmsg, *p;
3194         es_fputc (0, fp);
3195         if (es_fclose_snatch (fp, (void **) &tmpmsg, NULL))
3196           log_fatal ("error snatching memory stream\n");
3197         msg = format_text (tmpmsg, 72, 80);
3198         if (!msg) /* FIXME: Return the error all the way up.  */
3199           log_fatal ("format failed: %s\n",
3200                      gpg_strerror (gpg_error_from_syserror()));
3201         es_free (tmpmsg);
3202
3203         /* Print a status line but suppress the trailing LF.
3204          * Spaces are not percent escaped. */
3205         if (*msg)
3206           write_status_buffer (STATUS_TOFU_STATS_LONG,
3207                                msg, strlen (msg)-1, -1);
3208
3209         /* Remove the non-breaking space markers.  */
3210         for (p=msg; *p; p++)
3211           if (*p == '~')
3212             *p = ' ';
3213       }
3214
3215       log_string (GPGRT_LOG_INFO, msg);
3216       xfree (msg);
3217
3218       if (policy == TOFU_POLICY_AUTO)
3219         {
3220           if (signature_count == 0)
3221             log_info (_("Warning: we have yet to see"
3222                         " a message signed using this key and user id!\n"));
3223           else if (signature_count == 1)
3224             log_info (_("Warning: we've only seen one message"
3225                         " signed using this key and user id!\n"));
3226
3227           if (encryption_count == 0)
3228             log_info (_("Warning: you have yet to encrypt"
3229                         " a message to this key!\n"));
3230           else if (encryption_count == 1)
3231             log_info (_("Warning: you have only encrypted"
3232                         " one message to this key!\n"));
3233
3234           /* Cf. write_stats_status  */
3235           if (sqrtu32 (encryption_count * encryption_count
3236                        + signature_count * signature_count)
3237               < 2 * BASIC_TRUST_THRESHOLD)
3238             show_warning = 1;
3239         }
3240     }
3241
3242  out:
3243   xfree (fingerprint_pp);
3244
3245   return show_warning;
3246 }
3247
3248 static void
3249 show_warning (const char *fingerprint, strlist_t user_id_list)
3250 {
3251   char *set_policy_command;
3252   char *text;
3253   char *tmpmsg;
3254
3255   set_policy_command =
3256     xasprintf ("gpg --tofu-policy bad %s", fingerprint);
3257
3258   tmpmsg = xasprintf
3259     (ngettext
3260      ("Warning: if you think you've seen more signatures "
3261       "by this key and user id, then this key might be a "
3262       "forgery!  Carefully examine the email address for small "
3263       "variations.  If the key is suspect, then use\n"
3264       "  %s\n"
3265       "to mark it as being bad.\n",
3266       "Warning: if you think you've seen more signatures "
3267       "by this key and these user ids, then this key might be a "
3268       "forgery!  Carefully examine the email addresses for small "
3269       "variations.  If the key is suspect, then use\n"
3270       "  %s\n"
3271       "to mark it as being bad.\n",
3272       strlist_length (user_id_list)),
3273      set_policy_command);
3274
3275   text = format_text (tmpmsg, 72, 80);
3276   if (!text) /* FIXME: Return the error all the way up.  */
3277     log_fatal ("format failed: %s\n",
3278                gpg_strerror (gpg_error_from_syserror()));
3279   xfree (tmpmsg);
3280   log_string (GPGRT_LOG_INFO, text);
3281   xfree (text);
3282
3283   es_free (set_policy_command);
3284 }
3285
3286
3287 /* Extract the email address from a user id and normalize it.  If the
3288    user id doesn't contain an email address, then we use the whole
3289    user_id and normalize that.  The returned string must be freed.  */
3290 static char *
3291 email_from_user_id (const char *user_id)
3292 {
3293   char *email = mailbox_from_userid (user_id);
3294   if (! email)
3295     {
3296       /* Hmm, no email address was provided or we are out of core.  Just
3297          take the lower-case version of the whole user id.  It could be
3298          a hostname, for instance.  */
3299       email = ascii_strlwr (xstrdup (user_id));
3300     }
3301
3302   return email;
3303 }
3304
3305 /* Register the signature with the bindings <fingerprint, USER_ID>,
3306    for each USER_ID in USER_ID_LIST.  The fingerprint is taken from
3307    the primary key packet PK.
3308
3309    SIG_DIGEST_BIN is the binary representation of the message's
3310    digest.  SIG_DIGEST_BIN_LEN is its length.
3311
3312    SIG_TIME is the time that the signature was generated.
3313
3314    ORIGIN is a free-formed string describing the origin of the
3315    signature.  If this was from an email and the Claws MUA was used,
3316    then this should be something like: "email:claws".  If this is
3317    NULL, the default is simply "unknown".
3318
3319    If MAY_ASK is 1, then this function may interact with the user.
3320    This is necessary if there is a conflict or the binding's policy is
3321    TOFU_POLICY_ASK.
3322
3323    This function returns 0 on success and an error code if an error
3324    occurred.  */
3325 gpg_error_t
3326 tofu_register_signature (ctrl_t ctrl,
3327                          PKT_public_key *pk, strlist_t user_id_list,
3328                          const byte *sig_digest_bin, int sig_digest_bin_len,
3329                          time_t sig_time, const char *origin)
3330 {
3331   time_t now = gnupg_get_time ();
3332   gpg_error_t rc;
3333   tofu_dbs_t dbs;
3334   char *fingerprint = NULL;
3335   strlist_t user_id;
3336   char *email = NULL;
3337   char *err = NULL;
3338   char *sig_digest;
3339   unsigned long c;
3340
3341   dbs = opendbs (ctrl);
3342   if (! dbs)
3343     {
3344       rc = gpg_error (GPG_ERR_GENERAL);
3345       log_error (_("error opening TOFU database: %s\n"),
3346                  gpg_strerror (rc));
3347       return rc;
3348     }
3349
3350   /* We do a query and then an insert.  Make sure they are atomic
3351      by wrapping them in a transaction.  */
3352   rc = begin_transaction (ctrl, 0);
3353   if (rc)
3354     return rc;
3355
3356   log_assert (pk_is_primary (pk));
3357
3358   sig_digest = make_radix64_string (sig_digest_bin, sig_digest_bin_len);
3359   fingerprint = hexfingerprint (pk, NULL, 0);
3360
3361   if (! origin)
3362     /* The default origin is simply "unknown".  */
3363     origin = "unknown";
3364
3365   for (user_id = user_id_list; user_id; user_id = user_id->next)
3366     {
3367       email = email_from_user_id (user_id->d);
3368
3369       if (DBG_TRUST)
3370         log_debug ("TOFU: Registering signature %s with binding"
3371                    " <key: %s, user id: %s>\n",
3372                    sig_digest, fingerprint, email);
3373
3374       /* Make sure the binding exists and record any TOFU
3375          conflicts.  */
3376       if (get_trust (ctrl, pk, fingerprint, email, user_id->d,
3377                      0, NULL, NULL, now)
3378           == _tofu_GET_TRUST_ERROR)
3379         {
3380           rc = gpg_error (GPG_ERR_GENERAL);
3381           xfree (email);
3382           break;
3383         }
3384
3385       /* If we've already seen this signature before, then don't add
3386          it again.  */
3387       rc = gpgsql_stepx
3388         (dbs->db, &dbs->s.register_already_seen,
3389          get_single_unsigned_long_cb2, &c, &err,
3390          "select count (*)\n"
3391          " from signatures left join bindings\n"
3392          "  on signatures.binding = bindings.oid\n"
3393          " where fingerprint = ? and email = ? and sig_time = ?\n"
3394          "  and sig_digest = ?",
3395          GPGSQL_ARG_STRING, fingerprint, GPGSQL_ARG_STRING, email,
3396          GPGSQL_ARG_LONG_LONG, (long long) sig_time,
3397          GPGSQL_ARG_STRING, sig_digest,
3398          GPGSQL_ARG_END);
3399       if (rc)
3400         {
3401           log_error (_("error reading TOFU database: %s\n"), err);
3402           print_further_info ("checking existence");
3403           sqlite3_free (err);
3404           rc = gpg_error (GPG_ERR_GENERAL);
3405         }
3406       else if (c > 1)
3407         /* Duplicates!  This should not happen.  In particular,
3408            because <fingerprint, email, sig_time, sig_digest> is the
3409            primary key!  */
3410         log_debug ("SIGNATURES DB contains duplicate records"
3411                    " <key: %s, email: %s, time: 0x%lx, sig: %s,"
3412                    " origin: %s>."
3413                    "  Please report.\n",
3414                    fingerprint, email, (unsigned long) sig_time,
3415                    sig_digest, origin);
3416       else if (c == 1)
3417         {
3418           if (DBG_TRUST)
3419             log_debug ("Already observed the signature and binding"
3420                        " <key: %s, email: %s, time: 0x%lx, sig: %s,"
3421                        " origin: %s>\n",
3422                        fingerprint, email, (unsigned long) sig_time,
3423                        sig_digest, origin);
3424         }
3425       else if (opt.dry_run)
3426         {
3427           log_info ("TOFU database update skipped due to --dry-run\n");
3428         }
3429       else
3430         /* This is the first time that we've seen this signature and
3431            binding.  Record it.  */
3432         {
3433           if (DBG_TRUST)
3434             log_debug ("TOFU: Saving signature"
3435                        " <key: %s, user id: %s, sig: %s>\n",
3436                        fingerprint, email, sig_digest);
3437
3438           log_assert (c == 0);
3439
3440           rc = gpgsql_stepx
3441             (dbs->db, &dbs->s.register_signature, NULL, NULL, &err,
3442              "insert into signatures\n"
3443              " (binding, sig_digest, origin, sig_time, time)\n"
3444              " values\n"
3445              " ((select oid from bindings\n"
3446              "    where fingerprint = ? and email = ?),\n"
3447              "  ?, ?, ?, ?);",
3448              GPGSQL_ARG_STRING, fingerprint, GPGSQL_ARG_STRING, email,
3449              GPGSQL_ARG_STRING, sig_digest, GPGSQL_ARG_STRING, origin,
3450              GPGSQL_ARG_LONG_LONG, (long long) sig_time,
3451              GPGSQL_ARG_LONG_LONG, (long long) now,
3452              GPGSQL_ARG_END);
3453           if (rc)
3454             {
3455               log_error (_("error updating TOFU database: %s\n"), err);
3456               print_further_info ("insert signatures");
3457               sqlite3_free (err);
3458               rc = gpg_error (GPG_ERR_GENERAL);
3459             }
3460         }
3461
3462       xfree (email);
3463
3464       if (rc)
3465         break;
3466     }
3467
3468   if (rc)
3469     rollback_transaction (ctrl);
3470   else
3471     rc = end_transaction (ctrl, 0);
3472
3473   xfree (fingerprint);
3474   xfree (sig_digest);
3475
3476   return rc;
3477 }
3478
3479 gpg_error_t
3480 tofu_register_encryption (ctrl_t ctrl,
3481                           PKT_public_key *pk, strlist_t user_id_list,
3482                           int may_ask)
3483 {
3484   time_t now = gnupg_get_time ();
3485   gpg_error_t rc = 0;
3486   tofu_dbs_t dbs;
3487   kbnode_t kb = NULL;
3488   int free_user_id_list = 0;
3489   char *fingerprint = NULL;
3490   strlist_t user_id;
3491   char *err = NULL;
3492
3493   dbs = opendbs (ctrl);
3494   if (! dbs)
3495     {
3496       rc = gpg_error (GPG_ERR_GENERAL);
3497       log_error (_("error opening TOFU database: %s\n"),
3498                  gpg_strerror (rc));
3499       return rc;
3500     }
3501
3502   if (/* We need the key block to find the primary key.  */
3503       ! pk_is_primary (pk)
3504       /* We need the key block to find all user ids.  */
3505       || ! user_id_list)
3506     kb = get_pubkeyblock (ctrl, pk->keyid);
3507
3508   /* Make sure PK is a primary key.  */
3509   if (! pk_is_primary (pk))
3510     pk = kb->pkt->pkt.public_key;
3511
3512   if (! user_id_list)
3513     {
3514       /* Use all non-revoked user ids.  Do use expired user ids.  */
3515       kbnode_t n = kb;
3516
3517       while ((n = find_next_kbnode (n, PKT_USER_ID)))
3518         {
3519           PKT_user_id *uid = n->pkt->pkt.user_id;
3520
3521           if (uid->flags.revoked)
3522             continue;
3523
3524           add_to_strlist (&user_id_list, uid->name);
3525         }
3526
3527       free_user_id_list = 1;
3528
3529       if (! user_id_list)
3530         log_info (_("WARNING: Encrypting to %s, which has no "
3531                     "non-revoked user ids\n"),
3532                   keystr (pk->keyid));
3533     }
3534
3535   fingerprint = hexfingerprint (pk, NULL, 0);
3536
3537   tofu_begin_batch_update (ctrl);
3538   tofu_resume_batch_transaction (ctrl);
3539
3540   for (user_id = user_id_list; user_id; user_id = user_id->next)
3541     {
3542       char *email = email_from_user_id (user_id->d);
3543       strlist_t conflict_set = NULL;
3544       enum tofu_policy policy;
3545
3546       /* Make sure the binding exists and that we recognize any
3547          conflicts.  */
3548       int tl = get_trust (ctrl, pk, fingerprint, email, user_id->d,
3549                           may_ask, &policy, &conflict_set, now);
3550       if (tl == _tofu_GET_TRUST_ERROR)
3551         {
3552           /* An error.  */
3553           rc = gpg_error (GPG_ERR_GENERAL);
3554           xfree (email);
3555           goto die;
3556         }
3557
3558
3559       /* If there is a conflict and MAY_ASK is true, we need to show
3560        * the TOFU statistics for the current binding and the
3561        * conflicting bindings.  But, if we are not in batch mode, then
3562        * they have already been printed (this is required to make sure
3563        * the information is available to the caller before cpr_get is
3564        * called).  */
3565       if (policy == TOFU_POLICY_ASK && may_ask && opt.batch)
3566         {
3567           strlist_t iter;
3568
3569           /* The conflict set should contain at least the current
3570            * key.  */
3571           log_assert (conflict_set);
3572
3573           for (iter = conflict_set; iter; iter = iter->next)
3574             show_statistics (dbs, iter->d, email,
3575                              TOFU_POLICY_ASK, NULL, 1, now);
3576         }
3577
3578       free_strlist (conflict_set);
3579
3580       rc = gpgsql_stepx
3581         (dbs->db, &dbs->s.register_encryption, NULL, NULL, &err,
3582          "insert into encryptions\n"
3583          " (binding, time)\n"
3584          " values\n"
3585          " ((select oid from bindings\n"
3586          "    where fingerprint = ? and email = ?),\n"
3587          "  ?);",
3588          GPGSQL_ARG_STRING, fingerprint, GPGSQL_ARG_STRING, email,
3589          GPGSQL_ARG_LONG_LONG, (long long) now,
3590          GPGSQL_ARG_END);
3591       if (rc)
3592         {
3593           log_error (_("error updating TOFU database: %s\n"), err);
3594           print_further_info ("insert encryption");
3595           sqlite3_free (err);
3596           rc = gpg_error (GPG_ERR_GENERAL);
3597         }
3598
3599       xfree (email);
3600     }
3601
3602  die:
3603   tofu_end_batch_update (ctrl);
3604
3605   if (kb)
3606     release_kbnode (kb);
3607
3608   if (free_user_id_list)
3609     free_strlist (user_id_list);
3610
3611   xfree (fingerprint);
3612
3613   return rc;
3614 }
3615
3616
3617 /* Combine a trust level returned from the TOFU trust model with a
3618    trust level returned by the PGP trust model.  This is primarily of
3619    interest when the trust model is tofu+pgp (TM_TOFU_PGP).
3620
3621    This function ors together the upper bits (the values not covered
3622    by TRUST_MASK, i.e., TRUST_FLAG_REVOKED, etc.).  */
3623 int
3624 tofu_wot_trust_combine (int tofu_base, int wot_base)
3625 {
3626   int tofu = tofu_base & TRUST_MASK;
3627   int wot = wot_base & TRUST_MASK;
3628   int upper = (tofu_base & ~TRUST_MASK) | (wot_base & ~TRUST_MASK);
3629
3630   log_assert (tofu == TRUST_UNKNOWN
3631               || tofu == TRUST_EXPIRED
3632               || tofu == TRUST_UNDEFINED
3633               || tofu == TRUST_NEVER
3634               || tofu == TRUST_MARGINAL
3635               || tofu == TRUST_FULLY
3636               || tofu == TRUST_ULTIMATE);
3637   log_assert (wot == TRUST_UNKNOWN
3638               || wot == TRUST_EXPIRED
3639               || wot == TRUST_UNDEFINED
3640               || wot == TRUST_NEVER
3641               || wot == TRUST_MARGINAL
3642               || wot == TRUST_FULLY
3643               || wot == TRUST_ULTIMATE);
3644
3645   /* We first consider negative trust policys.  These trump positive
3646      trust policies.  */
3647   if (tofu == TRUST_NEVER || wot == TRUST_NEVER)
3648     /* TRUST_NEVER trumps everything else.  */
3649     return upper | TRUST_NEVER;
3650   if (tofu == TRUST_EXPIRED || wot == TRUST_EXPIRED)
3651     /* TRUST_EXPIRED trumps everything but TRUST_NEVER.  */
3652     return upper | TRUST_EXPIRED;
3653
3654   /* Now we only have positive or neutral trust policies.  We take
3655      the max.  */
3656   if (tofu == TRUST_ULTIMATE)
3657     return upper | TRUST_ULTIMATE | TRUST_FLAG_TOFU_BASED;
3658   if (wot == TRUST_ULTIMATE)
3659     return upper | TRUST_ULTIMATE;
3660
3661   if (tofu == TRUST_FULLY)
3662     return upper | TRUST_FULLY | TRUST_FLAG_TOFU_BASED;
3663   if (wot == TRUST_FULLY)
3664     return upper | TRUST_FULLY;
3665
3666   if (tofu == TRUST_MARGINAL)
3667     return upper | TRUST_MARGINAL | TRUST_FLAG_TOFU_BASED;
3668   if (wot == TRUST_MARGINAL)
3669     return upper | TRUST_MARGINAL;
3670
3671   if (tofu == TRUST_UNDEFINED)
3672     return upper | TRUST_UNDEFINED | TRUST_FLAG_TOFU_BASED;
3673   if (wot == TRUST_UNDEFINED)
3674     return upper | TRUST_UNDEFINED;
3675
3676   return upper | TRUST_UNKNOWN;
3677 }
3678
3679
3680 /* Write a "tfs" record for a --with-colons listing.  */
3681 gpg_error_t
3682 tofu_write_tfs_record (ctrl_t ctrl, estream_t fp,
3683                        PKT_public_key *pk, const char *user_id)
3684 {
3685   time_t now = gnupg_get_time ();
3686   gpg_error_t err;
3687   tofu_dbs_t dbs;
3688   char *fingerprint;
3689   char *email;
3690   enum tofu_policy policy;
3691
3692   if (!*user_id)
3693     return 0;  /* No TOFU stats possible for an empty ID.  */
3694
3695   dbs = opendbs (ctrl);
3696   if (!dbs)
3697     {
3698       err = gpg_error (GPG_ERR_GENERAL);
3699       log_error (_("error opening TOFU database: %s\n"), gpg_strerror (err));
3700       return err;
3701     }
3702
3703   fingerprint = hexfingerprint (pk, NULL, 0);
3704   email = email_from_user_id (user_id);
3705   policy = get_policy (ctrl, dbs, pk, fingerprint, user_id, email, NULL, now);
3706
3707   show_statistics (dbs, fingerprint, email, policy, fp, 0, now);
3708
3709   xfree (email);
3710   xfree (fingerprint);
3711   return 0;
3712 }
3713
3714
3715 /* Return the validity (TRUST_NEVER, etc.) of the bindings
3716    <FINGERPRINT, USER_ID>, for each USER_ID in USER_ID_LIST.  If
3717    USER_ID_LIST->FLAG is set, then the id is considered to be expired.
3718
3719    PK is the primary key packet.
3720
3721    If MAY_ASK is 1 and the policy is TOFU_POLICY_ASK, then the user
3722    will be prompted to choose a policy.  If MAY_ASK is 0 and the
3723    policy is TOFU_POLICY_ASK, then TRUST_UNKNOWN is returned.
3724
3725    Returns TRUST_UNDEFINED if an error occurs.  */
3726 int
3727 tofu_get_validity (ctrl_t ctrl, PKT_public_key *pk, strlist_t user_id_list,
3728                    int may_ask)
3729 {
3730   time_t now = gnupg_get_time ();
3731   tofu_dbs_t dbs;
3732   char *fingerprint = NULL;
3733   strlist_t user_id;
3734   int trust_level = TRUST_UNKNOWN;
3735   int bindings = 0;
3736   int bindings_valid = 0;
3737   int need_warning = 0;
3738   int had_conflict = 0;
3739
3740   dbs = opendbs (ctrl);
3741   if (! dbs)
3742     {
3743       log_error (_("error opening TOFU database: %s\n"),
3744                  gpg_strerror (GPG_ERR_GENERAL));
3745       return TRUST_UNDEFINED;
3746     }
3747
3748   fingerprint = hexfingerprint (pk, NULL, 0);
3749
3750   tofu_begin_batch_update (ctrl);
3751   /* Start the batch transaction now.  */
3752   tofu_resume_batch_transaction (ctrl);
3753
3754   for (user_id = user_id_list; user_id; user_id = user_id->next, bindings ++)
3755     {
3756       char *email = email_from_user_id (user_id->d);
3757       strlist_t conflict_set = NULL;
3758       enum tofu_policy policy;
3759
3760       /* Always call get_trust to make sure the binding is
3761          registered.  */
3762       int tl = get_trust (ctrl, pk, fingerprint, email, user_id->d,
3763                           may_ask, &policy, &conflict_set, now);
3764       if (tl == _tofu_GET_TRUST_ERROR)
3765         {
3766           /* An error.  */
3767           trust_level = TRUST_UNDEFINED;
3768           xfree (email);
3769           goto die;
3770         }
3771
3772       if (DBG_TRUST)
3773         log_debug ("TOFU: validity for <key: %s, user id: %s>: %s%s.\n",
3774                    fingerprint, email,
3775                    trust_value_to_string (tl),
3776                    user_id->flags ? " (but expired)" : "");
3777
3778       if (user_id->flags)
3779         tl = TRUST_EXPIRED;
3780
3781       if (tl != TRUST_EXPIRED)
3782         bindings_valid ++;
3783
3784       if (may_ask && tl != TRUST_ULTIMATE && tl != TRUST_EXPIRED)
3785         {
3786           /* If policy is ask, then we already printed out the
3787            * conflict information in ask_about_binding or will do so
3788            * in a moment.  */
3789           if (policy != TOFU_POLICY_ASK)
3790             need_warning |=
3791               show_statistics (dbs, fingerprint, email, policy, NULL, 0, now);
3792
3793           /* If there is a conflict and MAY_ASK is true, we need to
3794            * show the TOFU statistics for the current binding and the
3795            * conflicting bindings.  But, if we are not in batch mode,
3796            * then they have already been printed (this is required to
3797            * make sure the information is available to the caller
3798            * before cpr_get is called).  */
3799           if (policy == TOFU_POLICY_ASK && opt.batch)
3800             {
3801               strlist_t iter;
3802
3803               /* The conflict set should contain at least the current
3804                * key.  */
3805               log_assert (conflict_set);
3806
3807               had_conflict = 1;
3808               for (iter = conflict_set; iter; iter = iter->next)
3809                 show_statistics (dbs, iter->d, email,
3810                                  TOFU_POLICY_ASK, NULL, 1, now);
3811             }
3812         }
3813
3814       free_strlist (conflict_set);
3815
3816       if (tl == TRUST_NEVER)
3817         trust_level = TRUST_NEVER;
3818       else if (tl == TRUST_EXPIRED)
3819         /* Ignore expired bindings in the trust calculation.  */
3820         ;
3821       else if (tl > trust_level)
3822         {
3823           /* The expected values: */
3824           log_assert (tl == TRUST_UNKNOWN || tl == TRUST_UNDEFINED
3825                       || tl == TRUST_MARGINAL || tl == TRUST_FULLY
3826                       || tl == TRUST_ULTIMATE);
3827
3828           /* We assume the following ordering:  */
3829           log_assert (TRUST_UNKNOWN < TRUST_UNDEFINED);
3830           log_assert (TRUST_UNDEFINED < TRUST_MARGINAL);
3831           log_assert (TRUST_MARGINAL < TRUST_FULLY);
3832           log_assert (TRUST_FULLY < TRUST_ULTIMATE);
3833
3834           trust_level = tl;
3835         }
3836
3837       xfree (email);
3838     }
3839
3840   if (need_warning && ! had_conflict)
3841     show_warning (fingerprint, user_id_list);
3842
3843  die:
3844   tofu_end_batch_update (ctrl);
3845
3846   xfree (fingerprint);
3847
3848   if (bindings_valid == 0)
3849     {
3850       if (DBG_TRUST)
3851         log_debug ("no (of %d) valid bindings."
3852                    "  Can't get TOFU validity for this set of user ids.\n",
3853                    bindings);
3854       return TRUST_NEVER;
3855     }
3856
3857   return trust_level;
3858 }
3859
3860 /* Set the policy for all non-revoked user ids in the keyblock KB to
3861    POLICY.
3862
3863    If no key is available with the specified key id, then this
3864    function returns GPG_ERR_NO_PUBKEY.
3865
3866    Returns 0 on success and an error code otherwise.  */
3867 gpg_error_t
3868 tofu_set_policy (ctrl_t ctrl, kbnode_t kb, enum tofu_policy policy)
3869 {
3870   gpg_error_t err = 0;
3871   time_t now = gnupg_get_time ();
3872   tofu_dbs_t dbs;
3873   PKT_public_key *pk;
3874   char *fingerprint = NULL;
3875
3876   log_assert (kb->pkt->pkttype == PKT_PUBLIC_KEY);
3877   pk = kb->pkt->pkt.public_key;
3878
3879   dbs = opendbs (ctrl);
3880   if (! dbs)
3881     {
3882       log_error (_("error opening TOFU database: %s\n"),
3883                  gpg_strerror (GPG_ERR_GENERAL));
3884       return gpg_error (GPG_ERR_GENERAL);
3885     }
3886
3887   if (DBG_TRUST)
3888     log_debug ("Setting TOFU policy for %s to %s\n",
3889                keystr (pk->keyid), tofu_policy_str (policy));
3890   if (! pk_is_primary (pk))
3891     log_bug ("%s: Passed a subkey, but expecting a primary key.\n", __func__);
3892
3893   fingerprint = hexfingerprint (pk, NULL, 0);
3894
3895   begin_transaction (ctrl, 0);
3896
3897   for (; kb; kb = kb->next)
3898     {
3899       PKT_user_id *user_id;
3900       char *email;
3901
3902       if (kb->pkt->pkttype != PKT_USER_ID)
3903         continue;
3904
3905       user_id = kb->pkt->pkt.user_id;
3906       if (user_id->flags.revoked)
3907         /* Skip revoked user ids.  (Don't skip expired user ids, the
3908            expiry can be changed.)  */
3909         continue;
3910
3911       email = email_from_user_id (user_id->name);
3912
3913       err = record_binding (dbs, fingerprint, email, user_id->name,
3914                             policy, TOFU_POLICY_NONE, NULL, 0, 1, now);
3915       if (err)
3916         {
3917           log_error (_("error setting policy for key %s, user id \"%s\": %s"),
3918                      fingerprint, email, gpg_strerror (err));
3919           xfree (email);
3920           break;
3921         }
3922
3923       xfree (email);
3924     }
3925
3926   if (err)
3927     rollback_transaction (ctrl);
3928   else
3929     end_transaction (ctrl, 0);
3930
3931   xfree (fingerprint);
3932   return err;
3933 }
3934
3935 /* Return the TOFU policy for the specified binding in *POLICY.  If no
3936    policy has been set for the binding, sets *POLICY to
3937    TOFU_POLICY_NONE.
3938
3939    PK is a primary public key and USER_ID is a user id.
3940
3941    Returns 0 on success and an error code otherwise.  */
3942 gpg_error_t
3943 tofu_get_policy (ctrl_t ctrl, PKT_public_key *pk, PKT_user_id *user_id,
3944                  enum tofu_policy *policy)
3945 {
3946   time_t now = gnupg_get_time ();
3947   tofu_dbs_t dbs;
3948   char *fingerprint;
3949   char *email;
3950
3951   /* Make sure PK is a primary key.  */
3952   log_assert (pk_is_primary (pk));
3953
3954   dbs = opendbs (ctrl);
3955   if (! dbs)
3956     {
3957       log_error (_("error opening TOFU database: %s\n"),
3958                  gpg_strerror (GPG_ERR_GENERAL));
3959       return gpg_error (GPG_ERR_GENERAL);
3960     }
3961
3962   fingerprint = hexfingerprint (pk, NULL, 0);
3963
3964   email = email_from_user_id (user_id->name);
3965
3966   *policy = get_policy (ctrl, dbs, pk, fingerprint,
3967                         user_id->name, email, NULL, now);
3968
3969   xfree (email);
3970   xfree (fingerprint);
3971   if (*policy == _tofu_GET_POLICY_ERROR)
3972     return gpg_error (GPG_ERR_GENERAL);
3973   return 0;
3974 }
3975
3976 gpg_error_t
3977 tofu_notice_key_changed (ctrl_t ctrl, kbnode_t kb)
3978 {
3979   tofu_dbs_t dbs;
3980   PKT_public_key *pk;
3981   char *fingerprint;
3982   char *sqlerr = NULL;
3983   int rc;
3984
3985   /* Make sure PK is a primary key.  */
3986   setup_main_keyids (kb);
3987   pk = kb->pkt->pkt.public_key;
3988   log_assert (pk_is_primary (pk));
3989
3990   dbs = opendbs (ctrl);
3991   if (! dbs)
3992     {
3993       log_error (_("error opening TOFU database: %s\n"),
3994                  gpg_strerror (GPG_ERR_GENERAL));
3995       return gpg_error (GPG_ERR_GENERAL);
3996     }
3997
3998   fingerprint = hexfingerprint (pk, NULL, 0);
3999
4000   rc = gpgsql_stepx (dbs->db, NULL, NULL, NULL, &sqlerr,
4001                      "update bindings set effective_policy = ?"
4002                      " where fingerprint = ?;",
4003                      GPGSQL_ARG_INT, (int) TOFU_POLICY_NONE,
4004                      GPGSQL_ARG_STRING, fingerprint,
4005                      GPGSQL_ARG_END);
4006   xfree (fingerprint);
4007
4008   if (rc == _tofu_GET_POLICY_ERROR)
4009     return gpg_error (GPG_ERR_GENERAL);
4010   return 0;
4011 }