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