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