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