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