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