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