Adjust for changed macro names in libgpg-error master.
[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       /* Fixme: Why the check against N+1?  */
2087       int l = strlen (iter->d);
2088       if (!(l == 2 * 20
2089             || l == 2 * 20 + 1
2090             || l == 2 * 32
2091             || l == 2 * 32 + 1))
2092         {
2093           log_error (_("TOFU db corruption detected.\n"));
2094           print_further_info ("fingerprint '%s' is %d characters long",
2095                               iter->d, l);
2096         }
2097
2098       if (l >= 1 && iter->d[l - 1] == '!')
2099         {
2100           iter->flags |= BINDING_CONFLICT;
2101           /* Remove the !.  */
2102           iter->d[l - 1] = 0;
2103         }
2104     }
2105
2106   /* If the current binding has not yet been recorded, add it to the
2107    * list.  (The order by above ensures that if it is present, it will
2108    * be first.)  */
2109   if (! (conflict_set && strcmp (conflict_set->d, fingerprint) == 0))
2110     {
2111       add_to_strlist (&conflict_set, fingerprint);
2112       conflict_set->flags |= BINDING_NEW;
2113     }
2114
2115   conflict_set_count = strlist_length (conflict_set);
2116
2117   /* Eliminate false conflicts.  */
2118
2119   if (conflict_set_count == 1)
2120     /* We only have a single key.  There are no false conflicts to
2121        eliminate.  But, we do need to set the flags.  */
2122     {
2123       if (pk->has_expired)
2124         conflict_set->flags |= BINDING_EXPIRED;
2125       if (pk->flags.revoked)
2126         conflict_set->flags |= BINDING_REVOKED;
2127
2128       return conflict_set;
2129     }
2130
2131   /* If two keys have cross signatures, then they are controlled by
2132    * the same person and thus are not in conflict.  */
2133   kb_all = xcalloc (sizeof (kb_all[0]), conflict_set_count);
2134   hd = keydb_new ();
2135   for (i = 0, iter = conflict_set;
2136        i < conflict_set_count;
2137        i ++, iter = iter->next)
2138     {
2139       char *fp = iter->d;
2140       KEYDB_SEARCH_DESC desc;
2141       kbnode_t kb;
2142       PKT_public_key *binding_pk;
2143       kbnode_t n;
2144       int found_user_id;
2145
2146       rc = keydb_search_reset (hd);
2147       if (rc)
2148         {
2149           log_error (_("resetting keydb: %s\n"),
2150                      gpg_strerror (rc));
2151           continue;
2152         }
2153
2154       rc = classify_user_id (fp, &desc, 0);
2155       if (rc)
2156         {
2157           log_error (_("error parsing key specification '%s': %s\n"),
2158                      fp, gpg_strerror (rc));
2159           continue;
2160         }
2161
2162       rc = keydb_search (hd, &desc, 1, NULL);
2163       if (rc)
2164         {
2165           /* Note: it is entirely possible that we don't have the key
2166              corresponding to an entry in the TOFU DB.  This can
2167              happen if we merge two TOFU DBs, but not the key
2168              rings.  */
2169           log_info (_("key \"%s\" not found: %s\n"),
2170                     fp, gpg_strerror (rc));
2171           continue;
2172         }
2173
2174       rc = keydb_get_keyblock (hd, &kb);
2175       if (rc)
2176         {
2177           log_error (_("error reading keyblock: %s\n"),
2178                      gpg_strerror (rc));
2179           print_further_info ("fingerprint: %s", fp);
2180           continue;
2181         }
2182
2183       merge_keys_and_selfsig (ctrl, kb);
2184
2185       log_assert (kb->pkt->pkttype == PKT_PUBLIC_KEY);
2186
2187       kb_all[i] = kb;
2188
2189       /* Since we have the key block, use this opportunity to figure
2190        * out if the binding is expired or revoked.  */
2191       binding_pk = kb->pkt->pkt.public_key;
2192
2193       /* The binding is always expired/revoked if the key is
2194        * expired/revoked.  */
2195       if (binding_pk->has_expired)
2196         iter->flags |= BINDING_EXPIRED;
2197       if (binding_pk->flags.revoked)
2198         iter->flags |= BINDING_REVOKED;
2199
2200       /* The binding is also expired/revoked if the user id is
2201        * expired/revoked.  */
2202       n = kb;
2203       found_user_id = 0;
2204       while ((n = find_next_kbnode (n, PKT_USER_ID)) && ! found_user_id)
2205         {
2206           PKT_user_id *user_id2 = n->pkt->pkt.user_id;
2207           char *email2;
2208
2209           if (user_id2->attrib_data)
2210             continue;
2211
2212           email2 = email_from_user_id (user_id2->name);
2213
2214           if (strcmp (email, email2) == 0)
2215             {
2216               found_user_id = 1;
2217
2218               if (user_id2->flags.revoked)
2219                 iter->flags |= BINDING_REVOKED;
2220               if (user_id2->flags.expired)
2221                 iter->flags |= BINDING_EXPIRED;
2222             }
2223
2224           xfree (email2);
2225         }
2226
2227       if (! found_user_id)
2228         {
2229           log_info (_("TOFU db corruption detected.\n"));
2230           print_further_info ("user id '%s' not on key block '%s'",
2231                               email, fingerprint);
2232         }
2233     }
2234   keydb_release (hd);
2235
2236   /* Now that we have the key blocks, check for cross sigs.  */
2237   {
2238     int j;
2239     strlist_t *prevp;
2240     strlist_t iter_next;
2241     int *die;
2242
2243     log_assert (conflict_set_count > 0);
2244     die = xtrycalloc (conflict_set_count, sizeof *die);
2245     if (!die)
2246       {
2247         /*err = gpg_error_from_syserror ();*/
2248         xoutofcore (); /* Fixme: Let the function return an error.  */
2249       }
2250
2251     for (i = 0; i < conflict_set_count; i ++)
2252       {
2253         /* Look for cross sigs between this key (i == 0) or a key
2254          * that has cross sigs with i == 0 (i.e., transitively) */
2255         if (! (i == 0 || die[i]))
2256           continue;
2257
2258         for (j = i + 1; j < conflict_set_count; j ++)
2259           /* Be careful: we might not have a key block for a key.  */
2260           if (kb_all[i] && kb_all[j] && cross_sigs (email, kb_all[i], kb_all[j]))
2261             die[j] = 1;
2262       }
2263
2264     /* Free unconflicting bindings (and all of the key blocks).  */
2265     for (iter = conflict_set, prevp = &conflict_set, i = 0;
2266          iter;
2267          iter = iter_next, i ++)
2268       {
2269         iter_next = iter->next;
2270
2271         release_kbnode (kb_all[i]);
2272
2273         if (die[i])
2274           {
2275             *prevp = iter_next;
2276             iter->next = NULL;
2277             free_strlist (iter);
2278             conflict_set_count --;
2279           }
2280         else
2281           {
2282             prevp = &iter->next;
2283           }
2284       }
2285
2286     /* We shouldn't have removed the head.  */
2287     log_assert (conflict_set);
2288     log_assert (conflict_set_count >= 1);
2289     xfree (die);
2290   }
2291   xfree (kb_all);
2292
2293   if (DBG_TRUST)
2294     {
2295       log_debug ("binding <key: %s, email: %s> conflicts:\n",
2296                  fingerprint, email);
2297       for (iter = conflict_set; iter; iter = iter->next)
2298         {
2299           log_debug ("  %s:%s%s%s%s\n",
2300                      iter->d,
2301                      (iter->flags & BINDING_NEW) ? " new" : "",
2302                      (iter->flags & BINDING_CONFLICT) ? " known_conflict" : "",
2303                      (iter->flags & BINDING_EXPIRED) ? " expired" : "",
2304                      (iter->flags & BINDING_REVOKED) ? " revoked" : "");
2305         }
2306     }
2307
2308   return conflict_set;
2309 }
2310
2311
2312 /* Return the effective policy for the binding <FINGERPRINT, EMAIL>
2313  * (email has already been normalized).  Returns
2314  * _tofu_GET_POLICY_ERROR if an error occurs.  Returns any conflict
2315  * information in *CONFLICT_SETP if CONFLICT_SETP is not NULL and the
2316  * returned policy is TOFU_POLICY_ASK (consequently, if there is a
2317  * conflict, but the user set the policy to good *CONFLICT_SETP will
2318  * empty).  Note: as per build_conflict_set, which is used to build
2319  * the conflict information, the conflict information includes the
2320  * current user id as the first element of the linked list.
2321  *
2322  * This function registers the binding in the bindings table if it has
2323  * not yet been registered.
2324  */
2325 static enum tofu_policy
2326 get_policy (ctrl_t ctrl, tofu_dbs_t dbs, PKT_public_key *pk,
2327             const char *fingerprint, const char *user_id, const char *email,
2328             strlist_t *conflict_setp, time_t now)
2329 {
2330   int rc;
2331   char *err = NULL;
2332   strlist_t results = NULL;
2333   enum tofu_policy policy = _tofu_GET_POLICY_ERROR;
2334   enum tofu_policy effective_policy_orig = TOFU_POLICY_NONE;
2335   enum tofu_policy effective_policy = _tofu_GET_POLICY_ERROR;
2336   long along;
2337   char *conflict_orig = NULL;
2338   char *conflict = NULL;
2339   strlist_t conflict_set = NULL;
2340   int conflict_set_count;
2341
2342   /* Check if the <FINGERPRINT, EMAIL> binding is known
2343      (TOFU_POLICY_NONE cannot appear in the DB.  Thus, if POLICY is
2344      still TOFU_POLICY_NONE after executing the query, then the
2345      result set was empty.)  */
2346   rc = gpgsql_stepx (dbs->db, &dbs->s.get_policy_select_policy_and_conflict,
2347                       strings_collect_cb2, &results, &err,
2348                       "select policy, conflict, effective_policy from bindings\n"
2349                       " where fingerprint = ? and email = ?",
2350                       GPGSQL_ARG_STRING, fingerprint,
2351                       GPGSQL_ARG_STRING, email,
2352                       GPGSQL_ARG_END);
2353   if (rc)
2354     {
2355       log_error (_("error reading TOFU database: %s\n"), err);
2356       print_further_info ("reading the policy");
2357       sqlite3_free (err);
2358       rc = gpg_error (GPG_ERR_GENERAL);
2359       goto out;
2360     }
2361
2362   if (strlist_length (results) == 0)
2363     {
2364       /* No results.  Use the defaults.  */
2365       policy = TOFU_POLICY_NONE;
2366       effective_policy = TOFU_POLICY_NONE;
2367     }
2368   else if (strlist_length (results) == 3)
2369     {
2370       /* Parse and sanity check the results.  */
2371
2372       if (string_to_long (&along, results->d, 0, __LINE__))
2373         {
2374           log_error (_("error reading TOFU database: %s\n"),
2375                      gpg_strerror (GPG_ERR_BAD_DATA));
2376           print_further_info ("bad value for policy: %s", results->d);
2377           goto out;
2378         }
2379       policy = along;
2380
2381       if (! (policy == TOFU_POLICY_AUTO
2382              || policy == TOFU_POLICY_GOOD
2383              || policy == TOFU_POLICY_UNKNOWN
2384              || policy == TOFU_POLICY_BAD
2385              || policy == TOFU_POLICY_ASK))
2386         {
2387           log_error (_("error reading TOFU database: %s\n"),
2388                      gpg_strerror (GPG_ERR_DB_CORRUPTED));
2389           print_further_info ("invalid value for policy (%d)", policy);
2390           effective_policy = _tofu_GET_POLICY_ERROR;
2391           goto out;
2392         }
2393
2394       if (*results->next->d)
2395         conflict = xstrdup (results->next->d);
2396
2397       if (string_to_long (&along, results->next->next->d, 0, __LINE__))
2398         {
2399           log_error (_("error reading TOFU database: %s\n"),
2400                      gpg_strerror (GPG_ERR_BAD_DATA));
2401           print_further_info ("bad value for effective policy: %s",
2402                               results->next->next->d);
2403           goto out;
2404         }
2405       effective_policy = along;
2406
2407       if (! (effective_policy == TOFU_POLICY_NONE
2408              || effective_policy == TOFU_POLICY_AUTO
2409              || effective_policy == TOFU_POLICY_GOOD
2410              || effective_policy == TOFU_POLICY_UNKNOWN
2411              || effective_policy == TOFU_POLICY_BAD
2412              || effective_policy == TOFU_POLICY_ASK))
2413         {
2414           log_error (_("error reading TOFU database: %s\n"),
2415                      gpg_strerror (GPG_ERR_DB_CORRUPTED));
2416           print_further_info ("invalid value for effective_policy (%d)",
2417                               effective_policy);
2418           effective_policy = _tofu_GET_POLICY_ERROR;
2419           goto out;
2420         }
2421     }
2422   else
2423     {
2424       /* The result has the wrong form.  */
2425
2426       log_error (_("error reading TOFU database: %s\n"),
2427                  gpg_strerror (GPG_ERR_BAD_DATA));
2428       print_further_info ("reading policy: expected 3 columns, got %d\n",
2429                           strlist_length (results));
2430       goto out;
2431     }
2432
2433   /* Save the effective policy and conflict so we know if we changed
2434    * them.  */
2435   effective_policy_orig = effective_policy;
2436   conflict_orig = conflict;
2437
2438   /* Unless there is a conflict, if the effective policy is cached,
2439    * just return it.  The reason we don't do this when there is a
2440    * conflict is because of the following scenario: assume A and B
2441    * conflict and B has signed A's key.  Now, later we import A's
2442    * signature on B.  We need to recheck A, but the signature was on
2443    * B, i.e., when B changes, we invalidate B's effective policy, but
2444    * we also need to invalidate A's effective policy.  Instead, we
2445    * assume that conflicts are rare and don't optimize for them, which
2446    * would complicate the code.  */
2447   if (effective_policy != TOFU_POLICY_NONE && !conflict)
2448     goto out;
2449
2450   /* If the user explicitly set the policy, then respect that.  */
2451   if (policy != TOFU_POLICY_AUTO && policy != TOFU_POLICY_NONE)
2452     {
2453       effective_policy = policy;
2454       goto out;
2455     }
2456
2457   /* Unless proven wrong, assume the effective policy is 'auto'.  */
2458   effective_policy = TOFU_POLICY_AUTO;
2459
2460   /* See if the key is ultimately trusted.  */
2461   {
2462     u32 kid[2];
2463
2464     keyid_from_pk (pk, kid);
2465     if (tdb_keyid_is_utk (kid))
2466       {
2467         effective_policy = TOFU_POLICY_GOOD;
2468         goto out;
2469       }
2470   }
2471
2472   /* See if the key is signed by an ultimately trusted key.  */
2473   {
2474     int fingerprint_raw_len = strlen (fingerprint) / 2;
2475     char fingerprint_raw[MAX_FINGERPRINT_LEN];
2476     int len = 0;
2477
2478     /* FIXME(fingerprint) */
2479     if (fingerprint_raw_len != 20 /*sizeof fingerprint_raw */
2480         || ((len = hex2bin (fingerprint,
2481                             fingerprint_raw, fingerprint_raw_len))
2482             != strlen (fingerprint)))
2483       {
2484         if (DBG_TRUST)
2485           log_debug ("TOFU: Bad fingerprint: %s (len: %zu, parsed: %d)\n",
2486                      fingerprint, strlen (fingerprint), len);
2487       }
2488     else
2489       {
2490         int lookup_err;
2491         kbnode_t kb;
2492
2493         lookup_err = get_pubkey_byfprint (ctrl, NULL, &kb,
2494                                           fingerprint_raw,
2495                                           fingerprint_raw_len);
2496         if (lookup_err)
2497           {
2498             if (DBG_TRUST)
2499               log_debug ("TOFU: Looking up %s: %s\n",
2500                          fingerprint, gpg_strerror (lookup_err));
2501           }
2502         else
2503           {
2504             int is_signed_by_utk = signed_by_utk (email, kb);
2505             release_kbnode (kb);
2506             if (is_signed_by_utk)
2507               {
2508                 effective_policy = TOFU_POLICY_GOOD;
2509                 goto out;
2510               }
2511           }
2512       }
2513   }
2514
2515   /* Check for any conflicts / see if a previously discovered conflict
2516    * disappeared.  The latter can happen if the conflicting bindings
2517    * are now cross signed, for instance.  */
2518
2519   conflict_set = build_conflict_set (ctrl, dbs, pk, fingerprint, email);
2520   conflict_set_count = strlist_length (conflict_set);
2521   if (conflict_set_count == 0)
2522     {
2523       /* build_conflict_set should always at least return the current
2524          binding.  Something went wrong.  */
2525       effective_policy = _tofu_GET_POLICY_ERROR;
2526       goto out;
2527     }
2528
2529   if (conflict_set_count == 1
2530       && (conflict_set->flags & BINDING_NEW))
2531     {
2532       /* We've never observed a binding with this email address and we
2533        * have a default policy, which is not to ask the user.  */
2534
2535       /* If we've seen this binding, then we've seen this email and
2536        * policy couldn't possibly be TOFU_POLICY_NONE.  */
2537       log_assert (policy == TOFU_POLICY_NONE);
2538
2539       if (DBG_TRUST)
2540         log_debug ("TOFU: New binding <key: %s, user id: %s>, no conflict.\n",
2541                    fingerprint, email);
2542
2543       effective_policy = TOFU_POLICY_AUTO;
2544       goto out;
2545     }
2546
2547   if (conflict_set_count == 1
2548       && (conflict_set->flags & BINDING_CONFLICT))
2549     {
2550       /* No known conflicts now, but there was a conflict.  This means
2551        * at some point, there was a conflict and we changed this
2552        * binding's policy to ask and set the conflicting key.  The
2553        * conflict can go away if there is not a cross sig between the
2554        * two keys.  In this case, just silently clear the conflict and
2555        * reset the policy to auto.  */
2556
2557       if (DBG_TRUST)
2558         log_debug ("TOFU: binding <key: %s, user id: %s> had a conflict, but it's been resolved (probably via  cross sig).\n",
2559                    fingerprint, email);
2560
2561       effective_policy = TOFU_POLICY_AUTO;
2562       conflict = NULL;
2563
2564       goto out;
2565     }
2566
2567   if (conflict_set_count == 1)
2568     {
2569       /* No conflicts and never marked as conflicting.  */
2570
2571       log_assert (!conflict);
2572
2573       effective_policy = TOFU_POLICY_AUTO;
2574
2575       goto out;
2576     }
2577
2578   /* There is a conflicting key.  */
2579   log_assert (conflict_set_count > 1);
2580   effective_policy = TOFU_POLICY_ASK;
2581   conflict = xstrdup (conflict_set->next->d);
2582
2583  out:
2584   log_assert (policy == _tofu_GET_POLICY_ERROR
2585               || policy == TOFU_POLICY_NONE
2586               || policy == TOFU_POLICY_AUTO
2587               || policy == TOFU_POLICY_GOOD
2588               || policy == TOFU_POLICY_UNKNOWN
2589               || policy == TOFU_POLICY_BAD
2590               || policy == TOFU_POLICY_ASK);
2591   /* Everything but NONE.  */
2592   log_assert (effective_policy == _tofu_GET_POLICY_ERROR
2593               || effective_policy == TOFU_POLICY_AUTO
2594               || effective_policy == TOFU_POLICY_GOOD
2595               || effective_policy == TOFU_POLICY_UNKNOWN
2596               || effective_policy == TOFU_POLICY_BAD
2597               || effective_policy == TOFU_POLICY_ASK);
2598
2599   if (effective_policy != TOFU_POLICY_ASK && conflict)
2600     conflict = NULL;
2601
2602   /* If we don't have a record of this binding, its effective policy
2603    * changed, or conflict changed, update the DB.  */
2604   if (effective_policy != _tofu_GET_POLICY_ERROR
2605       && (/* New binding.  */
2606           policy == TOFU_POLICY_NONE
2607           /* effective_policy changed.  */
2608           || effective_policy != effective_policy_orig
2609           /* conflict changed.  */
2610           || (conflict != conflict_orig
2611               && (!conflict || !conflict_orig
2612                   || strcmp (conflict, conflict_orig) != 0))))
2613     {
2614       if (record_binding (dbs, fingerprint, email, user_id,
2615                           policy == TOFU_POLICY_NONE ? TOFU_POLICY_AUTO : policy,
2616                           effective_policy, conflict, 1, 0, now) != 0)
2617         log_error (_("error setting TOFU binding's policy"
2618                      " to %s\n"), tofu_policy_str (policy));
2619     }
2620
2621   /* If the caller wants the set of conflicts, return it.  */
2622   if (effective_policy == TOFU_POLICY_ASK && conflict_setp)
2623     {
2624       if (! conflict_set)
2625         conflict_set = build_conflict_set (ctrl, dbs, pk, fingerprint, email);
2626       *conflict_setp = conflict_set;
2627     }
2628   else
2629     {
2630       free_strlist (conflict_set);
2631
2632       if (conflict_setp)
2633         *conflict_setp = NULL;
2634     }
2635
2636   xfree (conflict_orig);
2637   if (conflict != conflict_orig)
2638     xfree (conflict);
2639   free_strlist (results);
2640
2641   return effective_policy;
2642 }
2643
2644
2645 /* Return the trust level (TRUST_NEVER, etc.) for the binding
2646  * <FINGERPRINT, EMAIL> (email is already normalized).  If no policy
2647  * is registered, returns TOFU_POLICY_NONE.  If an error occurs,
2648  * returns _tofu_GET_TRUST_ERROR.
2649  *
2650  * PK is the public key object for FINGERPRINT.
2651  *
2652  * USER_ID is the unadulterated user id.
2653  *
2654  * If MAY_ASK is set, then we may interact with the user.  This is
2655  * necessary if there is a conflict or the binding's policy is
2656  * TOFU_POLICY_ASK.  In the case of a conflict, we set the new
2657  * conflicting binding's policy to TOFU_POLICY_ASK.  In either case,
2658  * we return TRUST_UNDEFINED.  Note: if MAY_ASK is set, then this
2659  * function must not be called while in a transaction!  */
2660 static enum tofu_policy
2661 get_trust (ctrl_t ctrl, PKT_public_key *pk,
2662            const char *fingerprint, const char *email,
2663            const char *user_id, int may_ask,
2664            enum tofu_policy *policyp, strlist_t *conflict_setp,
2665            time_t now)
2666 {
2667   tofu_dbs_t dbs = ctrl->tofu.dbs;
2668   int in_transaction = 0;
2669   enum tofu_policy policy;
2670   int rc;
2671   char *sqerr = NULL;
2672   strlist_t conflict_set = NULL;
2673   int trust_level = TRUST_UNKNOWN;
2674   strlist_t iter;
2675
2676   log_assert (dbs);
2677
2678   if (may_ask)
2679     log_assert (dbs->in_transaction == 0);
2680
2681   if (opt.batch)
2682     may_ask = 0;
2683
2684   log_assert (pk_is_primary (pk));
2685
2686   /* Make sure _tofu_GET_TRUST_ERROR isn't equal to any of the trust
2687      levels.  */
2688   log_assert (_tofu_GET_TRUST_ERROR != TRUST_UNKNOWN
2689               && _tofu_GET_TRUST_ERROR != TRUST_EXPIRED
2690               && _tofu_GET_TRUST_ERROR != TRUST_UNDEFINED
2691               && _tofu_GET_TRUST_ERROR != TRUST_NEVER
2692               && _tofu_GET_TRUST_ERROR != TRUST_MARGINAL
2693               && _tofu_GET_TRUST_ERROR != TRUST_FULLY
2694               && _tofu_GET_TRUST_ERROR != TRUST_ULTIMATE);
2695
2696   begin_transaction (ctrl, 0);
2697   in_transaction = 1;
2698
2699   /* We need to call get_policy even if the key is ultimately trusted
2700    * to make sure the binding has been registered.  */
2701   policy = get_policy (ctrl, dbs, pk, fingerprint, user_id, email,
2702                        &conflict_set, now);
2703
2704   if (policy == TOFU_POLICY_ASK)
2705     /* The conflict set should always contain at least one element:
2706      * the current key.  */
2707     log_assert (conflict_set);
2708   else
2709     /* If the policy is not TOFU_POLICY_ASK, then conflict_set will be
2710      * NULL.  */
2711     log_assert (! conflict_set);
2712
2713   /* If the key is ultimately trusted, there is nothing to do.  */
2714   {
2715     u32 kid[2];
2716
2717     keyid_from_pk (pk, kid);
2718     if (tdb_keyid_is_utk (kid))
2719       {
2720         trust_level = TRUST_ULTIMATE;
2721         policy = TOFU_POLICY_GOOD;
2722         goto out;
2723       }
2724   }
2725
2726   if (policy == TOFU_POLICY_AUTO)
2727     {
2728       policy = opt.tofu_default_policy;
2729       if (DBG_TRUST)
2730         log_debug ("TOFU: binding <key: %s, user id: %s>'s policy is"
2731                    " auto (default: %s).\n",
2732                    fingerprint, email,
2733                    tofu_policy_str (opt.tofu_default_policy));
2734
2735       if (policy == TOFU_POLICY_ASK)
2736         /* The default policy is ASK, but there is no conflict (policy
2737          * was 'auto').  In this case, we need to make sure the
2738          * conflict set includes at least the current user id.  */
2739         {
2740           add_to_strlist (&conflict_set, fingerprint);
2741         }
2742     }
2743   switch (policy)
2744     {
2745     case TOFU_POLICY_AUTO:
2746     case TOFU_POLICY_GOOD:
2747     case TOFU_POLICY_UNKNOWN:
2748     case TOFU_POLICY_BAD:
2749       /* The saved judgement is auto -> auto, good, unknown or bad.
2750        * We don't need to ask the user anything.  */
2751       if (DBG_TRUST)
2752         log_debug ("TOFU: Known binding <key: %s, user id: %s>'s policy: %s\n",
2753                    fingerprint, email, tofu_policy_str (policy));
2754       trust_level = tofu_policy_to_trust_level (policy);
2755       goto out;
2756
2757     case TOFU_POLICY_ASK:
2758       /* We need to ask the user what to do.  */
2759       break;
2760
2761     case _tofu_GET_POLICY_ERROR:
2762       trust_level = _tofu_GET_TRUST_ERROR;
2763       goto out;
2764
2765     default:
2766       log_bug ("%s: Impossible value for policy (%d)\n", __func__, policy);
2767     }
2768
2769
2770   /* We get here if:
2771    *
2772    *   1. The saved policy is auto and the default policy is ask
2773    *      (get_policy() == TOFU_POLICY_AUTO
2774    *       && opt.tofu_default_policy == TOFU_POLICY_ASK)
2775    *
2776    *   2. The saved policy is ask (either last time the user selected
2777    *      accept once or reject once or there was a conflict and this
2778    *      binding's policy was changed from auto to ask)
2779    *      (policy == TOFU_POLICY_ASK).
2780    */
2781   log_assert (policy == TOFU_POLICY_ASK);
2782
2783   if (may_ask)
2784     {
2785       /* We can't be in a normal transaction in ask_about_binding.  */
2786       end_transaction (ctrl, 0);
2787       in_transaction = 0;
2788
2789       /* If we get here, we need to ask the user about the binding.  */
2790       ask_about_binding (ctrl,
2791                          &policy,
2792                          &trust_level,
2793                          conflict_set,
2794                          fingerprint,
2795                          email,
2796                          user_id,
2797                          now);
2798     }
2799   else
2800     {
2801       trust_level = TRUST_UNDEFINED;
2802     }
2803
2804   /* Mark any conflicting bindings that have an automatic policy as
2805    * now requiring confirmation.  Note: we do this after we ask for
2806    * confirmation so that when the current policy is printed, it is
2807    * correct.  */
2808   if (! in_transaction)
2809     {
2810       begin_transaction (ctrl, 0);
2811       in_transaction = 1;
2812     }
2813
2814   /* The conflict set should always contain at least one element:
2815    * the current key.  */
2816   log_assert (conflict_set);
2817
2818   for (iter = conflict_set->next; iter; iter = iter->next)
2819     {
2820       /* We don't immediately set the effective policy to 'ask,
2821          because  */
2822       rc = gpgsql_exec_printf
2823         (dbs->db, NULL, NULL, &sqerr,
2824          "update bindings set effective_policy = %d, conflict = %Q"
2825          " where email = %Q and fingerprint = %Q and effective_policy != %d;",
2826          TOFU_POLICY_NONE, fingerprint,
2827          email, iter->d, TOFU_POLICY_ASK);
2828       if (rc)
2829         {
2830           log_error (_("error changing TOFU policy: %s\n"), sqerr);
2831           print_further_info ("binding: <key: %s, user id: %s>",
2832                               fingerprint, user_id);
2833           sqlite3_free (sqerr);
2834           sqerr = NULL;
2835           rc = gpg_error (GPG_ERR_GENERAL);
2836         }
2837       else if (DBG_TRUST)
2838         log_debug ("Set %s to conflict with %s\n",
2839                    iter->d, fingerprint);
2840     }
2841
2842  out:
2843   if (in_transaction)
2844     end_transaction (ctrl, 0);
2845
2846   if (policyp)
2847     *policyp = policy;
2848
2849   if (conflict_setp)
2850     *conflict_setp = conflict_set;
2851   else
2852     free_strlist (conflict_set);
2853
2854   return trust_level;
2855 }
2856
2857
2858 /* Return a malloced string of the form
2859  *    "7~months"
2860  * The caller should replace all '~' in the returned string by a space
2861  * and also free the returned string.
2862  *
2863  * This is actually a bad hack which may not work correctly with all
2864  * languages.
2865  */
2866 static char *
2867 time_ago_str (long long int t)
2868 {
2869   /* It would be nice to use a macro to do this, but gettext
2870      works on the unpreprocessed code.  */
2871 #define MIN_SECS (60)
2872 #define HOUR_SECS (60 * MIN_SECS)
2873 #define DAY_SECS (24 * HOUR_SECS)
2874 #define WEEK_SECS (7 * DAY_SECS)
2875 #define MONTH_SECS (30 * DAY_SECS)
2876 #define YEAR_SECS (365 * DAY_SECS)
2877
2878   if (t > 2 * YEAR_SECS)
2879     {
2880       long long int c = t / YEAR_SECS;
2881       return xtryasprintf (ngettext("%lld~year", "%lld~years", c), c);
2882     }
2883   if (t > 2 * MONTH_SECS)
2884     {
2885       long long int c = t / MONTH_SECS;
2886       return xtryasprintf (ngettext("%lld~month", "%lld~months", c), c);
2887     }
2888   if (t > 2 * WEEK_SECS)
2889     {
2890       long long int c = t / WEEK_SECS;
2891       return xtryasprintf (ngettext("%lld~week", "%lld~weeks", c), c);
2892     }
2893   if (t > 2 * DAY_SECS)
2894     {
2895       long long int c = t / DAY_SECS;
2896       return xtryasprintf (ngettext("%lld~day", "%lld~days", c), c);
2897     }
2898   if (t > 2 * HOUR_SECS)
2899     {
2900       long long int c = t / HOUR_SECS;
2901       return xtryasprintf (ngettext("%lld~hour", "%lld~hours", c), c);
2902     }
2903   if (t > 2 * MIN_SECS)
2904     {
2905       long long int c = t / MIN_SECS;
2906       return xtryasprintf (ngettext("%lld~minute", "%lld~minutes", c), c);
2907     }
2908   return xtryasprintf (ngettext("%lld~second", "%lld~seconds", t), t);
2909 }
2910
2911
2912 /* If FP is NULL, write TOFU_STATS status line.  If FP is not NULL
2913  * write a "tfs" record to that stream. */
2914 static void
2915 write_stats_status (estream_t fp,
2916                     enum tofu_policy policy,
2917                     unsigned long signature_count,
2918                     unsigned long signature_first_seen,
2919                     unsigned long signature_most_recent,
2920                     unsigned long signature_days,
2921                     unsigned long encryption_count,
2922                     unsigned long encryption_first_done,
2923                     unsigned long encryption_most_recent,
2924                     unsigned long encryption_days)
2925 {
2926   int summary;
2927   int validity;
2928   unsigned long days_sq;
2929
2930   /* Use the euclidean distance (m = sqrt(a^2 + b^2)) rather then the
2931      sum of the magnitudes (m = a + b) to ensure a balance between
2932      verified signatures and encrypted messages.  */
2933   days_sq = signature_days * signature_days + encryption_days * encryption_days;
2934
2935   if (days_sq < 1)
2936     validity = 1; /* Key without history.  */
2937   else if (days_sq < (2 * BASIC_TRUST_THRESHOLD) * (2 * BASIC_TRUST_THRESHOLD))
2938     validity = 2; /* Key with too little history.  */
2939   else if (days_sq < (2 * FULL_TRUST_THRESHOLD) * (2 * FULL_TRUST_THRESHOLD))
2940     validity = 3; /* Key with enough history for basic trust.  */
2941   else
2942     validity = 4; /* Key with a lot of history.  */
2943
2944   if (policy == TOFU_POLICY_ASK)
2945     summary = 0; /* Key requires attention.  */
2946   else
2947     summary = validity;
2948
2949   if (fp)
2950     {
2951       es_fprintf (fp, "tfs:1:%d:%lu:%lu:%s:%lu:%lu:%lu:%lu:%d:%lu:%lu:\n",
2952                   summary, signature_count, encryption_count,
2953                   tofu_policy_str (policy),
2954                   signature_first_seen, signature_most_recent,
2955                   encryption_first_done, encryption_most_recent,
2956                   validity, signature_days, encryption_days);
2957     }
2958   else
2959     {
2960       write_status_printf (STATUS_TOFU_STATS,
2961                            "%d %lu %lu %s %lu %lu %lu %lu %d %lu %lu",
2962                            summary,
2963                            signature_count,
2964                            encryption_count,
2965                            tofu_policy_str (policy),
2966                            signature_first_seen,
2967                            signature_most_recent,
2968                            encryption_first_done,
2969                            encryption_most_recent,
2970                            validity,
2971                            signature_days, encryption_days);
2972     }
2973 }
2974
2975 /* Note: If OUTFP is not NULL, this function merely prints a "tfs" record
2976  * to OUTFP.
2977  *
2978  * POLICY is the key's policy (as returned by get_policy).
2979  *
2980  * Returns 0 if ONLY_STATUS_FD is set.  Otherwise, returns whether
2981  * the caller should call show_warning after iterating over all user
2982  * ids.
2983  */
2984 static int
2985 show_statistics (tofu_dbs_t dbs,
2986                  const char *fingerprint, const char *email,
2987                  enum tofu_policy policy,
2988                  estream_t outfp, int only_status_fd, time_t now)
2989 {
2990   char *fingerprint_pp;
2991   int rc;
2992   strlist_t strlist = NULL;
2993   char *err = NULL;
2994
2995   unsigned long signature_first_seen = 0;
2996   unsigned long signature_most_recent = 0;
2997   unsigned long signature_count = 0;
2998   unsigned long signature_days = 0;
2999   unsigned long encryption_first_done = 0;
3000   unsigned long encryption_most_recent = 0;
3001   unsigned long encryption_count = 0;
3002   unsigned long encryption_days = 0;
3003
3004   int show_warning = 0;
3005
3006   if (only_status_fd && ! is_status_enabled ())
3007     return 0;
3008
3009   fingerprint_pp = format_hexfingerprint (fingerprint, NULL, 0);
3010
3011   /* Get the signature stats.  */
3012   rc = gpgsql_exec_printf
3013     (dbs->db, strings_collect_cb, &strlist, &err,
3014      "select count (*), coalesce (min (signatures.time), 0),\n"
3015      "  coalesce (max (signatures.time), 0)\n"
3016      " from signatures\n"
3017      " left join bindings on signatures.binding = bindings.oid\n"
3018      " where fingerprint = %Q and email = %Q;",
3019      fingerprint, email);
3020   if (rc)
3021     {
3022       log_error (_("error reading TOFU database: %s\n"), err);
3023       print_further_info ("getting signature statistics");
3024       sqlite3_free (err);
3025       rc = gpg_error (GPG_ERR_GENERAL);
3026       goto out;
3027     }
3028   rc = gpgsql_exec_printf
3029     (dbs->db, strings_collect_cb, &strlist, &err,
3030      "select count (*) from\n"
3031      "  (select round(signatures.time / (24 * 60 * 60)) day\n"
3032      "    from signatures\n"
3033      "    left join bindings on signatures.binding = bindings.oid\n"
3034      "    where fingerprint = %Q and email = %Q\n"
3035      "    group by day);",
3036      fingerprint, email);
3037   if (rc)
3038     {
3039       log_error (_("error reading TOFU database: %s\n"), err);
3040       print_further_info ("getting signature statistics (by day)");
3041       sqlite3_free (err);
3042       rc = gpg_error (GPG_ERR_GENERAL);
3043       goto out;
3044     }
3045
3046   if (strlist)
3047     {
3048       /* We expect exactly 4 elements.  */
3049       log_assert (strlist->next);
3050       log_assert (strlist->next->next);
3051       log_assert (strlist->next->next->next);
3052       log_assert (! strlist->next->next->next->next);
3053
3054       string_to_ulong (&signature_days, strlist->d, -1, __LINE__);
3055       string_to_ulong (&signature_count, strlist->next->d, -1, __LINE__);
3056       string_to_ulong (&signature_first_seen,
3057                        strlist->next->next->d, -1, __LINE__);
3058       string_to_ulong (&signature_most_recent,
3059                        strlist->next->next->next->d, -1, __LINE__);
3060
3061       free_strlist (strlist);
3062       strlist = NULL;
3063     }
3064
3065   /* Get the encryption stats.  */
3066   rc = gpgsql_exec_printf
3067     (dbs->db, strings_collect_cb, &strlist, &err,
3068      "select count (*), coalesce (min (encryptions.time), 0),\n"
3069      "  coalesce (max (encryptions.time), 0)\n"
3070      " from encryptions\n"
3071      " left join bindings on encryptions.binding = bindings.oid\n"
3072      " where fingerprint = %Q and email = %Q;",
3073      fingerprint, email);
3074   if (rc)
3075     {
3076       log_error (_("error reading TOFU database: %s\n"), err);
3077       print_further_info ("getting encryption statistics");
3078       sqlite3_free (err);
3079       rc = gpg_error (GPG_ERR_GENERAL);
3080       goto out;
3081     }
3082   rc = gpgsql_exec_printf
3083     (dbs->db, strings_collect_cb, &strlist, &err,
3084      "select count (*) from\n"
3085      "  (select round(encryptions.time / (24 * 60 * 60)) day\n"
3086      "    from encryptions\n"
3087      "    left join bindings on encryptions.binding = bindings.oid\n"
3088      "    where fingerprint = %Q and email = %Q\n"
3089      "    group by day);",
3090      fingerprint, email);
3091   if (rc)
3092     {
3093       log_error (_("error reading TOFU database: %s\n"), err);
3094       print_further_info ("getting encryption statistics (by day)");
3095       sqlite3_free (err);
3096       rc = gpg_error (GPG_ERR_GENERAL);
3097       goto out;
3098     }
3099
3100   if (strlist)
3101     {
3102       /* We expect exactly 4 elements.  */
3103       log_assert (strlist->next);
3104       log_assert (strlist->next->next);
3105       log_assert (strlist->next->next->next);
3106       log_assert (! strlist->next->next->next->next);
3107
3108       string_to_ulong (&encryption_days, strlist->d, -1, __LINE__);
3109       string_to_ulong (&encryption_count, strlist->next->d, -1, __LINE__);
3110       string_to_ulong (&encryption_first_done,
3111                        strlist->next->next->d, -1, __LINE__);
3112       string_to_ulong (&encryption_most_recent,
3113                        strlist->next->next->next->d, -1, __LINE__);
3114
3115       free_strlist (strlist);
3116       strlist = NULL;
3117     }
3118
3119   if (!outfp)
3120     write_status_text_and_buffer (STATUS_TOFU_USER, fingerprint,
3121                                   email, strlen (email), 0);
3122
3123   write_stats_status (outfp, policy,
3124                       signature_count,
3125                       signature_first_seen,
3126                       signature_most_recent,
3127                       signature_days,
3128                       encryption_count,
3129                       encryption_first_done,
3130                       encryption_most_recent,
3131                       encryption_days);
3132
3133   if (!outfp && !only_status_fd)
3134     {
3135       estream_t fp;
3136       char *msg;
3137
3138       fp = es_fopenmem (0, "rw,samethread");
3139       if (! fp)
3140         log_fatal ("error creating memory stream: %s\n",
3141                    gpg_strerror (gpg_error_from_syserror()));
3142
3143       if (signature_count == 0 && encryption_count == 0)
3144         {
3145           es_fprintf (fp,
3146                       _("%s: Verified 0~signatures and encrypted 0~messages."),
3147                       email);
3148         }
3149       else
3150         {
3151           if (signature_count == 0)
3152             es_fprintf (fp, _("%s: Verified 0 signatures."), email);
3153           else
3154             {
3155               /* TRANSLATORS: The final %s is replaced by a string like
3156                  "7~months". */
3157               char *ago_str = time_ago_str (now - signature_first_seen);
3158               es_fprintf
3159                 (fp,
3160                  ngettext("%s: Verified %ld~signature in the past %s.",
3161                           "%s: Verified %ld~signatures in the past %s.",
3162                           signature_count),
3163                  email, signature_count, ago_str);
3164               xfree (ago_str);
3165             }
3166
3167           es_fputs ("  ", fp);
3168
3169           if (encryption_count == 0)
3170             es_fprintf (fp, _("Encrypted 0 messages."));
3171           else
3172             {
3173               char *ago_str = time_ago_str (now - encryption_first_done);
3174
3175               /* TRANSLATORS: The final %s is replaced by a string like
3176                  "7~months". */
3177               es_fprintf (fp,
3178                           ngettext("Encrypted %ld~message in the past %s.",
3179                                    "Encrypted %ld~messages in the past %s.",
3180                                    encryption_count),
3181                           encryption_count, ago_str);
3182               xfree (ago_str);
3183             }
3184         }
3185
3186       if (opt.verbose)
3187         {
3188           es_fputs ("  ", fp);
3189           es_fprintf (fp, _("(policy: %s)"), tofu_policy_str (policy));
3190         }
3191       es_fputs ("\n", fp);
3192
3193
3194       {
3195         char *tmpmsg, *p;
3196         es_fputc (0, fp);
3197         if (es_fclose_snatch (fp, (void **) &tmpmsg, NULL))
3198           log_fatal ("error snatching memory stream\n");
3199         msg = format_text (tmpmsg, 72, 80);
3200         if (!msg) /* FIXME: Return the error all the way up.  */
3201           log_fatal ("format failed: %s\n",
3202                      gpg_strerror (gpg_error_from_syserror()));
3203         es_free (tmpmsg);
3204
3205         /* Print a status line but suppress the trailing LF.
3206          * Spaces are not percent escaped. */
3207         if (*msg)
3208           write_status_buffer (STATUS_TOFU_STATS_LONG,
3209                                msg, strlen (msg)-1, -1);
3210
3211         /* Remove the non-breaking space markers.  */
3212         for (p=msg; *p; p++)
3213           if (*p == '~')
3214             *p = ' ';
3215       }
3216
3217       log_string (GPGRT_LOGLVL_INFO, msg);
3218       xfree (msg);
3219
3220       if (policy == TOFU_POLICY_AUTO)
3221         {
3222           if (signature_count == 0)
3223             log_info (_("Warning: we have yet to see"
3224                         " a message signed using this key and user id!\n"));
3225           else if (signature_count == 1)
3226             log_info (_("Warning: we've only seen one message"
3227                         " signed using this key and user id!\n"));
3228
3229           if (encryption_count == 0)
3230             log_info (_("Warning: you have yet to encrypt"
3231                         " a message to this key!\n"));
3232           else if (encryption_count == 1)
3233             log_info (_("Warning: you have only encrypted"
3234                         " one message to this key!\n"));
3235
3236           /* Cf. write_stats_status  */
3237           if ((encryption_count * encryption_count
3238                + signature_count * signature_count)
3239               < ((2 * BASIC_TRUST_THRESHOLD) * (2 * BASIC_TRUST_THRESHOLD)))
3240             show_warning = 1;
3241         }
3242     }
3243
3244  out:
3245   xfree (fingerprint_pp);
3246
3247   return show_warning;
3248 }
3249
3250 static void
3251 show_warning (const char *fingerprint, strlist_t user_id_list)
3252 {
3253   char *set_policy_command;
3254   char *text;
3255   char *tmpmsg;
3256
3257   set_policy_command =
3258     xasprintf ("gpg --tofu-policy bad %s", fingerprint);
3259
3260   tmpmsg = xasprintf
3261     (ngettext
3262      ("Warning: if you think you've seen more signatures "
3263       "by this key and user id, then this key might be a "
3264       "forgery!  Carefully examine the email address for small "
3265       "variations.  If the key is suspect, then use\n"
3266       "  %s\n"
3267       "to mark it as being bad.\n",
3268       "Warning: if you think you've seen more signatures "
3269       "by this key and these user ids, then this key might be a "
3270       "forgery!  Carefully examine the email addresses for small "
3271       "variations.  If the key is suspect, then use\n"
3272       "  %s\n"
3273       "to mark it as being bad.\n",
3274       strlist_length (user_id_list)),
3275      set_policy_command);
3276
3277   text = format_text (tmpmsg, 72, 80);
3278   if (!text) /* FIXME: Return the error all the way up.  */
3279     log_fatal ("format failed: %s\n",
3280                gpg_strerror (gpg_error_from_syserror()));
3281   xfree (tmpmsg);
3282   log_string (GPGRT_LOGLVL_INFO, text);
3283   xfree (text);
3284
3285   es_free (set_policy_command);
3286 }
3287
3288
3289 /* Extract the email address from a user id and normalize it.  If the
3290    user id doesn't contain an email address, then we use the whole
3291    user_id and normalize that.  The returned string must be freed.  */
3292 static char *
3293 email_from_user_id (const char *user_id)
3294 {
3295   char *email = mailbox_from_userid (user_id);
3296   if (! email)
3297     {
3298       /* Hmm, no email address was provided or we are out of core.  Just
3299          take the lower-case version of the whole user id.  It could be
3300          a hostname, for instance.  */
3301       email = ascii_strlwr (xstrdup (user_id));
3302     }
3303
3304   return email;
3305 }
3306
3307 /* Register the signature with the bindings <fingerprint, USER_ID>,
3308    for each USER_ID in USER_ID_LIST.  The fingerprint is taken from
3309    the primary key packet PK.
3310
3311    SIG_DIGEST_BIN is the binary representation of the message's
3312    digest.  SIG_DIGEST_BIN_LEN is its length.
3313
3314    SIG_TIME is the time that the signature was generated.
3315
3316    ORIGIN is a free-formed string describing the origin of the
3317    signature.  If this was from an email and the Claws MUA was used,
3318    then this should be something like: "email:claws".  If this is
3319    NULL, the default is simply "unknown".
3320
3321    If MAY_ASK is 1, then this function may interact with the user.
3322    This is necessary if there is a conflict or the binding's policy is
3323    TOFU_POLICY_ASK.
3324
3325    This function returns 0 on success and an error code if an error
3326    occurred.  */
3327 gpg_error_t
3328 tofu_register_signature (ctrl_t ctrl,
3329                          PKT_public_key *pk, strlist_t user_id_list,
3330                          const byte *sig_digest_bin, int sig_digest_bin_len,
3331                          time_t sig_time, const char *origin)
3332 {
3333   time_t now = gnupg_get_time ();
3334   gpg_error_t rc;
3335   tofu_dbs_t dbs;
3336   char *fingerprint = NULL;
3337   strlist_t user_id;
3338   char *email = NULL;
3339   char *err = NULL;
3340   char *sig_digest;
3341   unsigned long c;
3342
3343   dbs = opendbs (ctrl);
3344   if (! dbs)
3345     {
3346       rc = gpg_error (GPG_ERR_GENERAL);
3347       log_error (_("error opening TOFU database: %s\n"),
3348                  gpg_strerror (rc));
3349       return rc;
3350     }
3351
3352   /* We do a query and then an insert.  Make sure they are atomic
3353      by wrapping them in a transaction.  */
3354   rc = begin_transaction (ctrl, 0);
3355   if (rc)
3356     return rc;
3357
3358   log_assert (pk_is_primary (pk));
3359
3360   sig_digest = make_radix64_string (sig_digest_bin, sig_digest_bin_len);
3361   fingerprint = hexfingerprint (pk, NULL, 0);
3362
3363   if (! origin)
3364     /* The default origin is simply "unknown".  */
3365     origin = "unknown";
3366
3367   for (user_id = user_id_list; user_id; user_id = user_id->next)
3368     {
3369       email = email_from_user_id (user_id->d);
3370
3371       if (DBG_TRUST)
3372         log_debug ("TOFU: Registering signature %s with binding"
3373                    " <key: %s, user id: %s>\n",
3374                    sig_digest, fingerprint, email);
3375
3376       /* Make sure the binding exists and record any TOFU
3377          conflicts.  */
3378       if (get_trust (ctrl, pk, fingerprint, email, user_id->d,
3379                      0, NULL, NULL, now)
3380           == _tofu_GET_TRUST_ERROR)
3381         {
3382           rc = gpg_error (GPG_ERR_GENERAL);
3383           xfree (email);
3384           break;
3385         }
3386
3387       /* If we've already seen this signature before, then don't add
3388          it again.  */
3389       rc = gpgsql_stepx
3390         (dbs->db, &dbs->s.register_already_seen,
3391          get_single_unsigned_long_cb2, &c, &err,
3392          "select count (*)\n"
3393          " from signatures left join bindings\n"
3394          "  on signatures.binding = bindings.oid\n"
3395          " where fingerprint = ? and email = ? and sig_time = ?\n"
3396          "  and sig_digest = ?",
3397          GPGSQL_ARG_STRING, fingerprint, GPGSQL_ARG_STRING, email,
3398          GPGSQL_ARG_LONG_LONG, (long long) sig_time,
3399          GPGSQL_ARG_STRING, sig_digest,
3400          GPGSQL_ARG_END);
3401       if (rc)
3402         {
3403           log_error (_("error reading TOFU database: %s\n"), err);
3404           print_further_info ("checking existence");
3405           sqlite3_free (err);
3406           rc = gpg_error (GPG_ERR_GENERAL);
3407         }
3408       else if (c > 1)
3409         /* Duplicates!  This should not happen.  In particular,
3410            because <fingerprint, email, sig_time, sig_digest> is the
3411            primary key!  */
3412         log_debug ("SIGNATURES DB contains duplicate records"
3413                    " <key: %s, email: %s, time: 0x%lx, sig: %s,"
3414                    " origin: %s>."
3415                    "  Please report.\n",
3416                    fingerprint, email, (unsigned long) sig_time,
3417                    sig_digest, origin);
3418       else if (c == 1)
3419         {
3420           if (DBG_TRUST)
3421             log_debug ("Already observed the signature and binding"
3422                        " <key: %s, email: %s, time: 0x%lx, sig: %s,"
3423                        " origin: %s>\n",
3424                        fingerprint, email, (unsigned long) sig_time,
3425                        sig_digest, origin);
3426         }
3427       else if (opt.dry_run)
3428         {
3429           log_info ("TOFU database update skipped due to --dry-run\n");
3430         }
3431       else
3432         /* This is the first time that we've seen this signature and
3433            binding.  Record it.  */
3434         {
3435           if (DBG_TRUST)
3436             log_debug ("TOFU: Saving signature"
3437                        " <key: %s, user id: %s, sig: %s>\n",
3438                        fingerprint, email, sig_digest);
3439
3440           log_assert (c == 0);
3441
3442           rc = gpgsql_stepx
3443             (dbs->db, &dbs->s.register_signature, NULL, NULL, &err,
3444              "insert into signatures\n"
3445              " (binding, sig_digest, origin, sig_time, time)\n"
3446              " values\n"
3447              " ((select oid from bindings\n"
3448              "    where fingerprint = ? and email = ?),\n"
3449              "  ?, ?, ?, ?);",
3450              GPGSQL_ARG_STRING, fingerprint, GPGSQL_ARG_STRING, email,
3451              GPGSQL_ARG_STRING, sig_digest, GPGSQL_ARG_STRING, origin,
3452              GPGSQL_ARG_LONG_LONG, (long long) sig_time,
3453              GPGSQL_ARG_LONG_LONG, (long long) now,
3454              GPGSQL_ARG_END);
3455           if (rc)
3456             {
3457               log_error (_("error updating TOFU database: %s\n"), err);
3458               print_further_info ("insert signatures");
3459               sqlite3_free (err);
3460               rc = gpg_error (GPG_ERR_GENERAL);
3461             }
3462         }
3463
3464       xfree (email);
3465
3466       if (rc)
3467         break;
3468     }
3469
3470   if (rc)
3471     rollback_transaction (ctrl);
3472   else
3473     rc = end_transaction (ctrl, 0);
3474
3475   xfree (fingerprint);
3476   xfree (sig_digest);
3477
3478   return rc;
3479 }
3480
3481 gpg_error_t
3482 tofu_register_encryption (ctrl_t ctrl,
3483                           PKT_public_key *pk, strlist_t user_id_list,
3484                           int may_ask)
3485 {
3486   time_t now = gnupg_get_time ();
3487   gpg_error_t rc = 0;
3488   tofu_dbs_t dbs;
3489   kbnode_t kb = NULL;
3490   int free_user_id_list = 0;
3491   char *fingerprint = NULL;
3492   strlist_t user_id;
3493   char *err = NULL;
3494
3495   dbs = opendbs (ctrl);
3496   if (! dbs)
3497     {
3498       rc = gpg_error (GPG_ERR_GENERAL);
3499       log_error (_("error opening TOFU database: %s\n"),
3500                  gpg_strerror (rc));
3501       return rc;
3502     }
3503
3504   if (/* We need the key block to find the primary key.  */
3505       ! pk_is_primary (pk)
3506       /* We need the key block to find all user ids.  */
3507       || ! user_id_list)
3508     kb = get_pubkeyblock (ctrl, pk->keyid);
3509
3510   /* Make sure PK is a primary key.  */
3511   if (! pk_is_primary (pk))
3512     pk = kb->pkt->pkt.public_key;
3513
3514   if (! user_id_list)
3515     {
3516       /* Use all non-revoked user ids.  Do use expired user ids.  */
3517       kbnode_t n = kb;
3518
3519       while ((n = find_next_kbnode (n, PKT_USER_ID)))
3520         {
3521           PKT_user_id *uid = n->pkt->pkt.user_id;
3522
3523           if (uid->flags.revoked)
3524             continue;
3525
3526           add_to_strlist (&user_id_list, uid->name);
3527         }
3528
3529       free_user_id_list = 1;
3530
3531       if (! user_id_list)
3532         log_info (_("WARNING: Encrypting to %s, which has no "
3533                     "non-revoked user ids\n"),
3534                   keystr (pk->keyid));
3535     }
3536
3537   fingerprint = hexfingerprint (pk, NULL, 0);
3538
3539   tofu_begin_batch_update (ctrl);
3540   tofu_resume_batch_transaction (ctrl);
3541
3542   for (user_id = user_id_list; user_id; user_id = user_id->next)
3543     {
3544       char *email = email_from_user_id (user_id->d);
3545       strlist_t conflict_set = NULL;
3546       enum tofu_policy policy;
3547
3548       /* Make sure the binding exists and that we recognize any
3549          conflicts.  */
3550       int tl = get_trust (ctrl, pk, fingerprint, email, user_id->d,
3551                           may_ask, &policy, &conflict_set, now);
3552       if (tl == _tofu_GET_TRUST_ERROR)
3553         {
3554           /* An error.  */
3555           rc = gpg_error (GPG_ERR_GENERAL);
3556           xfree (email);
3557           goto die;
3558         }
3559
3560
3561       /* If there is a conflict and MAY_ASK is true, we need to show
3562        * the TOFU statistics for the current binding and the
3563        * conflicting bindings.  But, if we are not in batch mode, then
3564        * they have already been printed (this is required to make sure
3565        * the information is available to the caller before cpr_get is
3566        * called).  */