g10: Be more careful when checking cross signatures.
[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 INTEGER 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,
801                 const char *conflict,
802                 int show_old, time_t now)
803 {
804   char *fingerprint_pp = format_hexfingerprint (fingerprint, NULL, 0);
805   gpg_error_t rc;
806   char *err = NULL;
807
808   if (! (policy == TOFU_POLICY_AUTO
809          || policy == TOFU_POLICY_GOOD
810          || policy == TOFU_POLICY_UNKNOWN
811          || policy == TOFU_POLICY_BAD
812          || policy == TOFU_POLICY_ASK))
813     log_bug ("%s: Bad value for policy (%d)!\n", __func__, policy);
814
815
816   if (DBG_TRUST || show_old)
817     {
818       /* Get the old policy.  Since this is just for informational
819        * purposes, there is no need to start a transaction or to die
820        * if there is a failure.  */
821
822       /* policy_old needs to be a long and not an enum tofu_policy,
823          because we pass it by reference to get_single_long_cb2, which
824          expects a long.  */
825       long policy_old = TOFU_POLICY_NONE;
826
827       rc = gpgsql_stepx
828         (dbs->db, &dbs->s.record_binding_get_old_policy,
829          get_single_long_cb2, &policy_old, &err,
830          "select policy from bindings where fingerprint = ? and email = ?",
831          GPGSQL_ARG_STRING, fingerprint, GPGSQL_ARG_STRING, email,
832          GPGSQL_ARG_END);
833       if (rc)
834         {
835           log_debug ("TOFU: Error reading from binding database"
836                      " (reading policy for <key: %s, user id: %s>): %s\n",
837                      fingerprint, email, err);
838           sqlite3_free (err);
839         }
840
841       if (policy_old != TOFU_POLICY_NONE)
842         (show_old ? log_info : log_debug)
843           ("Changing TOFU trust policy for binding"
844            " <key: %s, user id: %s> from %s to %s.\n",
845            fingerprint, show_old ? user_id : email,
846            tofu_policy_str (policy_old),
847            tofu_policy_str (policy));
848       else
849         (show_old ? log_info : log_debug)
850           ("Setting TOFU trust policy for new binding"
851            " <key: %s, user id: %s> to %s.\n",
852            fingerprint, show_old ? user_id : email,
853            tofu_policy_str (policy));
854     }
855
856   if (opt.dry_run)
857     {
858       log_info ("TOFU database update skipped due to --dry-run\n");
859       rc = 0;
860       goto leave;
861     }
862
863   rc = gpgsql_stepx
864     (dbs->db, &dbs->s.record_binding_update, NULL, NULL, &err,
865      "insert or replace into bindings\n"
866      " (oid, fingerprint, email, user_id, time, policy, conflict)\n"
867      " values (\n"
868      /* If we don't explicitly reuse the OID, then SQLite will
869         reallocate a new one.  We just need to search for the OID
870         based on the fingerprint and email since they are unique.  */
871      "  (select oid from bindings where fingerprint = ? and email = ?),\n"
872      "  ?, ?, ?, ?, ?, ?);",
873      GPGSQL_ARG_STRING, fingerprint, GPGSQL_ARG_STRING, email,
874      GPGSQL_ARG_STRING, fingerprint, GPGSQL_ARG_STRING, email,
875      GPGSQL_ARG_STRING, user_id,
876      GPGSQL_ARG_LONG_LONG, (long long) now,
877      GPGSQL_ARG_INT, (int) policy,
878      GPGSQL_ARG_STRING, conflict ? conflict : "",
879      GPGSQL_ARG_END);
880   if (rc)
881     {
882       log_error (_("error updating TOFU database: %s\n"), err);
883       print_further_info (" insert bindings <key: %s, user id: %s> = %s",
884                           fingerprint, email, tofu_policy_str (policy));
885       sqlite3_free (err);
886       goto leave;
887     }
888
889  leave:
890   xfree (fingerprint_pp);
891   return rc;
892 }
893
894
895 /* Collect the strings returned by a query in a simply string list.
896    Any NULL values are converted to the empty string.
897
898    If a result has 3 rows and each row contains two columns, then the
899    results are added to the list as follows (the value is parentheses
900    is the 1-based index in the final list):
901
902      row 1, col 2 (6)
903      row 1, col 1 (5)
904      row 2, col 2 (4)
905      row 2, col 1 (3)
906      row 3, col 2 (2)
907      row 3, col 1 (1)
908
909    This is because add_to_strlist pushes the results onto the front of
910    the list.  The end result is that the rows are backwards, but the
911    columns are in the expected order.  */
912 static int
913 strings_collect_cb (void *cookie, int argc, char **argv, char **azColName)
914 {
915   int i;
916   strlist_t *strlist = cookie;
917
918   (void) azColName;
919
920   for (i = argc - 1; i >= 0; i --)
921     add_to_strlist (strlist, argv[i] ? argv[i] : "");
922
923   return 0;
924 }
925
926 static int
927 strings_collect_cb2 (void *cookie, int argc, char **argv, char **azColName,
928                      sqlite3_stmt *stmt)
929 {
930   (void) stmt;
931   return strings_collect_cb (cookie, argc, argv, azColName);
932
933 }
934
935 /* Auxiliary data structure to collect statistics about
936    signatures.  */
937 struct signature_stats
938 {
939   struct signature_stats *next;
940
941   /* The user-assigned policy for this binding.  */
942   enum tofu_policy policy;
943
944   /* How long ago the signature was created (rounded to a multiple of
945      TIME_AGO_UNIT_SMALL, etc.).  */
946   long time_ago;
947   /* Number of signatures during this time.  */
948   unsigned long count;
949
950   /* If the corresponding key/user id has been expired / revoked.  */
951   int is_expired;
952   int is_revoked;
953
954   /* The key that generated this signature.  */
955   char fingerprint[1];
956 };
957
958 static void
959 signature_stats_free (struct signature_stats *stats)
960 {
961   while (stats)
962     {
963       struct signature_stats *next = stats->next;
964       xfree (stats);
965       stats = next;
966     }
967 }
968
969 static void
970 signature_stats_prepend (struct signature_stats **statsp,
971                          const char *fingerprint,
972                          enum tofu_policy policy,
973                          long time_ago,
974                          unsigned long count)
975 {
976   struct signature_stats *stats =
977     xmalloc_clear (sizeof (*stats) + strlen (fingerprint));
978
979   stats->next = *statsp;
980   *statsp = stats;
981
982   strcpy (stats->fingerprint, fingerprint);
983   stats->policy = policy;
984   stats->time_ago = time_ago;
985   stats->count = count;
986 }
987
988
989 /* Process rows that contain the four columns:
990
991      <fingerprint, policy, time ago, count>.  */
992 static int
993 signature_stats_collect_cb (void *cookie, int argc, char **argv,
994                             char **azColName, sqlite3_stmt *stmt)
995 {
996   struct signature_stats **statsp = cookie;
997   int i = 0;
998   enum tofu_policy policy;
999   long time_ago;
1000   unsigned long count;
1001   long along;
1002
1003   (void) azColName;
1004   (void) stmt;
1005
1006   i ++;
1007
1008   if (string_to_long (&along, argv[i], 0, __LINE__))
1009     return 1;  /* Abort */
1010   policy = along;
1011   i ++;
1012
1013   if (! argv[i])
1014     time_ago = 0;
1015   else
1016     {
1017       if (string_to_long (&time_ago, argv[i], 0, __LINE__))
1018         return 1; /* Abort.  */
1019     }
1020   i ++;
1021
1022   /* If time_ago is NULL, then we had no messages, but we still have a
1023      single row, which count(*) turns into 1.  */
1024   if (! argv[i - 1])
1025     count = 0;
1026   else
1027     {
1028       if (string_to_ulong (&count, argv[i], 0, __LINE__))
1029         return 1; /* Abort */
1030     }
1031   i ++;
1032
1033   log_assert (argc == i);
1034
1035   signature_stats_prepend (statsp, argv[0], policy, time_ago, count);
1036
1037   return 0;
1038 }
1039
1040 /* Convert from seconds to time units.
1041
1042    Note: T should already be a multiple of TIME_AGO_UNIT_SMALL or
1043    TIME_AGO_UNIT_MEDIUM or TIME_AGO_UNIT_LARGE.  */
1044 signed long
1045 time_ago_scale (signed long t)
1046 {
1047   if (t < TIME_AGO_UNIT_MEDIUM)
1048     return t / TIME_AGO_UNIT_SMALL;
1049   if (t < TIME_AGO_UNIT_LARGE)
1050     return t / TIME_AGO_UNIT_MEDIUM;
1051   return t / TIME_AGO_UNIT_LARGE;
1052 }
1053
1054
1055 /* Return the policy for the binding <FINGERPRINT, EMAIL> (email has
1056    already been normalized) and any conflict information in *CONFLICT
1057    if CONFLICT is not NULL.  Returns _tofu_GET_POLICY_ERROR if an error
1058    occurs.  */
1059 static enum tofu_policy
1060 get_policy (tofu_dbs_t dbs, const char *fingerprint, const char *email,
1061             char **conflict)
1062 {
1063   int rc;
1064   char *err = NULL;
1065   strlist_t strlist = NULL;
1066   enum tofu_policy policy = _tofu_GET_POLICY_ERROR;
1067   long along;
1068
1069   /* Check if the <FINGERPRINT, EMAIL> binding is known
1070      (TOFU_POLICY_NONE cannot appear in the DB.  Thus, if POLICY is
1071      still TOFU_POLICY_NONE after executing the query, then the
1072      result set was empty.)  */
1073   rc = gpgsql_stepx (dbs->db, &dbs->s.get_policy_select_policy_and_conflict,
1074                       strings_collect_cb2, &strlist, &err,
1075                       "select policy, conflict from bindings\n"
1076                       " where fingerprint = ? and email = ?",
1077                       GPGSQL_ARG_STRING, fingerprint,
1078                       GPGSQL_ARG_STRING, email,
1079                       GPGSQL_ARG_END);
1080   if (rc)
1081     {
1082       log_error (_("error reading TOFU database: %s\n"), err);
1083       print_further_info ("checking for existing bad bindings");
1084       sqlite3_free (err);
1085       rc = gpg_error (GPG_ERR_GENERAL);
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 static int
1214 cross_sigs (const char *email, 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       int saw_email = 0;
1244
1245       /* Iterate over SIGNEE's keyblock and see if there is a valid
1246          signature from SIGNER.  */
1247       for (n = signee; n; n = n->next)
1248         {
1249           PKT_signature *sig;
1250
1251           if (n->pkt->pkttype == PKT_USER_ID)
1252             {
1253               if (saw_email)
1254                 /* We're done: we've processed all signatures on the
1255                    user id.  */
1256                 break;
1257               else
1258                 {
1259                   /* See if this is the matching user id.  */
1260                   PKT_user_id *user_id = n->pkt->pkt.user_id;
1261                   char *email2 = email_from_user_id (user_id->name);
1262
1263                   if (strcmp (email, email2) == 0)
1264                     saw_email = 1;
1265
1266                   xfree (email2);
1267                 }
1268             }
1269
1270           if (! saw_email)
1271             continue;
1272
1273           if (n->pkt->pkttype != PKT_SIGNATURE)
1274             continue;
1275
1276           sig = n->pkt->pkt.signature;
1277
1278           if (! (sig->sig_class == 0x10
1279                  || sig->sig_class == 0x11
1280                  || sig->sig_class == 0x12
1281                  || sig->sig_class == 0x13))
1282             /* Not a signature over a user id.  */
1283             continue;
1284
1285           /* SIG is on SIGNEE's keyblock.  If SIG was generated by the
1286              signer, then it's a match.  */
1287           if (keyid_cmp (sig->keyid, signer_kid) == 0)
1288             /* Match!  */
1289             break;
1290         }
1291       if (! n)
1292         /* We didn't find a signature from signer over signee.  */
1293         {
1294           if (DBG_TRUST)
1295             log_debug ("No cross sig between %s and %s\n",
1296                        a_keyid, b_keyid);
1297           return 0;
1298         }
1299     }
1300
1301   /* A signed B and B signed A.  */
1302   if (DBG_TRUST)
1303     log_debug ("Cross sig between %s and %s\n",
1304                a_keyid, b_keyid);
1305
1306   return 1;
1307 }
1308
1309 /* Return whether the key was signed by an ultimately trusted key.  */
1310 static int
1311 signed_by_utk (kbnode_t a)
1312 {
1313   kbnode_t n;
1314
1315   for (n = a; n; n = n->next)
1316     {
1317       PKT_signature *sig;
1318
1319       if (n->pkt->pkttype != PKT_SIGNATURE)
1320         continue;
1321
1322       sig = n->pkt->pkt.signature;
1323
1324       if (! (sig->sig_class == 0x10
1325              || sig->sig_class == 0x11
1326              || sig->sig_class == 0x12
1327              || sig->sig_class == 0x13))
1328         /* Not a signature over a user id.  */
1329         continue;
1330
1331       /* SIG is on SIGNEE's keyblock.  If SIG was generated by the
1332          signer, then it's a match.  */
1333       if (tdb_keyid_is_utk (sig->keyid))
1334         {
1335           /* Match!  */
1336           if (DBG_TRUST)
1337             log_debug ("TOFU: %s is signed by an ultimately trusted key.\n",
1338                        pk_keyid_str (a->pkt->pkt.public_key));
1339
1340           return 1;
1341         }
1342     }
1343
1344   if (DBG_TRUST)
1345     log_debug ("TOFU: %s is NOT signed by an ultimately trusted key.\n",
1346                pk_keyid_str (a->pkt->pkt.public_key));
1347
1348   return 0;
1349 }
1350
1351
1352 enum
1353   {
1354     BINDING_NEW = 1 << 0,
1355     BINDING_CONFLICT = 1 << 1,
1356     BINDING_EXPIRED = 1 << 2,
1357     BINDING_REVOKED = 1 << 3
1358   };
1359
1360
1361 /* Ask the user about the binding.  There are three ways we could end
1362  * up here:
1363  *
1364  *   - This is a new binding and there is a conflict
1365  *     (policy == TOFU_POLICY_NONE && conflict_set_count > 1),
1366  *
1367  *   - This is a new binding and opt.tofu_default_policy is set to
1368  *     ask.  (policy == TOFU_POLICY_NONE && opt.tofu_default_policy ==
1369  *     TOFU_POLICY_ASK), or,
1370  *
1371  *   - The policy is ask (the user deferred last time) (policy ==
1372  *     TOFU_POLICY_ASK).
1373  *
1374  * Note: this function must not be called while in a transaction!
1375  *
1376  * CONFLICT_SET includes all of the conflicting bindings
1377  * with FINGERPRINT first.  FLAGS is a bit-wise or of
1378  * BINDING_NEW, etc.
1379  */
1380 static void
1381 ask_about_binding (ctrl_t ctrl,
1382                    enum tofu_policy *policy,
1383                    int *trust_level,
1384                    strlist_t conflict_set,
1385                    const char *fingerprint,
1386                    const char *email,
1387                    const char *user_id,
1388                    time_t now)
1389 {
1390   tofu_dbs_t dbs;
1391   strlist_t iter;
1392   int conflict_set_count = strlist_length (conflict_set);
1393   char *sqerr = NULL;
1394   int rc;
1395   estream_t fp;
1396   strlist_t other_user_ids = NULL;
1397   struct signature_stats *stats = NULL;
1398   struct signature_stats *stats_iter = NULL;
1399   char *prompt = NULL;
1400   char *choices;
1401
1402   dbs = ctrl->tofu.dbs;
1403   log_assert (dbs);
1404   log_assert (dbs->in_transaction == 0);
1405
1406   fp = es_fopenmem (0, "rw,samethread");
1407   if (!fp)
1408     log_fatal ("error creating memory stream: %s\n",
1409                gpg_strerror (gpg_error_from_syserror()));
1410
1411   {
1412     char *text = format_conflict_msg_part1 (*policy, conflict_set, email);
1413     es_fputs (text, fp);
1414     es_fputc ('\n', fp);
1415     xfree (text);
1416   }
1417
1418   begin_transaction (ctrl, 0);
1419
1420   /* Find other user ids associated with this key and whether the
1421    * bindings are marked as good or bad.  */
1422   rc = gpgsql_stepx
1423     (dbs->db, &dbs->s.get_trust_gather_other_user_ids,
1424      strings_collect_cb2, &other_user_ids, &sqerr,
1425      "select user_id, policy from bindings where fingerprint = ?;",
1426      GPGSQL_ARG_STRING, fingerprint, GPGSQL_ARG_END);
1427   if (rc)
1428     {
1429       log_error (_("error gathering other user IDs: %s\n"), sqerr);
1430       sqlite3_free (sqerr);
1431       sqerr = NULL;
1432       rc = gpg_error (GPG_ERR_GENERAL);
1433     }
1434
1435   if (other_user_ids)
1436     {
1437       strlist_t strlist_iter;
1438
1439       es_fprintf (fp, _("This key's user IDs:\n"));
1440       for (strlist_iter = other_user_ids;
1441            strlist_iter;
1442            strlist_iter = strlist_iter->next)
1443         {
1444           char *other_user_id = strlist_iter->d;
1445           char *other_thing;
1446           enum tofu_policy other_policy;
1447
1448           log_assert (strlist_iter->next);
1449           strlist_iter = strlist_iter->next;
1450           other_thing = strlist_iter->d;
1451
1452           other_policy = atoi (other_thing);
1453
1454           es_fprintf (fp, "  %s (", other_user_id);
1455           es_fprintf (fp, _("policy: %s"), tofu_policy_str (other_policy));
1456           es_fprintf (fp, ")\n");
1457         }
1458       es_fprintf (fp, "\n");
1459
1460       free_strlist (other_user_ids);
1461     }
1462
1463   /* Get the stats for all the keys in CONFLICT_SET.  */
1464   strlist_rev (&conflict_set);
1465   for (iter = conflict_set; iter && ! rc; iter = iter->next)
1466     {
1467 #define STATS_SQL(table, time, sign)                         \
1468          "select fingerprint, policy, time_ago, count(*)\n" \
1469          " from\n" \
1470          "  (select bindings.*,\n" \
1471          "     "sign" case\n" \
1472          "       when delta ISNULL then 1\n" \
1473          /* From the future (but if its just a couple of hours in the \
1474           * future don't turn it into a warning)?  Or should we use \
1475           * small, medium or large units?  (Note: whatever we do, we \
1476           * keep the value in seconds.  Then when we group, everything \
1477           * that rounds to the same number of seconds is grouped.)  */ \
1478          "      when delta < -("STRINGIFY (TIME_AGO_FUTURE_IGNORE)") then 2\n" \
1479          "      when delta < ("STRINGIFY (TIME_AGO_SMALL_THRESHOLD)")\n" \
1480          "       then 3\n" \
1481          "      when delta < ("STRINGIFY (TIME_AGO_MEDIUM_THRESHOLD)")\n" \
1482          "       then 4\n" \
1483          "      when delta < ("STRINGIFY (TIME_AGO_LARGE_THRESHOLD)")\n" \
1484          "       then 5\n" \
1485          "      else 6\n" \
1486          "     end time_ago,\n" \
1487          "    delta time_ago_raw\n" \
1488          "   from bindings\n" \
1489          "   left join\n" \
1490          "     (select *,\n" \
1491          "        cast(? - " time " as real) delta\n" \
1492          "       from " table ") ss\n" \
1493          "    on ss.binding = bindings.oid)\n" \
1494          " where email = ? and fingerprint = ?\n" \
1495          " group by time_ago\n" \
1496          /* Make sure the current key is first.  */ \
1497          " order by time_ago desc;\n"
1498
1499       /* Use the time when we saw the signature, not when the
1500          signature was created as that can be forged.  */
1501       rc = gpgsql_stepx
1502         (dbs->db, &dbs->s.get_trust_gather_signature_stats,
1503          signature_stats_collect_cb, &stats, &sqerr,
1504          STATS_SQL ("signatures", "time", ""),
1505          GPGSQL_ARG_LONG_LONG, (long long) now,
1506          GPGSQL_ARG_STRING, email,
1507          GPGSQL_ARG_STRING, iter->d,
1508          GPGSQL_ARG_END);
1509       if (rc)
1510         {
1511           rc = gpg_error (GPG_ERR_GENERAL);
1512           break;
1513         }
1514
1515       if (!stats || strcmp (iter->d, stats->fingerprint) != 0)
1516         /* No stats for this binding.  Add a dummy entry.  */
1517         signature_stats_prepend (&stats, iter->d, TOFU_POLICY_AUTO, 1, 1);
1518
1519       rc = gpgsql_stepx
1520         (dbs->db, &dbs->s.get_trust_gather_encryption_stats,
1521          signature_stats_collect_cb, &stats, &sqerr,
1522          STATS_SQL ("encryptions", "time", "-"),
1523          GPGSQL_ARG_LONG_LONG, (long long) now,
1524          GPGSQL_ARG_STRING, email,
1525          GPGSQL_ARG_STRING, iter->d,
1526          GPGSQL_ARG_END);
1527       if (rc)
1528         {
1529           rc = gpg_error (GPG_ERR_GENERAL);
1530           break;
1531         }
1532
1533 #undef STATS_SQL
1534
1535       if (!stats || strcmp (iter->d, stats->fingerprint) != 0
1536           || stats->time_ago > 0)
1537         /* No stats for this binding.  Add a dummy entry.  */
1538         signature_stats_prepend (&stats, iter->d, TOFU_POLICY_AUTO, -1, 1);
1539     }
1540   end_transaction (ctrl, 0);
1541   strlist_rev (&conflict_set);
1542   if (rc)
1543     {
1544       strlist_t strlist_iter;
1545
1546       log_error (_("error gathering signature stats: %s\n"), sqerr);
1547       sqlite3_free (sqerr);
1548       sqerr = NULL;
1549
1550       es_fprintf (fp, ngettext("The email address \"%s\" is"
1551                                " associated with %d key:\n",
1552                                "The email address \"%s\" is"
1553                                " associated with %d keys:\n",
1554                                conflict_set_count),
1555                   email, conflict_set_count);
1556       for (strlist_iter = conflict_set;
1557            strlist_iter;
1558            strlist_iter = strlist_iter->next)
1559         es_fprintf (fp, "  %s\n", strlist_iter->d);
1560     }
1561   else
1562     {
1563       char *key = NULL;
1564       strlist_t binding;
1565       int seen_in_past = 0;
1566
1567       es_fprintf (fp, _("Statistics for keys"
1568                         " with the email address \"%s\":\n"),
1569                   email);
1570       for (stats_iter = stats; stats_iter; stats_iter = stats_iter->next)
1571         {
1572 #if 0
1573           log_debug ("%s: time_ago: %ld; count: %ld\n",
1574                      stats_iter->fingerprint,
1575                      stats_iter->time_ago,
1576                      stats_iter->count);
1577 #endif
1578
1579           if (! key || strcmp (key, stats_iter->fingerprint))
1580             {
1581               int this_key;
1582               char *key_pp;
1583
1584               key = stats_iter->fingerprint;
1585               this_key = strcmp (key, fingerprint) == 0;
1586               key_pp = format_hexfingerprint (key, NULL, 0);
1587               es_fprintf (fp, "  %s (", key_pp);
1588
1589               /* Find the associated binding.  */
1590               for (binding = conflict_set;
1591                    binding;
1592                    binding = binding->next)
1593                 if (strcmp (key, binding->d) == 0)
1594                   break;
1595               log_assert (binding);
1596
1597               if ((binding->flags & BINDING_REVOKED))
1598                 {
1599                   es_fprintf (fp, _("revoked"));
1600                   es_fprintf (fp, _(", "));
1601                 }
1602               else if ((binding->flags & BINDING_EXPIRED))
1603                 {
1604                   es_fprintf (fp, _("expired"));
1605                   es_fprintf (fp, _(", "));
1606                 }
1607
1608               if (this_key)
1609                 es_fprintf (fp, _("this key"));
1610               else
1611                 es_fprintf (fp, _("policy: %s"),
1612                             tofu_policy_str (stats_iter->policy));
1613               es_fputs ("):\n", fp);
1614               xfree (key_pp);
1615
1616               seen_in_past = 0;
1617             }
1618
1619           if (labs(stats_iter->time_ago) == 1)
1620             {
1621               /* The 1 in this case is the NULL entry.  */
1622               log_assert (stats_iter->count == 1);
1623               stats_iter->count = 0;
1624             }
1625           seen_in_past += stats_iter->count;
1626
1627           es_fputs ("    ", fp);
1628           /* TANSLATORS: This string is concatenated with one of
1629            * the day/week/month strings to form one sentence.  */
1630           if (stats_iter->time_ago > 0)
1631             es_fprintf (fp, ngettext("Verified %d message",
1632                                      "Verified %d messages",
1633                                      seen_in_past), seen_in_past);
1634           else
1635             es_fprintf (fp, ngettext("Encrypted %d message",
1636                                      "Encrypted %d messages",
1637                                      seen_in_past), seen_in_past);
1638
1639           if (!stats_iter->count)
1640             es_fputs (".", fp);
1641           else if (labs(stats_iter->time_ago) == 2)
1642             {
1643               es_fprintf (fp, "in the future.");
1644               /* Reset it.  */
1645               seen_in_past = 0;
1646             }
1647           else
1648             {
1649               if (labs(stats_iter->time_ago) == 3)
1650                 es_fprintf (fp, ngettext(" over the past day.",
1651                                          " over the past %d days.",
1652                                          seen_in_past),
1653                             TIME_AGO_SMALL_THRESHOLD
1654                             / TIME_AGO_UNIT_SMALL);
1655               else if (labs(stats_iter->time_ago) == 4)
1656                 es_fprintf (fp, ngettext(" over the past month.",
1657                                          " over the past %d months.",
1658                                          seen_in_past),
1659                             TIME_AGO_MEDIUM_THRESHOLD
1660                             / TIME_AGO_UNIT_MEDIUM);
1661               else if (labs(stats_iter->time_ago) == 5)
1662                 es_fprintf (fp, ngettext(" over the past year.",
1663                                          " over the past %d years.",
1664                                          seen_in_past),
1665                             TIME_AGO_LARGE_THRESHOLD
1666                             / TIME_AGO_UNIT_LARGE);
1667               else if (labs(stats_iter->time_ago) == 6)
1668                 es_fprintf (fp, _(" in the past."));
1669               else
1670                 log_assert (! "Broken SQL.\n");
1671             }
1672           es_fputs ("\n", fp);
1673         }
1674     }
1675
1676   if (conflict_set_count > 1 || (conflict_set->flags & BINDING_CONFLICT))
1677     {
1678       /* This is a conflict.  */
1679
1680       /* TRANSLATORS: Please translate the text found in the source
1681        * file below.  We don't directly internationalize that text so
1682        * that we can tweak it without breaking translations.  */
1683       char *text = _("TOFU detected a binding conflict");
1684       char *textbuf;
1685       if (!strcmp (text, "TOFU detected a binding conflict"))
1686         {
1687           /* No translation.  Use the English text.  */
1688           text =
1689             "Normally, an email address is associated with a single key.  "
1690             "However, people sometimes generate a new key if "
1691             "their key is too old or they think it might be compromised.  "
1692             "Alternatively, a new key may indicate a man-in-the-middle "
1693             "attack!  Before accepting this association, you should talk to or "
1694             "call the person to make sure this new key is legitimate.";
1695         }
1696       textbuf = format_text (text, 0, 72, 80);
1697       es_fprintf (fp, "\n%s\n", textbuf);
1698       xfree (textbuf);
1699     }
1700
1701   es_fputc ('\n', fp);
1702
1703   /* Add a NUL terminator.  */
1704   es_fputc (0, fp);
1705   if (es_fclose_snatch (fp, (void **) &prompt, NULL))
1706     log_fatal ("error snatching memory stream\n");
1707
1708   /* I think showing the large message once is sufficient.  If we
1709    * would move it right before the cpr_get many lines will scroll
1710    * away and the user might not realize that he merely entered a
1711    * wrong choise (because he does not see that either).  As a small
1712    * benefit we allow C-L to redisplay everything.  */
1713   tty_printf ("%s", prompt);
1714
1715   /* Suspend any transaction: it could take a while until the user
1716      responds.  */
1717   tofu_suspend_batch_transaction (ctrl);
1718   while (1)
1719     {
1720       char *response;
1721
1722       /* TRANSLATORS: Two letters (normally the lower and upper case
1723        * version of the hotkey) for each of the five choices.  If
1724        * there is only one choice in your language, repeat it.  */
1725       choices = _("gG" "aA" "uU" "rR" "bB");
1726       if (strlen (choices) != 10)
1727         log_bug ("Bad TOFU conflict translation!  Please report.");
1728
1729       response = cpr_get
1730         ("tofu.conflict",
1731          _("(G)ood, (A)ccept once, (U)nknown, (R)eject once, (B)ad? "));
1732       trim_spaces (response);
1733       cpr_kill_prompt ();
1734       if (*response == CONTROL_L)
1735         tty_printf ("%s", prompt);
1736       else if (!response[0])
1737         /* Default to unknown.  Don't save it.  */
1738         {
1739           tty_printf (_("Defaulting to unknown."));
1740           *policy = TOFU_POLICY_UNKNOWN;
1741           break;
1742         }
1743       else if (!response[1])
1744         {
1745           char *choice = strchr (choices, *response);
1746
1747           if (choice)
1748             {
1749               int c = ((size_t) choice - (size_t) choices) / 2;
1750
1751               switch (c)
1752                 {
1753                 case 0: /* Good.  */
1754                   *policy = TOFU_POLICY_GOOD;
1755                   *trust_level = tofu_policy_to_trust_level (*policy);
1756                   break;
1757                 case 1: /* Accept once.  */
1758                   *policy = TOFU_POLICY_ASK;
1759                   *trust_level = tofu_policy_to_trust_level (TOFU_POLICY_GOOD);
1760                   break;
1761                 case 2: /* Unknown.  */
1762                   *policy = TOFU_POLICY_UNKNOWN;
1763                   *trust_level = tofu_policy_to_trust_level (*policy);
1764                   break;
1765                 case 3: /* Reject once.  */
1766                   *policy = TOFU_POLICY_ASK;
1767                   *trust_level = tofu_policy_to_trust_level (TOFU_POLICY_BAD);
1768                   break;
1769                 case 4: /* Bad.  */
1770                   *policy = TOFU_POLICY_BAD;
1771                   *trust_level = tofu_policy_to_trust_level (*policy);
1772                   break;
1773                 default:
1774                   log_bug ("c should be between 0 and 4 but it is %d!", c);
1775                 }
1776
1777               if (record_binding (dbs, fingerprint, email, user_id,
1778                                   *policy, NULL, 0, now))
1779                 {
1780                   /* If there's an error registering the
1781                    * binding, don't save the signature.  */
1782                   *trust_level = _tofu_GET_TRUST_ERROR;
1783                 }
1784               break;
1785             }
1786         }
1787       xfree (response);
1788     }
1789
1790   tofu_resume_batch_transaction (ctrl);
1791
1792   xfree (prompt);
1793
1794   signature_stats_free (stats);
1795 }
1796
1797 /* Return the set of keys that conflict with the binding <fingerprint,
1798    email> (including the binding itself, which will be first in the
1799    list).  For each returned key also sets BINDING_NEW, etc.  */
1800 static strlist_t
1801 build_conflict_set (tofu_dbs_t dbs, const char *fingerprint, const char *email)
1802 {
1803   gpg_error_t rc;
1804   char *sqerr;
1805   strlist_t conflict_set = NULL;
1806   int conflict_set_count;
1807   strlist_t iter;
1808   kbnode_t *kb_all;
1809   KEYDB_HANDLE hd;
1810   int i;
1811
1812   /* Get the fingerprints of any bindings that share the email address
1813    * and whether the bindings have a known conflict.
1814    *
1815    * Note: if the binding in question is in the DB, it will also be
1816    * returned.  Thus, if the result set is empty, then <email,
1817    * fingerprint> is a new binding.  */
1818   rc = gpgsql_stepx
1819     (dbs->db, &dbs->s.get_trust_bindings_with_this_email,
1820      strings_collect_cb2, &conflict_set, &sqerr,
1821      "select"
1822      /* A binding should only appear once, but try not to break in the
1823       * case of corruption.  */
1824      "  fingerprint || case sum(conflict NOTNULL) when 0 then '' else '!' end"
1825      " from bindings where email = ?"
1826      "  group by fingerprint"
1827      /* Make sure the current key comes first in the result list (if
1828         it is present).  */
1829      "  order by fingerprint = ? asc, fingerprint desc;",
1830      GPGSQL_ARG_STRING, email,
1831      GPGSQL_ARG_STRING, fingerprint,
1832      GPGSQL_ARG_END);
1833   if (rc)
1834     {
1835       log_error (_("error reading TOFU database: %s\n"), sqerr);
1836       print_further_info ("listing fingerprints");
1837       sqlite3_free (sqerr);
1838       rc = gpg_error (GPG_ERR_GENERAL);
1839       return NULL;
1840     }
1841
1842   /* Set BINDING_CONFLICT if the binding has a known conflict.  This
1843    * allows us to distinguish between bindings where the user
1844    * explicitly set the policy to ask and bindings where we set the
1845    * policy to ask due to a conflict.  */
1846   for (iter = conflict_set; iter; iter = iter->next)
1847     {
1848       int l = strlen (iter->d);
1849       if (!(l == 2 * MAX_FINGERPRINT_LEN
1850             || l == 2 * MAX_FINGERPRINT_LEN + 1))
1851         {
1852           log_error (_("TOFU db corruption detected.\n"));
1853           print_further_info ("fingerprint '%s' is not %d characters long",
1854                               iter->d, 2 * MAX_FINGERPRINT_LEN);
1855         }
1856
1857       if (l >= 1 && iter->d[l - 1] == '!')
1858         {
1859           iter->flags |= BINDING_CONFLICT;
1860           /* Remove the !.  */
1861           iter->d[l - 1] = 0;
1862         }
1863     }
1864
1865   /* If the current binding has not yet been recorded, add it to the
1866    * list.  (The order by above ensures that if it is present, it will
1867    * be first.)  */
1868   if (! (conflict_set && strcmp (conflict_set->d, fingerprint) == 0))
1869     {
1870       add_to_strlist (&conflict_set, fingerprint);
1871       conflict_set->flags |= BINDING_NEW;
1872     }
1873
1874   conflict_set_count = strlist_length (conflict_set);
1875
1876   /* Eliminate false conflicts.  */
1877
1878   /* If two keys have cross signatures, then they are controlled by
1879    * the same person and thus are not in conflict.  */
1880   kb_all = xcalloc (sizeof (kb_all[0]), conflict_set_count);
1881   hd = keydb_new ();
1882   for (i = 0, iter = conflict_set;
1883        i < conflict_set_count;
1884        i ++, iter = iter->next)
1885     {
1886       char *fp = iter->d;
1887       KEYDB_SEARCH_DESC desc;
1888       kbnode_t kb;
1889       PKT_public_key *binding_pk;
1890       kbnode_t n;
1891       int found_user_id;
1892
1893       rc = keydb_search_reset (hd);
1894       if (rc)
1895         {
1896           log_error (_("resetting keydb: %s\n"),
1897                      gpg_strerror (rc));
1898           continue;
1899         }
1900
1901       rc = classify_user_id (fp, &desc, 0);
1902       if (rc)
1903         {
1904           log_error (_("error parsing key specification '%s': %s\n"),
1905                      fp, gpg_strerror (rc));
1906           continue;
1907         }
1908
1909       rc = keydb_search (hd, &desc, 1, NULL);
1910       if (rc)
1911         {
1912           /* Note: it is entirely possible that we don't have the key
1913              corresponding to an entry in the TOFU DB.  This can
1914              happen if we merge two TOFU DBs, but not the key
1915              rings.  */
1916           log_info (_("key \"%s\" not found: %s\n"),
1917                     fp, gpg_strerror (rc));
1918           continue;
1919         }
1920
1921       rc = keydb_get_keyblock (hd, &kb);
1922       if (rc)
1923         {
1924           log_error (_("error reading keyblock: %s\n"),
1925                      gpg_strerror (rc));
1926           print_further_info ("fingerprint: %s", fp);
1927           continue;
1928         }
1929
1930       merge_keys_and_selfsig (kb);
1931
1932       log_assert (kb->pkt->pkttype == PKT_PUBLIC_KEY);
1933
1934       kb_all[i] = kb;
1935
1936       /* Since we have the key block, use this opportunity to figure
1937        * out if the binding is expired or revoked.  */
1938       binding_pk = kb->pkt->pkt.public_key;
1939
1940       /* The binding is always expired/revoked if the key is
1941        * expired/revoked.  */
1942       if (binding_pk->has_expired)
1943         iter->flags &= BINDING_EXPIRED;
1944       if (binding_pk->flags.revoked)
1945         iter->flags &= BINDING_REVOKED;
1946
1947       /* The binding is also expired/revoked if the user id is
1948        * expired/revoked.  */
1949       n = kb;
1950       found_user_id = 0;
1951       while ((n = find_next_kbnode (n, PKT_USER_ID)) && ! found_user_id)
1952         {
1953           PKT_user_id *user_id2 = n->pkt->pkt.user_id;
1954           char *email2;
1955
1956           if (user_id2->attrib_data)
1957             continue;
1958
1959           email2 = email_from_user_id (user_id2->name);
1960
1961           if (strcmp (email, email2) == 0)
1962             {
1963               found_user_id = 1;
1964
1965               if (user_id2->is_revoked)
1966                 iter->flags &= BINDING_REVOKED;
1967               if (user_id2->is_expired)
1968                 iter->flags &= BINDING_EXPIRED;
1969             }
1970
1971           xfree (email2);
1972         }
1973
1974       if (! found_user_id)
1975         {
1976           log_info (_("TOFU db corruption detected.\n"));
1977           print_further_info ("user id '%s' not on key block '%s'",
1978                               email, fingerprint);
1979         }
1980     }
1981   keydb_release (hd);
1982
1983   /* Now that we have the key blocks, check for cross sigs.  */
1984   {
1985     int j;
1986     strlist_t *prevp;
1987     strlist_t iter_next;
1988     int die[conflict_set_count];
1989
1990     memset (die, 0, sizeof (die));
1991
1992     for (i = 0; i < conflict_set_count; i ++)
1993       {
1994         /* Look for cross sigs between this key (i == 0) or a key
1995          * that has cross sigs with i == 0 (i.e., transitively) */
1996         if (! (i == 0 || die[i]))
1997           continue;
1998
1999         for (j = i + 1; j < conflict_set_count; j ++)
2000           /* Be careful: we might not have a key block for a key.  */
2001           if (kb_all[i] && kb_all[j] && cross_sigs (email, kb_all[i], kb_all[j]))
2002             die[j] = 1;
2003       }
2004
2005     /* Free unconflicting bindings (and all of the key blocks).  */
2006     for (iter = conflict_set, prevp = &conflict_set, i = 0;
2007          iter;
2008          iter = iter_next, i ++)
2009       {
2010         iter_next = iter->next;
2011
2012         release_kbnode (kb_all[i]);
2013
2014         if (die[i])
2015           {
2016             *prevp = iter_next;
2017             iter->next = NULL;
2018             free_strlist (iter);
2019             conflict_set_count --;
2020           }
2021         else
2022           {
2023             prevp = &iter->next;
2024           }
2025       }
2026
2027     /* We shouldn't have removed the head.  */
2028     log_assert (conflict_set);
2029     log_assert (conflict_set_count >= 1);
2030   }
2031   xfree (kb_all);
2032
2033   if (DBG_TRUST)
2034     {
2035       log_debug ("binding <key: %s, email: %s> conflicts:\n",
2036                  fingerprint, email);
2037       for (iter = conflict_set; iter; iter = iter->next)
2038         {
2039           log_debug ("  %s:%s%s%s%s\n",
2040                      iter->d,
2041                      (iter->flags & BINDING_NEW) ? " new" : "",
2042                      (iter->flags & BINDING_CONFLICT) ? " known_conflict" : "",
2043                      (iter->flags & BINDING_EXPIRED) ? " expired" : "",
2044                      (iter->flags & BINDING_REVOKED) ? " revoked" : "");
2045         }
2046     }
2047
2048   return conflict_set;
2049 }
2050
2051
2052 /* Return the trust level (TRUST_NEVER, etc.) for the binding
2053  * <FINGERPRINT, EMAIL> (email is already normalized).  If no policy
2054  * is registered, returns TOFU_POLICY_NONE.  If an error occurs,
2055  * returns _tofu_GET_TRUST_ERROR.
2056  *
2057  * PK is the public key object for FINGERPRINT.
2058  *
2059  * USER_ID is the unadulterated user id.
2060  *
2061  * If MAY_ASK is set, then we may interact with the user.  This is
2062  * necessary if there is a conflict or the binding's policy is
2063  * TOFU_POLICY_ASK.  In the case of a conflict, we set the new
2064  * conflicting binding's policy to TOFU_POLICY_ASK.  In either case,
2065  * we return TRUST_UNDEFINED.  Note: if MAY_ASK is set, then this
2066  * function must not be called while in a transaction!  */
2067 static enum tofu_policy
2068 get_trust (ctrl_t ctrl, PKT_public_key *pk,
2069            const char *fingerprint, const char *email,
2070            const char *user_id, int may_ask, time_t now)
2071 {
2072   tofu_dbs_t dbs = ctrl->tofu.dbs;
2073   int in_transaction = 0;
2074   enum tofu_policy policy;
2075   int rc;
2076   char *sqerr = NULL;
2077   int change_conflicting_to_ask = 0;
2078   strlist_t conflict_set = NULL;
2079   int conflict_set_count;
2080   int trust_level = TRUST_UNKNOWN;
2081   strlist_t iter;
2082
2083   log_assert (dbs);
2084
2085   if (may_ask)
2086     log_assert (dbs->in_transaction == 0);
2087
2088   if (opt.batch)
2089     may_ask = 0;
2090
2091   log_assert (keyid_cmp (pk_keyid (pk), pk_main_keyid (pk)) == 0);
2092
2093   /* Make sure _tofu_GET_TRUST_ERROR isn't equal to any of the trust
2094      levels.  */
2095   log_assert (_tofu_GET_TRUST_ERROR != TRUST_UNKNOWN
2096               && _tofu_GET_TRUST_ERROR != TRUST_EXPIRED
2097               && _tofu_GET_TRUST_ERROR != TRUST_UNDEFINED
2098               && _tofu_GET_TRUST_ERROR != TRUST_NEVER
2099               && _tofu_GET_TRUST_ERROR != TRUST_MARGINAL
2100               && _tofu_GET_TRUST_ERROR != TRUST_FULLY
2101               && _tofu_GET_TRUST_ERROR != TRUST_ULTIMATE);
2102
2103   begin_transaction (ctrl, 0);
2104   in_transaction = 1;
2105
2106   policy = get_policy (dbs, fingerprint, email, NULL);
2107   {
2108     /* See if the key is ultimately trusted.  If so, we're done.  */
2109     u32 kid[2];
2110
2111     keyid_from_pk (pk, kid);
2112
2113     if (tdb_keyid_is_utk (kid))
2114       {
2115         if (policy == TOFU_POLICY_NONE)
2116           /* New binding.  */
2117           {
2118             if (record_binding (dbs, fingerprint, email, user_id,
2119                                 TOFU_POLICY_GOOD, NULL, 0, now) != 0)
2120               {
2121                 log_error (_("error setting TOFU binding's trust level"
2122                              " to %s\n"), "good");
2123                 trust_level = _tofu_GET_TRUST_ERROR;
2124                 goto out;
2125               }
2126           }
2127
2128         trust_level = TRUST_ULTIMATE;
2129         goto out;
2130       }
2131   }
2132
2133   if (policy == TOFU_POLICY_AUTO)
2134     {
2135       policy = opt.tofu_default_policy;
2136       if (DBG_TRUST)
2137         log_debug ("TOFU: binding <key: %s, user id: %s>'s policy is"
2138                    " auto (default: %s).\n",
2139                    fingerprint, email,
2140                    tofu_policy_str (opt.tofu_default_policy));
2141     }
2142   switch (policy)
2143     {
2144     case TOFU_POLICY_AUTO:
2145     case TOFU_POLICY_GOOD:
2146     case TOFU_POLICY_UNKNOWN:
2147     case TOFU_POLICY_BAD:
2148       /* The saved judgement is auto -> auto, good, unknown or bad.
2149        * We don't need to ask the user anything.  */
2150       if (DBG_TRUST)
2151         log_debug ("TOFU: Known binding <key: %s, user id: %s>'s policy: %s\n",
2152                    fingerprint, email, tofu_policy_str (policy));
2153       trust_level = tofu_policy_to_trust_level (policy);
2154       goto out;
2155
2156     case TOFU_POLICY_ASK:
2157       /* We need to ask the user what to do.  Case #1 or #2 below.  */
2158       break;
2159
2160     case TOFU_POLICY_NONE:
2161       /* The binding is new, we need to check for conflicts.  Case #3
2162        * below.  */
2163       break;
2164
2165     case _tofu_GET_POLICY_ERROR:
2166       trust_level = _tofu_GET_TRUST_ERROR;
2167       goto out;
2168
2169     default:
2170       log_bug ("%s: Impossible value for policy (%d)\n", __func__, policy);
2171     }
2172
2173
2174   /* We get here if:
2175    *
2176    *   1. The saved policy is auto and the default policy is ask
2177    *      (get_policy() == TOFU_POLICY_AUTO
2178    *       && opt.tofu_default_policy == TOFU_POLICY_ASK)
2179    *
2180    *   2. The saved policy is ask (either last time the user selected
2181    *      accept once or reject once or there was a conflict and this
2182    *      binding's policy was changed from auto to ask)
2183    *      (policy == TOFU_POLICY_ASK), or,
2184    *
2185    *   3. We don't have a saved policy (policy == TOFU_POLICY_NONE)
2186    *      (need to check for a conflict).
2187    *
2188    * In summary: POLICY is ask or none.
2189    */
2190
2191   /* Before continuing, see if the key is signed by an ultimately
2192    * trusted key.  */
2193   {
2194     int fingerprint_raw_len = strlen (fingerprint) / 2;
2195     char fingerprint_raw[fingerprint_raw_len];
2196     int len = 0;
2197     int is_signed_by_utk = 0;
2198
2199     if (fingerprint_raw_len != 20
2200         || ((len = hex2bin (fingerprint,
2201                             fingerprint_raw, fingerprint_raw_len))
2202             != strlen (fingerprint)))
2203       {
2204         if (DBG_TRUST)
2205           log_debug ("TOFU: Bad fingerprint: %s (len: %zd, parsed: %d)\n",
2206                      fingerprint, strlen (fingerprint), len);
2207       }
2208     else
2209       {
2210         int lookup_err;
2211         kbnode_t kb;
2212
2213         lookup_err = get_pubkey_byfprint (NULL, &kb,
2214                                           fingerprint_raw,
2215                                           fingerprint_raw_len);
2216         if (lookup_err)
2217           {
2218             if (DBG_TRUST)
2219               log_debug ("TOFU: Looking up %s: %s\n",
2220                          fingerprint, gpg_strerror (lookup_err));
2221           }
2222         else
2223           {
2224             is_signed_by_utk = signed_by_utk (kb);
2225             release_kbnode (kb);
2226           }
2227       }
2228
2229     if (is_signed_by_utk)
2230       {
2231         if (record_binding (dbs, fingerprint, email, user_id,
2232                             TOFU_POLICY_GOOD, NULL, 0, now) != 0)
2233           {
2234             log_error (_("error setting TOFU binding's trust level"
2235                          " to %s\n"), "good");
2236             trust_level = _tofu_GET_TRUST_ERROR;
2237           }
2238         else
2239           trust_level = TRUST_FULLY;
2240
2241         goto out;
2242       }
2243   }
2244
2245
2246   /* Look for conflicts.  This is needed in all 3 cases.  */
2247   conflict_set = build_conflict_set (dbs, fingerprint, email);
2248   conflict_set_count = strlist_length (conflict_set);
2249   if (conflict_set_count == 0)
2250     {
2251       /* We should always at least have the current binding.  */
2252       trust_level = _tofu_GET_TRUST_ERROR;
2253       goto out;
2254     }
2255
2256   if (conflict_set_count == 1
2257       && (conflict_set->flags & BINDING_NEW)
2258       && opt.tofu_default_policy != TOFU_POLICY_ASK)
2259     {
2260       /* We've never observed a binding with this email address and we
2261        * have a default policy, which is not to ask the user.  */
2262
2263       /* If we've seen this binding, then we've seen this email and
2264        * policy couldn't possibly be TOFU_POLICY_NONE.  */
2265       log_assert (policy == TOFU_POLICY_NONE);
2266
2267       if (DBG_TRUST)
2268         log_debug ("TOFU: New binding <key: %s, user id: %s>, no conflict.\n",
2269                    fingerprint, email);
2270
2271       if (record_binding (dbs, fingerprint, email, user_id,
2272                           TOFU_POLICY_AUTO, NULL, 0, now) != 0)
2273         {
2274           log_error (_("error setting TOFU binding's trust level to %s\n"),
2275                        "auto");
2276           trust_level = _tofu_GET_TRUST_ERROR;
2277           goto out;
2278         }
2279
2280       trust_level = tofu_policy_to_trust_level (TOFU_POLICY_AUTO);
2281       goto out;
2282     }
2283
2284   if (conflict_set_count == 1
2285       && (conflict_set->flags & BINDING_CONFLICT))
2286     {
2287       /* No known conflicts now, but there was a conflict.  This means
2288        * at somepoint, there was a conflict and we changed this
2289        * binding's policy to ask and set the conflicting key.  The
2290        * conflict can go away if there is not a cross sig between the
2291        * two keys.  In this case, just silently clear the conflict and
2292        * reset the policy to auto.  */
2293
2294       log_assert (policy == TOFU_POLICY_ASK);
2295
2296       if (DBG_TRUST)
2297         log_debug ("TOFU: binding <key: %s, user id: %s> had a conflict, but it's been resolved (probably via  cross sig).\n",
2298                    fingerprint, email);
2299
2300       if (record_binding (dbs, fingerprint, email, user_id,
2301                           TOFU_POLICY_AUTO, NULL, 0, now) != 0)
2302         log_error (_("error setting TOFU binding's trust level to %s\n"),
2303                    "auto");
2304
2305       trust_level = tofu_policy_to_trust_level (TOFU_POLICY_AUTO);
2306       goto out;
2307     }
2308
2309   /* We have a conflict.  Mark any conflicting bindings that have an
2310    * automatic policy as now requiring confirmation.  Note: we delay
2311    * this until after we ask for confirmation so that when the current
2312    * policy is printed, it is correct.  */
2313   change_conflicting_to_ask = 1;
2314
2315   if (! may_ask)
2316     {
2317       log_assert (policy == TOFU_POLICY_NONE || policy == TOFU_POLICY_ASK);
2318       if (policy == TOFU_POLICY_NONE)
2319         {
2320           /* We get here in the third case (no saved policy) and if
2321            * there is a conflict.  */
2322           if (record_binding (dbs, fingerprint, email, user_id,
2323                               TOFU_POLICY_ASK,
2324                               conflict_set && conflict_set->next
2325                               ? conflict_set->next->d : NULL,
2326                               0, now) != 0)
2327             log_error (_("error setting TOFU binding's trust level to %s\n"),
2328                        "ask");
2329         }
2330
2331       trust_level = TRUST_UNDEFINED;
2332       goto out;
2333     }
2334
2335   /* We can't be in a normal transaction in ask_about_binding.  */
2336   end_transaction (ctrl, 0);
2337   in_transaction = 0;
2338
2339   /* If we get here, we need to ask the user about the binding.  */
2340   ask_about_binding (ctrl,
2341                      &policy,
2342                      &trust_level,
2343                      conflict_set,
2344                      fingerprint,
2345                      email,
2346                      user_id,
2347                      now);
2348
2349  out:
2350
2351   if (change_conflicting_to_ask)
2352     {
2353       /* Mark any conflicting bindings that have an automatic policy as
2354        * now requiring confirmation.  */
2355
2356       if (! in_transaction)
2357         {
2358           begin_transaction (ctrl, 0);
2359           in_transaction = 1;
2360         }
2361
2362       /* If we weren't allowed to ask, also update this key as
2363        * conflicting with itself.  */
2364       for (iter = may_ask ? conflict_set->next : conflict_set;
2365            iter; iter = iter->next)
2366         {
2367           rc = gpgsql_exec_printf
2368             (dbs->db, NULL, NULL, &sqerr,
2369              "update bindings set policy = %d, conflict = %Q"
2370              " where email = %Q and fingerprint = %Q and policy = %d;",
2371              TOFU_POLICY_ASK, fingerprint,
2372              email, iter->d, TOFU_POLICY_AUTO);
2373           if (rc)
2374             {
2375               log_error (_("error changing TOFU policy: %s\n"), sqerr);
2376               print_further_info ("binding: <key: %s, user id: %s>",
2377                                   fingerprint, user_id);
2378               sqlite3_free (sqerr);
2379               sqerr = NULL;
2380               rc = gpg_error (GPG_ERR_GENERAL);
2381             }
2382           else if (DBG_TRUST)
2383             log_debug ("Set %s to conflict with %s\n",
2384                        iter->d, fingerprint);
2385         }
2386     }
2387
2388   if (in_transaction)
2389     end_transaction (ctrl, 0);
2390
2391   free_strlist (conflict_set);
2392
2393   return trust_level;
2394 }
2395
2396
2397 /* Return a malloced string of the form
2398  *    "7 months, 1 day, 5 minutes, 0 seconds"
2399  * The caller should replace all '~' in the returned string by a space
2400  * and also free the returned string.
2401  *
2402  * This is actually a bad hack which may not work correctly with all
2403  * languages.
2404  */
2405 static char *
2406 time_ago_str (long long int t)
2407 {
2408   estream_t fp;
2409   int years = 0;
2410   int months = 0;
2411   int days = 0;
2412   int hours = 0;
2413   int minutes = 0;
2414   int seconds = 0;
2415
2416   /* The number of units that we've printed so far.  */
2417   int count = 0;
2418   /* The first unit that we printed (year = 0, month = 1,
2419      etc.).  */
2420   int first = -1;
2421   /* The current unit.  */
2422   int i = 0;
2423
2424   char *str;
2425
2426   /* It would be nice to use a macro to do this, but gettext
2427      works on the unpreprocessed code.  */
2428 #define MIN_SECS (60)
2429 #define HOUR_SECS (60 * MIN_SECS)
2430 #define DAY_SECS (24 * HOUR_SECS)
2431 #define MONTH_SECS (30 * DAY_SECS)
2432 #define YEAR_SECS (365 * DAY_SECS)
2433
2434   if (t > YEAR_SECS)
2435     {
2436       years = t / YEAR_SECS;
2437       t -= years * YEAR_SECS;
2438     }
2439   if (t > MONTH_SECS)
2440     {
2441       months = t / MONTH_SECS;
2442       t -= months * MONTH_SECS;
2443     }
2444   if (t > DAY_SECS)
2445     {
2446       days = t / DAY_SECS;
2447       t -= days * DAY_SECS;
2448     }
2449   if (t > HOUR_SECS)
2450     {
2451       hours = t / HOUR_SECS;
2452       t -= hours * HOUR_SECS;
2453     }
2454   if (t > MIN_SECS)
2455     {
2456       minutes = t / MIN_SECS;
2457       t -= minutes * MIN_SECS;
2458     }
2459   seconds = t;
2460
2461 #undef MIN_SECS
2462 #undef HOUR_SECS
2463 #undef DAY_SECS
2464 #undef MONTH_SECS
2465 #undef YEAR_SECS
2466
2467   fp = es_fopenmem (0, "rw,samethread");
2468   if (! fp)
2469     log_fatal ("error creating memory stream: %s\n",
2470                gpg_strerror (gpg_error_from_syserror()));
2471
2472   if (years)
2473     {
2474       /* TRANSLATORS: The tilde ('~') is used here to indicate a
2475        * non-breakable space  */
2476       es_fprintf (fp, ngettext("%d~year", "%d~years", years), years);
2477       count ++;
2478       first = i;
2479     }
2480   i ++;
2481   if ((first == -1 || i - first <= 3) && count <= 0 && months)
2482     {
2483       if (count)
2484         es_fprintf (fp, ", ");
2485       es_fprintf (fp, ngettext("%d~month", "%d~months", months), months);
2486       count ++;
2487       first = i;
2488     }
2489   i ++;
2490   if ((first == -1 || i - first <= 3) && count <= 0 && days)
2491     {
2492       if (count)
2493         es_fprintf (fp, ", ");
2494       es_fprintf (fp, ngettext("%d~day", "%d~days", days), days);
2495       count ++;
2496       first = i;
2497     }
2498   i ++;
2499   if ((first == -1 || i - first <= 3) && count <= 0 && hours)
2500     {
2501       if (count)
2502         es_fprintf (fp, ", ");
2503       es_fprintf (fp, ngettext("%d~hour", "%d~hours", hours), hours);
2504       count ++;
2505       first = i;
2506     }
2507   i ++;
2508   if ((first == -1 || i - first <= 3) && count <= 0 && minutes)
2509     {
2510       if (count)
2511         es_fprintf (fp, ", ");
2512       es_fprintf (fp, ngettext("%d~minute", "%d~minutes", minutes), minutes);
2513       count ++;
2514       first = i;
2515     }
2516   i ++;
2517   if ((first == -1 || i - first <= 3) && count <= 0)
2518     {
2519       if (count)
2520         es_fprintf (fp, ", ");
2521       es_fprintf (fp, ngettext("%d~second", "%d~seconds", seconds), seconds);
2522     }
2523
2524   es_fputc (0, fp);
2525   if (es_fclose_snatch (fp, (void **) &str, NULL))
2526     log_fatal ("error snatching memory stream\n");
2527
2528   return str;
2529 }
2530
2531
2532 /* If FP is NULL, write TOFU_STATS status line.  If FP is not NULL
2533  * write a "tfs" record to that stream. */
2534 static void
2535 write_stats_status (estream_t fp,
2536                     enum tofu_policy policy,
2537                     unsigned long signature_count,
2538                     unsigned long signature_first_seen,
2539                     unsigned long signature_most_recent,
2540                     unsigned long encryption_count,
2541                     unsigned long encryption_first_done,
2542                     unsigned long encryption_most_recent)
2543 {
2544   const char *validity;
2545   unsigned long messages;
2546
2547   /* Use the euclidean distance (m = sqrt(a^2 + b^2)) rather then the
2548      sum of the magnitudes (m = a + b) to ensure a balance between
2549      verified signatures and encrypted messages.  */
2550   messages = sqrtu32 (signature_count * signature_count
2551                       + encryption_count * encryption_count);
2552
2553   if (messages < 1)
2554     validity = "1"; /* Key without history.  */
2555   else if (messages < 2 * BASIC_TRUST_THRESHOLD)
2556     validity = "2"; /* Key with too little history.  */
2557   else if (messages < 2 * FULL_TRUST_THRESHOLD)
2558     validity = "3"; /* Key with enough history for basic trust.  */
2559   else
2560     validity = "4"; /* Key with a lot of history.  */
2561
2562   if (fp)
2563     {
2564       es_fprintf (fp, "tfs:1:%s:%lu:%lu:%s:%lu:%lu:%lu:%lu:\n",
2565                   validity, signature_count, encryption_count,
2566                   tofu_policy_str (policy),
2567                   signature_first_seen, signature_most_recent,
2568                   encryption_first_done, encryption_most_recent);
2569     }
2570   else
2571     {
2572       write_status_printf (STATUS_TOFU_STATS,
2573                            "%s %lu %lu %s %lu %lu %lu %lu",
2574                            validity,
2575                            signature_count,
2576                            encryption_count,
2577                            tofu_policy_str (policy),
2578                            signature_first_seen,
2579                            signature_most_recent,
2580                            encryption_first_done,
2581                            encryption_most_recent);
2582     }
2583 }
2584
2585 /* Note: If OUTFP is not NULL, this function merely prints a "tfs" record
2586  * to OUTFP.  In this case USER_ID is not required.
2587  *
2588  * Returns whether the caller should call show_warning after iterating
2589  * over all user ids.
2590  */
2591 static int
2592 show_statistics (tofu_dbs_t dbs, const char *fingerprint,
2593                  const char *email, const char *user_id,
2594                  estream_t outfp, time_t now)
2595 {
2596   enum tofu_policy policy = get_policy (dbs, fingerprint, email, NULL);
2597
2598   char *fingerprint_pp;
2599   int rc;
2600   strlist_t strlist = NULL;
2601   char *err = NULL;
2602
2603   unsigned long signature_first_seen = 0;
2604   unsigned long signature_most_recent = 0;
2605   unsigned long signature_count = 0;
2606   unsigned long encryption_first_done = 0;
2607   unsigned long encryption_most_recent = 0;
2608   unsigned long encryption_count = 0;
2609
2610   int show_warning = 0;
2611
2612   (void) user_id;
2613
2614   fingerprint_pp = format_hexfingerprint (fingerprint, NULL, 0);
2615
2616   /* Get the signature stats.  */
2617   rc = gpgsql_exec_printf
2618     (dbs->db, strings_collect_cb, &strlist, &err,
2619      "select count (*), min (signatures.time), max (signatures.time)\n"
2620      " from signatures\n"
2621      " left join bindings on signatures.binding = bindings.oid\n"
2622      " where fingerprint = %Q and email = %Q;",
2623      fingerprint, email);
2624   if (rc)
2625     {
2626       log_error (_("error reading TOFU database: %s\n"), err);
2627       print_further_info ("getting signature statistics");
2628       sqlite3_free (err);
2629       rc = gpg_error (GPG_ERR_GENERAL);
2630       goto out;
2631     }
2632
2633   if (strlist)
2634     {
2635       /* We expect exactly 3 elements.  */
2636       log_assert (strlist->next);
2637       log_assert (strlist->next->next);
2638       log_assert (! strlist->next->next->next);
2639
2640       string_to_ulong (&signature_count, strlist->d, -1, __LINE__);
2641       string_to_ulong (&signature_first_seen, strlist->next->d, -1, __LINE__);
2642       string_to_ulong (&signature_most_recent,
2643                        strlist->next->next->d, -1, __LINE__);
2644
2645       free_strlist (strlist);
2646       strlist = NULL;
2647     }
2648
2649   /* Get the encryption stats.  */
2650   rc = gpgsql_exec_printf
2651     (dbs->db, strings_collect_cb, &strlist, &err,
2652      "select count (*), min (encryptions.time), max (encryptions.time)\n"
2653      " from encryptions\n"
2654      " left join bindings on encryptions.binding = bindings.oid\n"
2655      " where fingerprint = %Q and email = %Q;",
2656      fingerprint, email);
2657   if (rc)
2658     {
2659       log_error (_("error reading TOFU database: %s\n"), err);
2660       print_further_info ("getting encryption statistics");
2661       sqlite3_free (err);
2662       rc = gpg_error (GPG_ERR_GENERAL);
2663       goto out;
2664     }
2665
2666   if (strlist)
2667     {
2668       /* We expect exactly 3 elements.  */
2669       log_assert (strlist->next);
2670       log_assert (strlist->next->next);
2671       log_assert (! strlist->next->next->next);
2672
2673       string_to_ulong (&encryption_count, strlist->d, -1, __LINE__);
2674       string_to_ulong (&encryption_first_done, strlist->next->d, -1, __LINE__);
2675       string_to_ulong (&encryption_most_recent,
2676                        strlist->next->next->d, -1, __LINE__);
2677
2678       free_strlist (strlist);
2679       strlist = NULL;
2680     }
2681
2682   if (!outfp)
2683     write_status_text_and_buffer (STATUS_TOFU_USER, fingerprint,
2684                                   email, strlen (email), 0);
2685
2686   write_stats_status (outfp, policy,
2687                       signature_count,
2688                       signature_first_seen,
2689                       signature_most_recent,
2690                       encryption_count,
2691                       encryption_first_done,
2692                       encryption_most_recent);
2693
2694   if (!outfp)
2695     {
2696       estream_t fp;
2697       char *msg;
2698
2699       fp = es_fopenmem (0, "rw,samethread");
2700       if (! fp)
2701         log_fatal ("error creating memory stream: %s\n",
2702                    gpg_strerror (gpg_error_from_syserror()));
2703
2704       es_fprintf (fp, _("%s: "), email);
2705
2706       if (signature_count == 0)
2707         {
2708           es_fprintf (fp, _("Verified %ld signatures"), 0L);
2709           es_fputc ('\n', fp);
2710         }
2711       else
2712         {
2713           char *first_seen_ago_str = time_ago_str (now - signature_first_seen);
2714
2715           /* TRANSLATORS: The final %s is replaced by a string like
2716              "7 months, 1 day, 5 minutes, 0 seconds". */
2717           es_fprintf (fp,
2718                       ngettext("Verified %ld signature in the past %s",
2719                                "Verified %ld signatures in the past %s",
2720                                signature_count),
2721                       signature_count, first_seen_ago_str);
2722
2723           xfree (first_seen_ago_str);
2724         }
2725
2726       if (encryption_count == 0)
2727         {
2728           es_fprintf (fp, _(", and encrypted %ld messages"), 0L);
2729         }
2730       else
2731         {
2732           char *first_done_ago_str = time_ago_str (now - encryption_first_done);
2733
2734           /* TRANSLATORS: The final %s is replaced by a string like
2735              "7 months, 1 day, 5 minutes, 0 seconds". */
2736           es_fprintf (fp,
2737                       ngettext(", and encrypted %ld message in the past %s",
2738                                ", and encrypted %ld messages in the past %s",
2739                                encryption_count),
2740                       encryption_count, first_done_ago_str);
2741
2742           xfree (first_done_ago_str);
2743         }
2744
2745       if (opt.verbose)
2746         {
2747           es_fputs ("  ", fp);
2748           es_fputc ('(', fp);
2749           es_fprintf (fp, _("policy: %s"), tofu_policy_str (policy));
2750           es_fputs (").\n", fp);
2751         }
2752       else
2753         es_fputs (".\n", fp);
2754
2755
2756       {
2757         char *tmpmsg, *p;
2758         es_fputc (0, fp);
2759         if (es_fclose_snatch (fp, (void **) &tmpmsg, NULL))
2760           log_fatal ("error snatching memory stream\n");
2761         msg = format_text (tmpmsg, 0, 72, 80);
2762         es_free (tmpmsg);
2763
2764         /* Print a status line but suppress the trailing LF.
2765          * Spaces are not percent escaped. */
2766         if (*msg)
2767           write_status_buffer (STATUS_TOFU_STATS_LONG,
2768                                msg, strlen (msg)-1, -1);
2769
2770         /* Remove the non-breaking space markers.  */
2771         for (p=msg; *p; p++)
2772           if (*p == '~')
2773             *p = ' ';
2774       }
2775
2776       log_string (GPGRT_LOG_INFO, msg);
2777       xfree (msg);
2778
2779       if (policy == TOFU_POLICY_AUTO)
2780         {
2781           if (signature_count == 0)
2782             log_info (_("Warning: we have yet to see"
2783                         " a message signed using this key and user id!\n"));
2784           else if (signature_count == 1)
2785             log_info (_("Warning: we've only seen one message"
2786                         " signed using this key and user id!\n"));
2787
2788           if (encryption_count == 0)
2789             log_info (_("Warning: you have yet to encrypt"
2790                         " a message to this key!\n"));
2791           else if (encryption_count == 1)
2792             log_info (_("Warning: you have only encrypted"
2793                         " one message to this key!\n"));
2794
2795           /* Cf. write_stats_status  */
2796           if (sqrtu32 (encryption_count * encryption_count
2797                        + signature_count * signature_count)
2798               < 2 * BASIC_TRUST_THRESHOLD)
2799             show_warning = 1;
2800         }
2801     }
2802
2803  out:
2804   xfree (fingerprint_pp);
2805
2806   return show_warning;
2807 }
2808
2809 static void
2810 show_warning (const char *fingerprint, strlist_t user_id_list)
2811 {
2812   char *set_policy_command;
2813   char *text;
2814   char *tmpmsg;
2815
2816   set_policy_command =
2817     xasprintf ("gpg --tofu-policy bad %s", fingerprint);
2818
2819   tmpmsg = xasprintf
2820     (ngettext
2821      ("Warning: if you think you've seen more signatures "
2822       "by this key and user id, then this key might be a "
2823       "forgery!  Carefully examine the email address for small "
2824       "variations.  If the key is suspect, then use\n"
2825       "  %s\n"
2826       "to mark it as being bad.\n",
2827       "Warning: if you think you've seen more signatures "
2828       "by this key and these user ids, then this key might be a "
2829       "forgery!  Carefully examine the email addresses for small "
2830       "variations.  If the key is suspect, then use\n"
2831       "  %s\n"
2832       "to mark it as being bad.\n",
2833       strlist_length (user_id_list)),
2834      set_policy_command);
2835
2836   text = format_text (tmpmsg, 0, 72, 80);
2837   xfree (tmpmsg);
2838   log_string (GPGRT_LOG_INFO, text);
2839   xfree (text);
2840
2841   es_free (set_policy_command);
2842 }
2843
2844
2845 /* Extract the email address from a user id and normalize it.  If the
2846    user id doesn't contain an email address, then we use the whole
2847    user_id and normalize that.  The returned string must be freed.  */
2848 static char *
2849 email_from_user_id (const char *user_id)
2850 {
2851   char *email = mailbox_from_userid (user_id);
2852   if (! email)
2853     {
2854       /* Hmm, no email address was provided or we are out of core.  Just
2855          take the lower-case version of the whole user id.  It could be
2856          a hostname, for instance.  */
2857       email = ascii_strlwr (xstrdup (user_id));
2858     }
2859
2860   return email;
2861 }
2862
2863 /* Register the signature with the bindings <fingerprint, USER_ID>,
2864    for each USER_ID in USER_ID_LIST.  The fingerprint is taken from
2865    the primary key packet PK.
2866
2867    SIG_DIGEST_BIN is the binary representation of the message's
2868    digest.  SIG_DIGEST_BIN_LEN is its length.
2869
2870    SIG_TIME is the time that the signature was generated.
2871
2872    ORIGIN is a free-formed string describing the origin of the
2873    signature.  If this was from an email and the Claws MUA was used,
2874    then this should be something like: "email:claws".  If this is
2875    NULL, the default is simply "unknown".
2876
2877    If MAY_ASK is 1, then this function may interact with the user.
2878    This is necessary if there is a conflict or the binding's policy is
2879    TOFU_POLICY_ASK.
2880
2881    This function returns 0 on success and an error code if an error
2882    occurred.  */
2883 gpg_error_t
2884 tofu_register_signature (ctrl_t ctrl,
2885                          PKT_public_key *pk, strlist_t user_id_list,
2886                          const byte *sig_digest_bin, int sig_digest_bin_len,
2887                          time_t sig_time, const char *origin)
2888 {
2889   time_t now = gnupg_get_time ();
2890   gpg_error_t rc;
2891   tofu_dbs_t dbs;
2892   char *fingerprint = NULL;
2893   strlist_t user_id;
2894   char *email = NULL;
2895   char *err = NULL;
2896   char *sig_digest;
2897   unsigned long c;
2898
2899   dbs = opendbs (ctrl);
2900   if (! dbs)
2901     {
2902       rc = gpg_error (GPG_ERR_GENERAL);
2903       log_error (_("error opening TOFU database: %s\n"),
2904                  gpg_strerror (rc));
2905       return rc;
2906     }
2907
2908   /* We do a query and then an insert.  Make sure they are atomic
2909      by wrapping them in a transaction.  */
2910   rc = begin_transaction (ctrl, 0);
2911   if (rc)
2912     return rc;
2913
2914   log_assert (keyid_cmp (pk_keyid (pk), pk_main_keyid (pk)) == 0);
2915
2916   sig_digest = make_radix64_string (sig_digest_bin, sig_digest_bin_len);
2917   fingerprint = hexfingerprint (pk, NULL, 0);
2918
2919   if (! origin)
2920     /* The default origin is simply "unknown".  */
2921     origin = "unknown";
2922
2923   for (user_id = user_id_list; user_id; user_id = user_id->next)
2924     {
2925       email = email_from_user_id (user_id->d);
2926
2927       if (DBG_TRUST)
2928         log_debug ("TOFU: Registering signature %s with binding"
2929                    " <key: %s, user id: %s>\n",
2930                    sig_digest, fingerprint, email);
2931
2932       /* Make sure the binding exists and record any TOFU
2933          conflicts.  */
2934       if (get_trust (ctrl, pk, fingerprint, email, user_id->d, 0, now)
2935           == _tofu_GET_TRUST_ERROR)
2936         {
2937           rc = gpg_error (GPG_ERR_GENERAL);
2938           xfree (email);
2939           break;
2940         }
2941
2942       /* If we've already seen this signature before, then don't add
2943          it again.  */
2944       rc = gpgsql_stepx
2945         (dbs->db, &dbs->s.register_already_seen,
2946          get_single_unsigned_long_cb2, &c, &err,
2947          "select count (*)\n"
2948          " from signatures left join bindings\n"
2949          "  on signatures.binding = bindings.oid\n"
2950          " where fingerprint = ? and email = ? and sig_time = ?\n"
2951          "  and sig_digest = ?",
2952          GPGSQL_ARG_STRING, fingerprint, GPGSQL_ARG_STRING, email,
2953          GPGSQL_ARG_LONG_LONG, (long long) sig_time,
2954          GPGSQL_ARG_STRING, sig_digest,
2955          GPGSQL_ARG_END);
2956       if (rc)
2957         {
2958           log_error (_("error reading TOFU database: %s\n"), err);
2959           print_further_info ("checking existence");
2960           sqlite3_free (err);
2961           rc = gpg_error (GPG_ERR_GENERAL);
2962         }
2963       else if (c > 1)
2964         /* Duplicates!  This should not happen.  In particular,
2965            because <fingerprint, email, sig_time, sig_digest> is the
2966            primary key!  */
2967         log_debug ("SIGNATURES DB contains duplicate records"
2968                    " <key: %s, email: %s, time: 0x%lx, sig: %s,"
2969                    " origin: %s>."
2970                    "  Please report.\n",
2971                    fingerprint, email, (unsigned long) sig_time,
2972                    sig_digest, origin);
2973       else if (c == 1)
2974         {
2975           if (DBG_TRUST)
2976             log_debug ("Already observed the signature and binding"
2977                        " <key: %s, email: %s, time: 0x%lx, sig: %s,"
2978                        " origin: %s>\n",
2979                        fingerprint, email, (unsigned long) sig_time,
2980                        sig_digest, origin);
2981         }
2982       else if (opt.dry_run)
2983         {
2984           log_info ("TOFU database update skipped due to --dry-run\n");
2985         }
2986       else
2987         /* This is the first time that we've seen this signature and
2988            binding.  Record it.  */
2989         {
2990           if (DBG_TRUST)
2991             log_debug ("TOFU: Saving signature"
2992                        " <key: %s, user id: %s, sig: %s>\n",
2993                        fingerprint, email, sig_digest);
2994
2995           log_assert (c == 0);
2996
2997           rc = gpgsql_stepx
2998             (dbs->db, &dbs->s.register_insert, NULL, NULL, &err,
2999              "insert into signatures\n"
3000              " (binding, sig_digest, origin, sig_time, time)\n"
3001              " values\n"
3002              " ((select oid from bindings\n"
3003              "    where fingerprint = ? and email = ?),\n"
3004              "  ?, ?, ?, ?);",
3005              GPGSQL_ARG_STRING, fingerprint, GPGSQL_ARG_STRING, email,
3006              GPGSQL_ARG_STRING, sig_digest, GPGSQL_ARG_STRING, origin,
3007              GPGSQL_ARG_LONG_LONG, (long long) sig_time,
3008              GPGSQL_ARG_LONG_LONG, (long long) now,
3009              GPGSQL_ARG_END);
3010           if (rc)
3011             {
3012               log_error (_("error updating TOFU database: %s\n"), err);
3013               print_further_info ("insert signatures");
3014               sqlite3_free (err);
3015               rc = gpg_error (GPG_ERR_GENERAL);
3016             }
3017         }
3018
3019       xfree (email);
3020
3021       if (rc)
3022         break;
3023     }
3024
3025   if (rc)
3026     rollback_transaction (ctrl);
3027   else
3028     rc = end_transaction (ctrl, 0);
3029
3030   xfree (fingerprint);
3031   xfree (sig_digest);
3032
3033   return rc;
3034 }
3035
3036 gpg_error_t
3037 tofu_register_encryption (ctrl_t ctrl,
3038                           PKT_public_key *pk, strlist_t user_id_list,
3039                           int may_ask)
3040 {
3041   time_t now = gnupg_get_time ();
3042   gpg_error_t rc = 0;
3043   tofu_dbs_t dbs;
3044   kbnode_t kb = NULL;
3045   int free_user_id_list = 0;
3046   char *fingerprint = NULL;
3047   strlist_t user_id;
3048   char *err = NULL;
3049
3050   dbs = opendbs (ctrl);
3051   if (! dbs)
3052     {
3053       rc = gpg_error (GPG_ERR_GENERAL);
3054       log_error (_("error opening TOFU database: %s\n"),
3055                  gpg_strerror (rc));
3056       return rc;
3057     }
3058
3059   if (/* We need the key block to find the primary key.  */
3060       keyid_cmp (pk_keyid (pk), pk_main_keyid (pk)) != 0
3061       /* We need the key block to find all user ids.  */
3062       || ! user_id_list)
3063     kb = get_pubkeyblock (pk->keyid);
3064
3065   /* Make sure PK is a primary key.  */
3066   if (keyid_cmp (pk_keyid (pk), pk_main_keyid (pk)) != 0)
3067     pk = kb->pkt->pkt.public_key;
3068
3069   if (! user_id_list)
3070     {
3071       /* Use all non-revoked user ids.  Do use expired user ids.  */
3072       kbnode_t n = kb;
3073
3074       while ((n = find_next_kbnode (n, PKT_USER_ID)))
3075         {
3076           PKT_user_id *uid = n->pkt->pkt.user_id;
3077
3078           if (uid->is_revoked)
3079             continue;
3080
3081           add_to_strlist (&user_id_list, uid->name);
3082         }
3083
3084       free_user_id_list = 1;
3085
3086       if (! user_id_list)
3087         log_info (_("WARNING: Encrypting to %s, which has no"
3088                     "non-revoked user ids.\n"),
3089                   keystr (pk->keyid));
3090     }
3091
3092   fingerprint = hexfingerprint (pk, NULL, 0);
3093
3094   tofu_begin_batch_update (ctrl);
3095   tofu_resume_batch_transaction (ctrl);
3096
3097   for (user_id = user_id_list; user_id; user_id = user_id->next)
3098     {
3099       char *email = email_from_user_id (user_id->d);
3100
3101       /* Make sure the binding exists and that we recognize any
3102          conflicts.  */
3103       int tl = get_trust (ctrl, pk, fingerprint, email, user_id->d,
3104                           may_ask, now);
3105       if (tl == _tofu_GET_TRUST_ERROR)
3106         {
3107           /* An error.  */
3108           rc = gpg_error (GPG_ERR_GENERAL);
3109           xfree (email);
3110           goto die;
3111         }
3112
3113       rc = gpgsql_stepx
3114         (dbs->db, &dbs->s.register_insert, NULL, NULL, &err,
3115          "insert into encryptions\n"
3116          " (binding, time)\n"
3117          " values\n"
3118          " ((select oid from bindings\n"
3119          "    where fingerprint = ? and email = ?),\n"
3120          "  ?);",
3121          GPGSQL_ARG_STRING, fingerprint, GPGSQL_ARG_STRING, email,
3122          GPGSQL_ARG_LONG_LONG, (long long) now,
3123          GPGSQL_ARG_END);
3124       if (rc)
3125         {
3126           log_error (_("error updating TOFU database: %s\n"), err);
3127           print_further_info ("insert encryption");
3128           sqlite3_free (err);
3129           rc = gpg_error (GPG_ERR_GENERAL);
3130         }
3131
3132       xfree (email);
3133     }
3134
3135  die:
3136   tofu_end_batch_update (ctrl);
3137
3138   if (kb)
3139     release_kbnode (kb);
3140
3141   if (free_user_id_list)
3142     free_strlist (user_id_list);
3143
3144   xfree (fingerprint);
3145
3146   return rc;
3147 }
3148
3149
3150 /* Combine a trust level returned from the TOFU trust model with a
3151    trust level returned by the PGP trust model.  This is primarily of
3152    interest when the trust model is tofu+pgp (TM_TOFU_PGP).
3153
3154    This function ors together the upper bits (the values not covered
3155    by TRUST_MASK, i.e., TRUST_FLAG_REVOKED, etc.).  */
3156 int
3157 tofu_wot_trust_combine (int tofu_base, int wot_base)
3158 {
3159   int tofu = tofu_base & TRUST_MASK;
3160   int wot = wot_base & TRUST_MASK;
3161   int upper = (tofu_base & ~TRUST_MASK) | (wot_base & ~TRUST_MASK);
3162
3163   log_assert (tofu == TRUST_UNKNOWN
3164               || tofu == TRUST_EXPIRED
3165               || tofu == TRUST_UNDEFINED
3166               || tofu == TRUST_NEVER
3167               || tofu == TRUST_MARGINAL
3168               || tofu == TRUST_FULLY
3169               || tofu == TRUST_ULTIMATE);
3170   log_assert (wot == TRUST_UNKNOWN
3171               || wot == TRUST_EXPIRED
3172               || wot == TRUST_UNDEFINED
3173               || wot == TRUST_NEVER
3174               || wot == TRUST_MARGINAL
3175               || wot == TRUST_FULLY
3176               || wot == TRUST_ULTIMATE);
3177
3178   /* We first consider negative trust policys.  These trump positive
3179      trust policies.  */
3180   if (tofu == TRUST_NEVER || wot == TRUST_NEVER)
3181     /* TRUST_NEVER trumps everything else.  */
3182     return upper | TRUST_NEVER;
3183   if (tofu == TRUST_EXPIRED || wot == TRUST_EXPIRED)
3184     /* TRUST_EXPIRED trumps everything but TRUST_NEVER.  */
3185     return upper | TRUST_EXPIRED;
3186
3187   /* Now we only have positive or neutral trust policies.  We take
3188      the max.  */
3189   if (tofu == TRUST_ULTIMATE)
3190     return upper | TRUST_ULTIMATE | TRUST_FLAG_TOFU_BASED;
3191   if (wot == TRUST_ULTIMATE)
3192     return upper | TRUST_ULTIMATE;
3193
3194   if (tofu == TRUST_FULLY)
3195     return upper | TRUST_FULLY | TRUST_FLAG_TOFU_BASED;
3196   if (wot == TRUST_FULLY)
3197     return upper | TRUST_FULLY;
3198
3199   if (tofu == TRUST_MARGINAL)
3200     return upper | TRUST_MARGINAL | TRUST_FLAG_TOFU_BASED;
3201   if (wot == TRUST_MARGINAL)
3202     return upper | TRUST_MARGINAL;
3203
3204   if (tofu == TRUST_UNDEFINED)
3205     return upper | TRUST_UNDEFINED | TRUST_FLAG_TOFU_BASED;
3206   if (wot == TRUST_UNDEFINED)
3207     return upper | TRUST_UNDEFINED;
3208
3209   return upper | TRUST_UNKNOWN;
3210 }
3211
3212
3213 /* Write a "tfs" record for a --with-colons listing.  */
3214 gpg_error_t
3215 tofu_write_tfs_record (ctrl_t ctrl, estream_t fp,
3216                        PKT_public_key *pk, const char *user_id)
3217 {
3218   time_t now = gnupg_get_time ();
3219   gpg_error_t err;
3220   tofu_dbs_t dbs;
3221   char *fingerprint;
3222   char *email;
3223
3224   if (!*user_id)
3225     return 0;  /* No TOFU stats possible for an empty ID.  */
3226
3227   dbs = opendbs (ctrl);
3228   if (!dbs)
3229     {
3230       err = gpg_error (GPG_ERR_GENERAL);
3231       log_error (_("error opening TOFU database: %s\n"), gpg_strerror (err));
3232       return err;
3233     }
3234
3235   fingerprint = hexfingerprint (pk, NULL, 0);
3236   email = email_from_user_id (user_id);
3237
3238   show_statistics (dbs, fingerprint, email, user_id, fp, now);
3239
3240   xfree (email);
3241   xfree (fingerprint);
3242   return 0;
3243 }
3244
3245
3246 /* Return the validity (TRUST_NEVER, etc.) of the bindings
3247    <FINGERPRINT, USER_ID>, for each USER_ID in USER_ID_LIST.  If
3248    USER_ID_LIST->FLAG is set, then the id is considered to be expired.
3249
3250    PK is the primary key packet.
3251
3252    If MAY_ASK is 1 and the policy is TOFU_POLICY_ASK, then the user
3253    will be prompted to choose a policy.  If MAY_ASK is 0 and the
3254    policy is TOFU_POLICY_ASK, then TRUST_UNKNOWN is returned.
3255
3256    Returns TRUST_UNDEFINED if an error occurs.  */
3257 int
3258 tofu_get_validity (ctrl_t ctrl, PKT_public_key *pk, strlist_t user_id_list,
3259                    int may_ask)
3260 {
3261   time_t now = gnupg_get_time ();
3262   tofu_dbs_t dbs;
3263   char *fingerprint = NULL;
3264   strlist_t user_id;
3265   int trust_level = TRUST_UNKNOWN;
3266   int bindings = 0;
3267   int bindings_valid = 0;
3268   int need_warning = 0;
3269
3270   dbs = opendbs (ctrl);
3271   if (! dbs)
3272     {
3273       log_error (_("error opening TOFU database: %s\n"),
3274                  gpg_strerror (GPG_ERR_GENERAL));
3275       return TRUST_UNDEFINED;
3276     }
3277
3278   fingerprint = hexfingerprint (pk, NULL, 0);
3279
3280   tofu_begin_batch_update (ctrl);
3281   /* Start the batch transaction now.  */
3282   tofu_resume_batch_transaction (ctrl);
3283
3284   for (user_id = user_id_list; user_id; user_id = user_id->next, bindings ++)
3285     {
3286       char *email = email_from_user_id (user_id->d);
3287
3288       /* Always call get_trust to make sure the binding is
3289          registered.  */
3290       int tl = get_trust (ctrl, pk, fingerprint, email, user_id->d,
3291                           may_ask, now);
3292       if (tl == _tofu_GET_TRUST_ERROR)
3293         {
3294           /* An error.  */
3295           trust_level = TRUST_UNDEFINED;
3296           xfree (email);
3297           goto die;
3298         }
3299
3300       if (DBG_TRUST)
3301         log_debug ("TOFU: validity for <key: %s, user id: %s>: %s%s.\n",
3302                    fingerprint, email,
3303                    trust_value_to_string (tl),
3304                    user_id->flags ? " (but expired)" : "");
3305
3306       if (user_id->flags)
3307         tl = TRUST_EXPIRED;
3308
3309       if (tl != TRUST_EXPIRED)
3310         bindings_valid ++;
3311
3312       if (may_ask && tl != TRUST_ULTIMATE && tl != TRUST_EXPIRED)
3313         need_warning |=
3314           show_statistics (dbs, fingerprint, email, user_id->d, NULL, now);
3315
3316       if (tl == TRUST_NEVER)
3317         trust_level = TRUST_NEVER;
3318       else if (tl == TRUST_EXPIRED)
3319         /* Ignore expired bindings in the trust calculation.  */
3320         ;
3321       else if (tl > trust_level)
3322         {
3323           /* The expected values: */
3324           log_assert (tl == TRUST_UNKNOWN || tl == TRUST_UNDEFINED
3325                       || tl == TRUST_MARGINAL || tl == TRUST_FULLY
3326                       || tl == TRUST_ULTIMATE);
3327
3328           /* We assume the following ordering:  */
3329           log_assert (TRUST_UNKNOWN < TRUST_UNDEFINED);
3330           log_assert (TRUST_UNDEFINED < TRUST_MARGINAL);
3331           log_assert (TRUST_MARGINAL < TRUST_FULLY);
3332           log_assert (TRUST_FULLY < TRUST_ULTIMATE);
3333
3334           trust_level = tl;
3335         }
3336
3337       xfree (email);
3338     }
3339
3340   if (need_warning)
3341     show_warning (fingerprint, user_id_list);
3342
3343  die:
3344   tofu_end_batch_update (ctrl);
3345
3346   xfree (fingerprint);
3347
3348   if (bindings_valid == 0)
3349     {
3350       if (DBG_TRUST)
3351         log_debug ("no (of %d) valid bindings."
3352                    "  Can't get TOFU validity for this set of user ids.\n",
3353                    bindings);
3354       return TRUST_NEVER;
3355     }
3356
3357   return trust_level;
3358 }
3359
3360 /* Set the policy for all non-revoked user ids in the keyblock KB to
3361    POLICY.
3362
3363    If no key is available with the specified key id, then this
3364    function returns GPG_ERR_NO_PUBKEY.
3365
3366    Returns 0 on success and an error code otherwise.  */
3367 gpg_error_t
3368 tofu_set_policy (ctrl_t ctrl, kbnode_t kb, enum tofu_policy policy)
3369 {
3370   gpg_error_t err;
3371   time_t now = gnupg_get_time ();
3372   tofu_dbs_t dbs;
3373   PKT_public_key *pk;
3374   char *fingerprint = NULL;
3375
3376   log_assert (kb->pkt->pkttype == PKT_PUBLIC_KEY);
3377   pk = kb->pkt->pkt.public_key;
3378
3379   dbs = opendbs (ctrl);
3380   if (! dbs)
3381     {
3382       log_error (_("error opening TOFU database: %s\n"),
3383                  gpg_strerror (GPG_ERR_GENERAL));
3384       return gpg_error (GPG_ERR_GENERAL);
3385     }
3386
3387   if (DBG_TRUST)
3388     log_debug ("Setting TOFU policy for %s to %s\n",
3389                keystr (pk->keyid), tofu_policy_str (policy));
3390   if (keyid_cmp (pk_main_keyid (pk), pk_keyid (pk)) != 0)
3391     log_bug ("%s: Passed a subkey, but expecting a primary key.\n", __func__);
3392
3393   fingerprint = hexfingerprint (pk, NULL, 0);
3394
3395   begin_transaction (ctrl, 0);
3396
3397   for (; kb; kb = kb->next)
3398     {
3399       PKT_user_id *user_id;
3400       char *email;
3401
3402       if (kb->pkt->pkttype != PKT_USER_ID)
3403         continue;
3404
3405       user_id = kb->pkt->pkt.user_id;
3406       if (user_id->is_revoked)
3407         /* Skip revoked user ids.  (Don't skip expired user ids, the
3408            expiry can be changed.)  */
3409         continue;
3410
3411       email = email_from_user_id (user_id->name);
3412
3413       err = record_binding (dbs, fingerprint, email, user_id->name,
3414                             policy, NULL, 1, now);
3415       if (err)
3416         {
3417           log_error (_("error setting policy for key %s, user id \"%s\": %s"),
3418                      fingerprint, email, gpg_strerror (err));
3419           xfree (email);
3420           break;
3421         }
3422
3423       xfree (email);
3424     }
3425
3426   if (err)
3427     rollback_transaction (ctrl);
3428   else
3429     end_transaction (ctrl, 0);
3430
3431   xfree (fingerprint);
3432   return err;
3433 }
3434
3435 /* Set the TOFU policy for all non-revoked user ids in the KEY with
3436    the key id KEYID to POLICY.
3437
3438    If no key is available with the specified key id, then this
3439    function returns GPG_ERR_NO_PUBKEY.
3440
3441    Returns 0 on success and an error code otherwise.  */
3442 gpg_error_t
3443 tofu_set_policy_by_keyid (ctrl_t ctrl, u32 *keyid, enum tofu_policy policy)
3444 {
3445   kbnode_t keyblock = get_pubkeyblock (keyid);
3446   if (! keyblock)
3447     return gpg_error (GPG_ERR_NO_PUBKEY);
3448
3449   return tofu_set_policy (ctrl, keyblock, policy);
3450 }
3451
3452 /* Return the TOFU policy for the specified binding in *POLICY.  If no
3453    policy has been set for the binding, sets *POLICY to
3454    TOFU_POLICY_NONE.
3455
3456    PK is a primary public key and USER_ID is a user id.
3457
3458    Returns 0 on success and an error code otherwise.  */
3459 gpg_error_t
3460 tofu_get_policy (ctrl_t ctrl, PKT_public_key *pk, PKT_user_id *user_id,
3461                  enum tofu_policy *policy)
3462 {
3463   tofu_dbs_t dbs;
3464   char *fingerprint;
3465   char *email;
3466
3467   /* Make sure PK is a primary key.  */
3468   log_assert (pk->main_keyid[0] == pk->keyid[0]
3469               && pk->main_keyid[1] == pk->keyid[1]);
3470
3471   dbs = opendbs (ctrl);
3472   if (! dbs)
3473     {
3474       log_error (_("error opening TOFU database: %s\n"),
3475                  gpg_strerror (GPG_ERR_GENERAL));
3476       return gpg_error (GPG_ERR_GENERAL);
3477     }
3478
3479   fingerprint = hexfingerprint (pk, NULL, 0);
3480
3481   email = email_from_user_id (user_id->name);
3482
3483   *policy = get_policy (dbs, fingerprint, email, NULL);
3484
3485   xfree (email);
3486   xfree (fingerprint);
3487   if (*policy == _tofu_GET_POLICY_ERROR)
3488     return gpg_error (GPG_ERR_GENERAL);
3489   return 0;
3490 }