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