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