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