g10: If an sqlite operation fails, map the error code to GPG_ERR_GENERAL
[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       if (! may_ask)
2135         {
2136           trust_level = TRUST_UNDEFINED;
2137           goto out;
2138         }
2139
2140       break;
2141
2142     case TOFU_POLICY_NONE:
2143       /* The binding is new, we need to check for conflicts.  Case #3
2144        * below.  */
2145       break;
2146
2147     case _tofu_GET_POLICY_ERROR:
2148       trust_level = _tofu_GET_TRUST_ERROR;
2149       goto out;
2150
2151     default:
2152       log_bug ("%s: Impossible value for policy (%d)\n", __func__, policy);
2153     }
2154
2155
2156   /* We get here if:
2157    *
2158    *   1. The saved policy is auto and the default policy is ask
2159    *      (get_policy() == TOFU_POLICY_AUTO
2160    *       && opt.tofu_default_policy == TOFU_POLICY_ASK)
2161    *
2162    *   2. The saved policy is ask (either last time the user selected
2163    *      accept once or reject once or there was a conflict and this
2164    *      binding's policy was changed from auto to ask)
2165    *      (policy == TOFU_POLICY_ASK), or,
2166    *
2167    *   3. We don't have a saved policy (policy == TOFU_POLICY_NONE)
2168    *      (need to check for a conflict).
2169    *
2170    * In summary: POLICY is ask or none.
2171    */
2172
2173   /* Before continuing, see if the key is signed by an ultimately
2174    * trusted key.  */
2175   {
2176     int fingerprint_raw_len = strlen (fingerprint) / 2;
2177     char fingerprint_raw[fingerprint_raw_len];
2178     int len = 0;
2179     int is_signed_by_utk = 0;
2180
2181     if (fingerprint_raw_len != 20
2182         || ((len = hex2bin (fingerprint,
2183                             fingerprint_raw, fingerprint_raw_len))
2184             != strlen (fingerprint)))
2185       {
2186         if (DBG_TRUST)
2187           log_debug ("TOFU: Bad fingerprint: %s (len: %zd, parsed: %d)\n",
2188                      fingerprint, strlen (fingerprint), len);
2189       }
2190     else
2191       {
2192         int lookup_err;
2193         kbnode_t kb;
2194
2195         lookup_err = get_pubkey_byfprint (NULL, &kb,
2196                                           fingerprint_raw,
2197                                           fingerprint_raw_len);
2198         if (lookup_err)
2199           {
2200             if (DBG_TRUST)
2201               log_debug ("TOFU: Looking up %s: %s\n",
2202                          fingerprint, gpg_strerror (lookup_err));
2203           }
2204         else
2205           {
2206             is_signed_by_utk = signed_by_utk (kb);
2207             release_kbnode (kb);
2208           }
2209       }
2210
2211     if (is_signed_by_utk)
2212       {
2213         if (record_binding (dbs, fingerprint, email, user_id,
2214                             TOFU_POLICY_GOOD, NULL, 0, now) != 0)
2215           {
2216             log_error (_("error setting TOFU binding's trust level"
2217                          " to %s\n"), "good");
2218             trust_level = _tofu_GET_TRUST_ERROR;
2219           }
2220         else
2221           trust_level = TRUST_FULLY;
2222
2223         goto out;
2224       }
2225   }
2226
2227
2228   /* Look for conflicts.  This is needed in all 3 cases.  */
2229   conflict_set = build_conflict_set (dbs, fingerprint, email);
2230   conflict_set_count = strlist_length (conflict_set);
2231   if (conflict_set_count == 0)
2232     {
2233       /* We should always at least have the current binding.  */
2234       trust_level = _tofu_GET_TRUST_ERROR;
2235       goto out;
2236     }
2237
2238   if (conflict_set_count == 1
2239       && (conflict_set->flags & BINDING_NEW)
2240       && opt.tofu_default_policy != TOFU_POLICY_ASK)
2241     {
2242       /* We've never observed a binding with this email address and we
2243        * have a default policy, which is not to ask the user.  */
2244
2245       /* If we've seen this binding, then we've seen this email and
2246        * policy couldn't possibly be TOFU_POLICY_NONE.  */
2247       log_assert (policy == TOFU_POLICY_NONE);
2248
2249       if (DBG_TRUST)
2250         log_debug ("TOFU: New binding <key: %s, user id: %s>, no conflict.\n",
2251                    fingerprint, email);
2252
2253       if (record_binding (dbs, fingerprint, email, user_id,
2254                           TOFU_POLICY_AUTO, NULL, 0, now) != 0)
2255         {
2256           log_error (_("error setting TOFU binding's trust level to %s\n"),
2257                        "auto");
2258           trust_level = _tofu_GET_TRUST_ERROR;
2259           goto out;
2260         }
2261
2262       trust_level = tofu_policy_to_trust_level (TOFU_POLICY_AUTO);
2263       goto out;
2264     }
2265
2266   if (conflict_set_count == 1
2267       && (conflict_set->flags & BINDING_CONFLICT))
2268     {
2269       /* No known conflicts now, but there was a conflict.  This means
2270        * at somepoint, there was a conflict and we changed this
2271        * binding's policy to ask and set the conflicting key.  The
2272        * conflict can go away if there is not a cross sig between the
2273        * two keys.  In this case, just silently clear the conflict and
2274        * reset the policy to auto.  */
2275
2276       log_assert (policy == TOFU_POLICY_ASK);
2277
2278       if (DBG_TRUST)
2279         log_debug ("TOFU: binding <key: %s, user id: %s> had a conflict, but it's been resolved (probably via  cross sig).\n",
2280                    fingerprint, email);
2281
2282       if (record_binding (dbs, fingerprint, email, user_id,
2283                           TOFU_POLICY_AUTO, NULL, 0, now) != 0)
2284         log_error (_("error setting TOFU binding's trust level to %s\n"),
2285                    "auto");
2286
2287       trust_level = tofu_policy_to_trust_level (TOFU_POLICY_AUTO);
2288       goto out;
2289     }
2290
2291   /* We have a conflict.  Mark any conflicting bindings that have an
2292    * automatic policy as now requiring confirmation.  Note: we delay
2293    * this until after we ask for confirmation so that when the current
2294    * policy is printed, it is correct.  */
2295   change_conflicting_to_ask = 1;
2296
2297   if (! may_ask)
2298     {
2299       /* We can only get here in the third case (no saved policy) and
2300        * if there is a conflict.  (If the policy was ask (cases #1 and
2301        * #2) and we weren't allowed to ask, we'd have already exited).  */
2302       log_assert (policy == TOFU_POLICY_NONE);
2303
2304       if (record_binding (dbs, fingerprint, email, user_id,
2305                           TOFU_POLICY_ASK,
2306                           conflict_set && conflict_set->next
2307                           ? conflict_set->next->d : NULL,
2308                           0, now) != 0)
2309         log_error (_("error setting TOFU binding's trust level to %s\n"),
2310                    "ask");
2311
2312       trust_level = TRUST_UNDEFINED;
2313       goto out;
2314     }
2315
2316   /* We can't be in a normal transaction in ask_about_binding.  */
2317   end_transaction (ctrl, 0);
2318   in_transaction = 0;
2319
2320   /* If we get here, we need to ask the user about the binding.  */
2321   ask_about_binding (ctrl,
2322                      &policy,
2323                      &trust_level,
2324                      conflict_set,
2325                      fingerprint,
2326                      email,
2327                      user_id,
2328                      now);
2329
2330  out:
2331
2332   if (change_conflicting_to_ask)
2333     {
2334       /* Mark any conflicting bindings that have an automatic policy as
2335        * now requiring confirmation.  */
2336
2337       if (! in_transaction)
2338         {
2339           begin_transaction (ctrl, 0);
2340           in_transaction = 1;
2341         }
2342
2343       /* If we weren't allowed to ask, also update this key as
2344        * conflicting with itself.  */
2345       for (iter = may_ask ? conflict_set->next : conflict_set;
2346            iter; iter = iter->next)
2347         {
2348           rc = gpgsql_exec_printf
2349             (dbs->db, NULL, NULL, &sqerr,
2350              "update bindings set policy = %d, conflict = %Q"
2351              " where email = %Q and fingerprint = %Q and policy = %d;",
2352              TOFU_POLICY_ASK, fingerprint,
2353              email, iter->d, TOFU_POLICY_AUTO);
2354           if (rc)
2355             {
2356               log_error (_("error changing TOFU policy: %s\n"), sqerr);
2357               print_further_info ("binding: <key: %s, user id: %s>",
2358                                   fingerprint, user_id);
2359               sqlite3_free (sqerr);
2360               sqerr = NULL;
2361               rc = gpg_error (GPG_ERR_GENERAL);
2362             }
2363           else if (DBG_TRUST)
2364             log_debug ("Set %s to conflict with %s\n",
2365                        iter->d, fingerprint);
2366         }
2367     }
2368
2369   if (in_transaction)
2370     end_transaction (ctrl, 0);
2371
2372   free_strlist (conflict_set);
2373
2374   return trust_level;
2375 }
2376
2377
2378 /* Return a malloced string of the form
2379  *    "7 months, 1 day, 5 minutes, 0 seconds"
2380  * The caller should replace all '~' in the returned string by a space
2381  * and also free the returned string.
2382  *
2383  * This is actually a bad hack which may not work correctly with all
2384  * languages.
2385  */
2386 static char *
2387 time_ago_str (long long int t)
2388 {
2389   estream_t fp;
2390   int years = 0;
2391   int months = 0;
2392   int days = 0;
2393   int hours = 0;
2394   int minutes = 0;
2395   int seconds = 0;
2396
2397   /* The number of units that we've printed so far.  */
2398   int count = 0;
2399   /* The first unit that we printed (year = 0, month = 1,
2400      etc.).  */
2401   int first = -1;
2402   /* The current unit.  */
2403   int i = 0;
2404
2405   char *str;
2406
2407   /* It would be nice to use a macro to do this, but gettext
2408      works on the unpreprocessed code.  */
2409 #define MIN_SECS (60)
2410 #define HOUR_SECS (60 * MIN_SECS)
2411 #define DAY_SECS (24 * HOUR_SECS)
2412 #define MONTH_SECS (30 * DAY_SECS)
2413 #define YEAR_SECS (365 * DAY_SECS)
2414
2415   if (t > YEAR_SECS)
2416     {
2417       years = t / YEAR_SECS;
2418       t -= years * YEAR_SECS;
2419     }
2420   if (t > MONTH_SECS)
2421     {
2422       months = t / MONTH_SECS;
2423       t -= months * MONTH_SECS;
2424     }
2425   if (t > DAY_SECS)
2426     {
2427       days = t / DAY_SECS;
2428       t -= days * DAY_SECS;
2429     }
2430   if (t > HOUR_SECS)
2431     {
2432       hours = t / HOUR_SECS;
2433       t -= hours * HOUR_SECS;
2434     }
2435   if (t > MIN_SECS)
2436     {
2437       minutes = t / MIN_SECS;
2438       t -= minutes * MIN_SECS;
2439     }
2440   seconds = t;
2441
2442 #undef MIN_SECS
2443 #undef HOUR_SECS
2444 #undef DAY_SECS
2445 #undef MONTH_SECS
2446 #undef YEAR_SECS
2447
2448   fp = es_fopenmem (0, "rw,samethread");
2449   if (! fp)
2450     log_fatal ("error creating memory stream: %s\n",
2451                gpg_strerror (gpg_error_from_syserror()));
2452
2453   if (years)
2454     {
2455       /* TRANSLATORS: The tilde ('~') is used here to indicate a
2456        * non-breakable space  */
2457       es_fprintf (fp, ngettext("%d~year", "%d~years", years), years);
2458       count ++;
2459       first = i;
2460     }
2461   i ++;
2462   if ((first == -1 || i - first <= 3) && count <= 0 && months)
2463     {
2464       if (count)
2465         es_fprintf (fp, ", ");
2466       es_fprintf (fp, ngettext("%d~month", "%d~months", months), months);
2467       count ++;
2468       first = i;
2469     }
2470   i ++;
2471   if ((first == -1 || i - first <= 3) && count <= 0 && days)
2472     {
2473       if (count)
2474         es_fprintf (fp, ", ");
2475       es_fprintf (fp, ngettext("%d~day", "%d~days", days), days);
2476       count ++;
2477       first = i;
2478     }
2479   i ++;
2480   if ((first == -1 || i - first <= 3) && count <= 0 && hours)
2481     {
2482       if (count)
2483         es_fprintf (fp, ", ");
2484       es_fprintf (fp, ngettext("%d~hour", "%d~hours", hours), hours);
2485       count ++;
2486       first = i;
2487     }
2488   i ++;
2489   if ((first == -1 || i - first <= 3) && count <= 0 && minutes)
2490     {
2491       if (count)
2492         es_fprintf (fp, ", ");
2493       es_fprintf (fp, ngettext("%d~minute", "%d~minutes", minutes), minutes);
2494       count ++;
2495       first = i;
2496     }
2497   i ++;
2498   if ((first == -1 || i - first <= 3) && count <= 0)
2499     {
2500       if (count)
2501         es_fprintf (fp, ", ");
2502       es_fprintf (fp, ngettext("%d~second", "%d~seconds", seconds), seconds);
2503     }
2504
2505   es_fputc (0, fp);
2506   if (es_fclose_snatch (fp, (void **) &str, NULL))
2507     log_fatal ("error snatching memory stream\n");
2508
2509   return str;
2510 }
2511
2512
2513 /* If FP is NULL, write TOFU_STATS status line.  If FP is not NULL
2514  * write a "tfs" record to that stream. */
2515 static void
2516 write_stats_status (estream_t fp,
2517                     enum tofu_policy policy,
2518                     unsigned long signature_count,
2519                     unsigned long signature_first_seen,
2520                     unsigned long signature_most_recent,
2521                     unsigned long encryption_count,
2522                     unsigned long encryption_first_done,
2523                     unsigned long encryption_most_recent)
2524 {
2525   const char *validity;
2526   unsigned long messages;
2527
2528   /* Use the euclidean distance (m = sqrt(a^2 + b^2)) rather then the
2529      sum of the magnitudes (m = a + b) to ensure a balance between
2530      verified signatures and encrypted messages.  */
2531   messages = sqrtu32 (signature_count * signature_count
2532                       + encryption_count * encryption_count);
2533
2534   if (messages < 1)
2535     validity = "1"; /* Key without history.  */
2536   else if (messages < 2 * BASIC_TRUST_THRESHOLD)
2537     validity = "2"; /* Key with too little history.  */
2538   else if (messages < 2 * FULL_TRUST_THRESHOLD)
2539     validity = "3"; /* Key with enough history for basic trust.  */
2540   else
2541     validity = "4"; /* Key with a lot of history.  */
2542
2543   if (fp)
2544     {
2545       es_fprintf (fp, "tfs:1:%s:%lu:%lu:%s:%lu:%lu:%lu:%lu:\n",
2546                   validity, signature_count, encryption_count,
2547                   tofu_policy_str (policy),
2548                   signature_first_seen, signature_most_recent,
2549                   encryption_first_done, encryption_most_recent);
2550     }
2551   else
2552     {
2553       write_status_printf (STATUS_TOFU_STATS,
2554                            "%s %lu %lu %s %lu %lu %lu %lu",
2555                            validity,
2556                            signature_count,
2557                            encryption_count,
2558                            tofu_policy_str (policy),
2559                            signature_first_seen,
2560                            signature_most_recent,
2561                            encryption_first_done,
2562                            encryption_most_recent);
2563     }
2564 }
2565
2566 /* Note: If OUTFP is not NULL, this function merely prints a "tfs" record
2567  * to OUTFP.  In this case USER_ID is not required.
2568  *
2569  * Returns whether the caller should call show_warning after iterating
2570  * over all user ids.
2571  */
2572 static int
2573 show_statistics (tofu_dbs_t dbs, const char *fingerprint,
2574                  const char *email, const char *user_id,
2575                  estream_t outfp, time_t now)
2576 {
2577   enum tofu_policy policy = get_policy (dbs, fingerprint, email, NULL);
2578
2579   char *fingerprint_pp;
2580   int rc;
2581   strlist_t strlist = NULL;
2582   char *err = NULL;
2583
2584   unsigned long signature_first_seen = 0;
2585   unsigned long signature_most_recent = 0;
2586   unsigned long signature_count = 0;
2587   unsigned long encryption_first_done = 0;
2588   unsigned long encryption_most_recent = 0;
2589   unsigned long encryption_count = 0;
2590
2591   int show_warning = 0;
2592
2593   (void) user_id;
2594
2595   fingerprint_pp = format_hexfingerprint (fingerprint, NULL, 0);
2596
2597   /* Get the signature stats.  */
2598   rc = gpgsql_exec_printf
2599     (dbs->db, strings_collect_cb, &strlist, &err,
2600      "select count (*), min (signatures.time), max (signatures.time)\n"
2601      " from signatures\n"
2602      " left join bindings on signatures.binding = bindings.oid\n"
2603      " where fingerprint = %Q and email = %Q;",
2604      fingerprint, email);
2605   if (rc)
2606     {
2607       log_error (_("error reading TOFU database: %s\n"), err);
2608       print_further_info ("getting signature statistics");
2609       sqlite3_free (err);
2610       rc = gpg_error (GPG_ERR_GENERAL);
2611       goto out;
2612     }
2613
2614   if (strlist)
2615     {
2616       /* We expect exactly 3 elements.  */
2617       log_assert (strlist->next);
2618       log_assert (strlist->next->next);
2619       log_assert (! strlist->next->next->next);
2620
2621       string_to_ulong (&signature_count, strlist->d, -1, __LINE__);
2622       string_to_ulong (&signature_first_seen, strlist->next->d, -1, __LINE__);
2623       string_to_ulong (&signature_most_recent,
2624                        strlist->next->next->d, -1, __LINE__);
2625
2626       free_strlist (strlist);
2627       strlist = NULL;
2628     }
2629
2630   /* Get the encryption stats.  */
2631   rc = gpgsql_exec_printf
2632     (dbs->db, strings_collect_cb, &strlist, &err,
2633      "select count (*), min (encryptions.time), max (encryptions.time)\n"
2634      " from encryptions\n"
2635      " left join bindings on encryptions.binding = bindings.oid\n"
2636      " where fingerprint = %Q and email = %Q;",
2637      fingerprint, email);
2638   if (rc)
2639     {
2640       log_error (_("error reading TOFU database: %s\n"), err);
2641       print_further_info ("getting encryption statistics");
2642       sqlite3_free (err);
2643       rc = gpg_error (GPG_ERR_GENERAL);
2644       goto out;
2645     }
2646
2647   if (strlist)
2648     {
2649       /* We expect exactly 3 elements.  */
2650       log_assert (strlist->next);
2651       log_assert (strlist->next->next);
2652       log_assert (! strlist->next->next->next);
2653
2654       string_to_ulong (&encryption_count, strlist->d, -1, __LINE__);
2655       string_to_ulong (&encryption_first_done, strlist->next->d, -1, __LINE__);
2656       string_to_ulong (&encryption_most_recent,
2657                        strlist->next->next->d, -1, __LINE__);
2658
2659       free_strlist (strlist);
2660       strlist = NULL;
2661     }
2662
2663   if (!outfp)
2664     write_status_text_and_buffer (STATUS_TOFU_USER, fingerprint,
2665                                   email, strlen (email), 0);
2666
2667   write_stats_status (outfp, policy,
2668                       signature_count,
2669                       signature_first_seen,
2670                       signature_most_recent,
2671                       encryption_count,
2672                       encryption_first_done,
2673                       encryption_most_recent);
2674
2675   if (!outfp)
2676     {
2677       estream_t fp;
2678       char *msg;
2679
2680       fp = es_fopenmem (0, "rw,samethread");
2681       if (! fp)
2682         log_fatal ("error creating memory stream: %s\n",
2683                    gpg_strerror (gpg_error_from_syserror()));
2684
2685       es_fprintf (fp, _("%s: "), email);
2686
2687       if (signature_count == 0)
2688         {
2689           es_fprintf (fp, _("Verified %ld signatures"), 0L);
2690           es_fputc ('\n', fp);
2691         }
2692       else
2693         {
2694           char *first_seen_ago_str = time_ago_str (now - signature_first_seen);
2695
2696           /* TRANSLATORS: The final %s is replaced by a string like
2697              "7 months, 1 day, 5 minutes, 0 seconds". */
2698           es_fprintf (fp,
2699                       ngettext("Verified %ld signature in the past %s",
2700                                "Verified %ld signatures in the past %s",
2701                                signature_count),
2702                       signature_count, first_seen_ago_str);
2703
2704           xfree (first_seen_ago_str);
2705         }
2706
2707       if (encryption_count == 0)
2708         {
2709           es_fprintf (fp, _(", and encrypted %ld messages"), 0L);
2710         }
2711       else
2712         {
2713           char *first_done_ago_str = time_ago_str (now - encryption_first_done);
2714
2715           /* TRANSLATORS: The final %s is replaced by a string like
2716              "7 months, 1 day, 5 minutes, 0 seconds". */
2717           es_fprintf (fp,
2718                       ngettext(", and encrypted %ld message in the past %s",
2719                                ", and encrypted %ld messages in the past %s",
2720                                encryption_count),
2721                       encryption_count, first_done_ago_str);
2722
2723           xfree (first_done_ago_str);
2724         }
2725
2726       if (opt.verbose)
2727         {
2728           es_fputs ("  ", fp);
2729           es_fputc ('(', fp);
2730           es_fprintf (fp, _("policy: %s"), tofu_policy_str (policy));
2731           es_fputs (").\n", fp);
2732         }
2733       else
2734         es_fputs (".\n", fp);
2735
2736
2737       {
2738         char *tmpmsg, *p;
2739         es_fputc (0, fp);
2740         if (es_fclose_snatch (fp, (void **) &tmpmsg, NULL))
2741           log_fatal ("error snatching memory stream\n");
2742         msg = format_text (tmpmsg, 0, 72, 80);
2743         es_free (tmpmsg);
2744
2745         /* Print a status line but suppress the trailing LF.
2746          * Spaces are not percent escaped. */
2747         if (*msg)
2748           write_status_buffer (STATUS_TOFU_STATS_LONG,
2749                                msg, strlen (msg)-1, -1);
2750
2751         /* Remove the non-breaking space markers.  */
2752         for (p=msg; *p; p++)
2753           if (*p == '~')
2754             *p = ' ';
2755       }
2756
2757       log_string (GPGRT_LOG_INFO, msg);
2758       xfree (msg);
2759
2760       if (policy == TOFU_POLICY_AUTO)
2761         {
2762           if (signature_count == 0)
2763             log_info (_("Warning: we have yet to see"
2764                         " a message signed using this key and user id!\n"));
2765           else if (signature_count == 1)
2766             log_info (_("Warning: we've only seen one message"
2767                         " signed using this key and user id!\n"));
2768
2769           if (encryption_count == 0)
2770             log_info (_("Warning: you have yet to encrypt"
2771                         " a message to this key!\n"));
2772           else if (encryption_count == 1)
2773             log_info (_("Warning: you have only encrypted"
2774                         " one message to this key!\n"));
2775
2776           /* Cf. write_stats_status  */
2777           if (sqrtu32 (encryption_count * encryption_count
2778                        + signature_count * signature_count)
2779               < 2 * BASIC_TRUST_THRESHOLD)
2780             show_warning = 1;
2781         }
2782     }
2783
2784  out:
2785   xfree (fingerprint_pp);
2786
2787   return show_warning;
2788 }
2789
2790 static void
2791 show_warning (const char *fingerprint, strlist_t user_id_list)
2792 {
2793   char *set_policy_command;
2794   char *text;
2795   char *tmpmsg;
2796
2797   set_policy_command =
2798     xasprintf ("gpg --tofu-policy bad %s", fingerprint);
2799
2800   tmpmsg = xasprintf
2801     (ngettext
2802      ("Warning: if you think you've seen more signatures "
2803       "by this key and user id, then this key might be a "
2804       "forgery!  Carefully examine the email address for small "
2805       "variations.  If the key is suspect, then use\n"
2806       "  %s\n"
2807       "to mark it as being bad.\n",
2808       "Warning: if you think you've seen more signatures "
2809       "by this key and these user ids, then this key might be a "
2810       "forgery!  Carefully examine the email addresses for small "
2811       "variations.  If the key is suspect, then use\n"
2812       "  %s\n"
2813       "to mark it as being bad.\n",
2814       strlist_length (user_id_list)),
2815      set_policy_command);
2816
2817   text = format_text (tmpmsg, 0, 72, 80);
2818   xfree (tmpmsg);
2819   log_string (GPGRT_LOG_INFO, text);
2820   xfree (text);
2821
2822   es_free (set_policy_command);
2823 }
2824
2825
2826 /* Extract the email address from a user id and normalize it.  If the
2827    user id doesn't contain an email address, then we use the whole
2828    user_id and normalize that.  The returned string must be freed.  */
2829 static char *
2830 email_from_user_id (const char *user_id)
2831 {
2832   char *email = mailbox_from_userid (user_id);
2833   if (! email)
2834     {
2835       /* Hmm, no email address was provided or we are out of core.  Just
2836          take the lower-case version of the whole user id.  It could be
2837          a hostname, for instance.  */
2838       email = ascii_strlwr (xstrdup (user_id));
2839     }
2840
2841   return email;
2842 }
2843
2844 /* Register the signature with the bindings <fingerprint, USER_ID>,
2845    for each USER_ID in USER_ID_LIST.  The fingerprint is taken from
2846    the primary key packet PK.
2847
2848    SIG_DIGEST_BIN is the binary representation of the message's
2849    digest.  SIG_DIGEST_BIN_LEN is its length.
2850
2851    SIG_TIME is the time that the signature was generated.
2852
2853    ORIGIN is a free-formed string describing the origin of the
2854    signature.  If this was from an email and the Claws MUA was used,
2855    then this should be something like: "email:claws".  If this is
2856    NULL, the default is simply "unknown".
2857
2858    If MAY_ASK is 1, then this function may interact with the user.
2859    This is necessary if there is a conflict or the binding's policy is
2860    TOFU_POLICY_ASK.
2861
2862    This function returns 0 on success and an error code if an error
2863    occurred.  */
2864 gpg_error_t
2865 tofu_register_signature (ctrl_t ctrl,
2866                          PKT_public_key *pk, strlist_t user_id_list,
2867                          const byte *sig_digest_bin, int sig_digest_bin_len,
2868                          time_t sig_time, const char *origin)
2869 {
2870   time_t now = gnupg_get_time ();
2871   gpg_error_t rc;
2872   tofu_dbs_t dbs;
2873   char *fingerprint = NULL;
2874   strlist_t user_id;
2875   char *email = NULL;
2876   char *err = NULL;
2877   char *sig_digest;
2878   unsigned long c;
2879
2880   dbs = opendbs (ctrl);
2881   if (! dbs)
2882     {
2883       rc = gpg_error (GPG_ERR_GENERAL);
2884       log_error (_("error opening TOFU database: %s\n"),
2885                  gpg_strerror (rc));
2886       return rc;
2887     }
2888
2889   /* We do a query and then an insert.  Make sure they are atomic
2890      by wrapping them in a transaction.  */
2891   rc = begin_transaction (ctrl, 0);
2892   if (rc)
2893     return rc;
2894
2895   log_assert (keyid_cmp (pk_keyid (pk), pk_main_keyid (pk)) == 0);
2896
2897   sig_digest = make_radix64_string (sig_digest_bin, sig_digest_bin_len);
2898   fingerprint = hexfingerprint (pk, NULL, 0);
2899
2900   if (! origin)
2901     /* The default origin is simply "unknown".  */
2902     origin = "unknown";
2903
2904   for (user_id = user_id_list; user_id; user_id = user_id->next)
2905     {
2906       email = email_from_user_id (user_id->d);
2907
2908       if (DBG_TRUST)
2909         log_debug ("TOFU: Registering signature %s with binding"
2910                    " <key: %s, user id: %s>\n",
2911                    sig_digest, fingerprint, email);
2912
2913       /* Make sure the binding exists and record any TOFU
2914          conflicts.  */
2915       if (get_trust (ctrl, pk, fingerprint, email, user_id->d, 0, now)
2916           == _tofu_GET_TRUST_ERROR)
2917         {
2918           rc = gpg_error (GPG_ERR_GENERAL);
2919           xfree (email);
2920           break;
2921         }
2922
2923       /* If we've already seen this signature before, then don't add
2924          it again.  */
2925       rc = gpgsql_stepx
2926         (dbs->db, &dbs->s.register_already_seen,
2927          get_single_unsigned_long_cb2, &c, &err,
2928          "select count (*)\n"
2929          " from signatures left join bindings\n"
2930          "  on signatures.binding = bindings.oid\n"
2931          " where fingerprint = ? and email = ? and sig_time = ?\n"
2932          "  and sig_digest = ?",
2933          GPGSQL_ARG_STRING, fingerprint, GPGSQL_ARG_STRING, email,
2934          GPGSQL_ARG_LONG_LONG, (long long) sig_time,
2935          GPGSQL_ARG_STRING, sig_digest,
2936          GPGSQL_ARG_END);
2937       if (rc)
2938         {
2939           log_error (_("error reading TOFU database: %s\n"), err);
2940           print_further_info ("checking existence");
2941           sqlite3_free (err);
2942           rc = gpg_error (GPG_ERR_GENERAL);
2943         }
2944       else if (c > 1)
2945         /* Duplicates!  This should not happen.  In particular,
2946            because <fingerprint, email, sig_time, sig_digest> is the
2947            primary key!  */
2948         log_debug ("SIGNATURES DB contains duplicate records"
2949                    " <key: %s, email: %s, time: 0x%lx, sig: %s,"
2950                    " origin: %s>."
2951                    "  Please report.\n",
2952                    fingerprint, email, (unsigned long) sig_time,
2953                    sig_digest, origin);
2954       else if (c == 1)
2955         {
2956           if (DBG_TRUST)
2957             log_debug ("Already observed the signature and binding"
2958                        " <key: %s, email: %s, time: 0x%lx, sig: %s,"
2959                        " origin: %s>\n",
2960                        fingerprint, email, (unsigned long) sig_time,
2961                        sig_digest, origin);
2962         }
2963       else if (opt.dry_run)
2964         {
2965           log_info ("TOFU database update skipped due to --dry-run\n");
2966         }
2967       else
2968         /* This is the first time that we've seen this signature and
2969            binding.  Record it.  */
2970         {
2971           if (DBG_TRUST)
2972             log_debug ("TOFU: Saving signature"
2973                        " <key: %s, user id: %s, sig: %s>\n",
2974                        fingerprint, email, sig_digest);
2975
2976           log_assert (c == 0);
2977
2978           rc = gpgsql_stepx
2979             (dbs->db, &dbs->s.register_insert, NULL, NULL, &err,
2980              "insert into signatures\n"
2981              " (binding, sig_digest, origin, sig_time, time)\n"
2982              " values\n"
2983              " ((select oid from bindings\n"
2984              "    where fingerprint = ? and email = ?),\n"
2985              "  ?, ?, ?, ?);",
2986              GPGSQL_ARG_STRING, fingerprint, GPGSQL_ARG_STRING, email,
2987              GPGSQL_ARG_STRING, sig_digest, GPGSQL_ARG_STRING, origin,
2988              GPGSQL_ARG_LONG_LONG, (long long) sig_time,
2989              GPGSQL_ARG_LONG_LONG, (long long) now,
2990              GPGSQL_ARG_END);
2991           if (rc)
2992             {
2993               log_error (_("error updating TOFU database: %s\n"), err);
2994               print_further_info ("insert signatures");
2995               sqlite3_free (err);
2996               rc = gpg_error (GPG_ERR_GENERAL);
2997             }
2998         }
2999
3000       xfree (email);
3001
3002       if (rc)
3003         break;
3004     }
3005
3006   if (rc)
3007     rollback_transaction (ctrl);
3008   else
3009     rc = end_transaction (ctrl, 0);
3010
3011   xfree (fingerprint);
3012   xfree (sig_digest);
3013
3014   return rc;
3015 }
3016
3017 gpg_error_t
3018 tofu_register_encryption (ctrl_t ctrl,
3019                           PKT_public_key *pk, strlist_t user_id_list,
3020                           int may_ask)
3021 {
3022   time_t now = gnupg_get_time ();
3023   gpg_error_t rc = 0;
3024   tofu_dbs_t dbs;
3025   kbnode_t kb = NULL;
3026   int free_user_id_list = 0;
3027   char *fingerprint = NULL;
3028   strlist_t user_id;
3029   char *err = NULL;
3030
3031   dbs = opendbs (ctrl);
3032   if (! dbs)
3033     {
3034       rc = gpg_error (GPG_ERR_GENERAL);
3035       log_error (_("error opening TOFU database: %s\n"),
3036                  gpg_strerror (rc));
3037       return rc;
3038     }
3039
3040   if (/* We need the key block to find the primary key.  */
3041       keyid_cmp (pk_keyid (pk), pk_main_keyid (pk)) != 0
3042       /* We need the key block to find all user ids.  */
3043       || ! user_id_list)
3044     kb = get_pubkeyblock (pk->keyid);
3045
3046   /* Make sure PK is a primary key.  */
3047   if (keyid_cmp (pk_keyid (pk), pk_main_keyid (pk)) != 0)
3048     pk = kb->pkt->pkt.public_key;
3049
3050   if (! user_id_list)
3051     {
3052       /* Use all non-revoked user ids.  Do use expired user ids.  */
3053       kbnode_t n = kb;
3054
3055       while ((n = find_next_kbnode (n, PKT_USER_ID)))
3056         {
3057           PKT_user_id *uid = n->pkt->pkt.user_id;
3058
3059           if (uid->is_revoked)
3060             continue;
3061
3062           add_to_strlist (&user_id_list, uid->name);
3063         }
3064
3065       free_user_id_list = 1;
3066
3067       if (! user_id_list)
3068         log_info (_("WARNING: Encrypting to %s, which has no"
3069                     "non-revoked user ids.\n"),
3070                   keystr (pk->keyid));
3071     }
3072
3073   fingerprint = hexfingerprint (pk, NULL, 0);
3074
3075   tofu_begin_batch_update (ctrl);
3076   tofu_resume_batch_transaction (ctrl);
3077
3078   for (user_id = user_id_list; user_id; user_id = user_id->next)
3079     {
3080       char *email = email_from_user_id (user_id->d);
3081
3082       /* Make sure the binding exists and that we recognize any
3083          conflicts.  */
3084       int tl = get_trust (ctrl, pk, fingerprint, email, user_id->d,
3085                           may_ask, now);
3086       if (tl == _tofu_GET_TRUST_ERROR)
3087         {
3088           /* An error.  */
3089           rc = gpg_error (GPG_ERR_GENERAL);
3090           xfree (email);
3091           goto die;
3092         }
3093
3094       rc = gpgsql_stepx
3095         (dbs->db, &dbs->s.register_insert, NULL, NULL, &err,
3096          "insert into encryptions\n"
3097          " (binding, time)\n"
3098          " values\n"
3099          " ((select oid from bindings\n"
3100          "    where fingerprint = ? and email = ?),\n"
3101          "  ?);",
3102          GPGSQL_ARG_STRING, fingerprint, GPGSQL_ARG_STRING, email,
3103          GPGSQL_ARG_LONG_LONG, (long long) now,
3104          GPGSQL_ARG_END);
3105       if (rc)
3106         {
3107           log_error (_("error updating TOFU database: %s\n"), err);
3108           print_further_info ("insert encryption");
3109           sqlite3_free (err);
3110           rc = gpg_error (GPG_ERR_GENERAL);
3111         }
3112
3113       xfree (email);
3114     }
3115
3116  die:
3117   tofu_end_batch_update (ctrl);
3118
3119   if (kb)
3120     release_kbnode (kb);
3121
3122   if (free_user_id_list)
3123     free_strlist (user_id_list);
3124
3125   xfree (fingerprint);
3126
3127   return rc;
3128 }
3129
3130
3131 /* Combine a trust level returned from the TOFU trust model with a
3132    trust level returned by the PGP trust model.  This is primarily of
3133    interest when the trust model is tofu+pgp (TM_TOFU_PGP).
3134
3135    This function ors together the upper bits (the values not covered
3136    by TRUST_MASK, i.e., TRUST_FLAG_REVOKED, etc.).  */
3137 int
3138 tofu_wot_trust_combine (int tofu_base, int wot_base)
3139 {
3140   int tofu = tofu_base & TRUST_MASK;
3141   int wot = wot_base & TRUST_MASK;
3142   int upper = (tofu_base & ~TRUST_MASK) | (wot_base & ~TRUST_MASK);
3143
3144   log_assert (tofu == TRUST_UNKNOWN
3145               || tofu == TRUST_EXPIRED
3146               || tofu == TRUST_UNDEFINED
3147               || tofu == TRUST_NEVER
3148               || tofu == TRUST_MARGINAL
3149               || tofu == TRUST_FULLY
3150               || tofu == TRUST_ULTIMATE);
3151   log_assert (wot == TRUST_UNKNOWN
3152               || wot == TRUST_EXPIRED
3153               || wot == TRUST_UNDEFINED
3154               || wot == TRUST_NEVER
3155               || wot == TRUST_MARGINAL
3156               || wot == TRUST_FULLY
3157               || wot == TRUST_ULTIMATE);
3158
3159   /* We first consider negative trust policys.  These trump positive
3160      trust policies.  */
3161   if (tofu == TRUST_NEVER || wot == TRUST_NEVER)
3162     /* TRUST_NEVER trumps everything else.  */
3163     return upper | TRUST_NEVER;
3164   if (tofu == TRUST_EXPIRED || wot == TRUST_EXPIRED)
3165     /* TRUST_EXPIRED trumps everything but TRUST_NEVER.  */
3166     return upper | TRUST_EXPIRED;
3167
3168   /* Now we only have positive or neutral trust policies.  We take
3169      the max.  */
3170   if (tofu == TRUST_ULTIMATE)
3171     return upper | TRUST_ULTIMATE | TRUST_FLAG_TOFU_BASED;
3172   if (wot == TRUST_ULTIMATE)
3173     return upper | TRUST_ULTIMATE;
3174
3175   if (tofu == TRUST_FULLY)
3176     return upper | TRUST_FULLY | TRUST_FLAG_TOFU_BASED;
3177   if (wot == TRUST_FULLY)
3178     return upper | TRUST_FULLY;
3179
3180   if (tofu == TRUST_MARGINAL)
3181     return upper | TRUST_MARGINAL | TRUST_FLAG_TOFU_BASED;
3182   if (wot == TRUST_MARGINAL)
3183     return upper | TRUST_MARGINAL;
3184
3185   if (tofu == TRUST_UNDEFINED)
3186     return upper | TRUST_UNDEFINED | TRUST_FLAG_TOFU_BASED;
3187   if (wot == TRUST_UNDEFINED)
3188     return upper | TRUST_UNDEFINED;
3189
3190   return upper | TRUST_UNKNOWN;
3191 }
3192
3193
3194 /* Write a "tfs" record for a --with-colons listing.  */
3195 gpg_error_t
3196 tofu_write_tfs_record (ctrl_t ctrl, estream_t fp,
3197                        PKT_public_key *pk, const char *user_id)
3198 {
3199   time_t now = gnupg_get_time ();
3200   gpg_error_t err;
3201   tofu_dbs_t dbs;
3202   char *fingerprint;
3203   char *email;
3204
3205   if (!*user_id)
3206     return 0;  /* No TOFU stats possible for an empty ID.  */
3207
3208   dbs = opendbs (ctrl);
3209   if (!dbs)
3210     {
3211       err = gpg_error (GPG_ERR_GENERAL);
3212       log_error (_("error opening TOFU database: %s\n"), gpg_strerror (err));
3213       return err;
3214     }
3215
3216   fingerprint = hexfingerprint (pk, NULL, 0);
3217   email = email_from_user_id (user_id);
3218
3219   show_statistics (dbs, fingerprint, email, user_id, fp, now);
3220
3221   xfree (email);
3222   xfree (fingerprint);
3223   return 0;
3224 }
3225
3226
3227 /* Return the validity (TRUST_NEVER, etc.) of the bindings
3228    <FINGERPRINT, USER_ID>, for each USER_ID in USER_ID_LIST.  If
3229    USER_ID_LIST->FLAG is set, then the id is considered to be expired.
3230
3231    PK is the primary key packet.
3232
3233    If MAY_ASK is 1 and the policy is TOFU_POLICY_ASK, then the user
3234    will be prompted to choose a policy.  If MAY_ASK is 0 and the
3235    policy is TOFU_POLICY_ASK, then TRUST_UNKNOWN is returned.
3236
3237    Returns TRUST_UNDEFINED if an error occurs.  */
3238 int
3239 tofu_get_validity (ctrl_t ctrl, PKT_public_key *pk, strlist_t user_id_list,
3240                    int may_ask)
3241 {
3242   time_t now = gnupg_get_time ();
3243   tofu_dbs_t dbs;
3244   char *fingerprint = NULL;
3245   strlist_t user_id;
3246   int trust_level = TRUST_UNKNOWN;
3247   int bindings = 0;
3248   int bindings_valid = 0;
3249   int need_warning = 0;
3250
3251   dbs = opendbs (ctrl);
3252   if (! dbs)
3253     {
3254       log_error (_("error opening TOFU database: %s\n"),
3255                  gpg_strerror (GPG_ERR_GENERAL));
3256       return TRUST_UNDEFINED;
3257     }
3258
3259   fingerprint = hexfingerprint (pk, NULL, 0);
3260
3261   tofu_begin_batch_update (ctrl);
3262   /* Start the batch transaction now.  */
3263   tofu_resume_batch_transaction (ctrl);
3264
3265   for (user_id = user_id_list; user_id; user_id = user_id->next, bindings ++)
3266     {
3267       char *email = email_from_user_id (user_id->d);
3268
3269       /* Always call get_trust to make sure the binding is
3270          registered.  */
3271       int tl = get_trust (ctrl, pk, fingerprint, email, user_id->d,
3272                           may_ask, now);
3273       if (tl == _tofu_GET_TRUST_ERROR)
3274         {
3275           /* An error.  */
3276           trust_level = TRUST_UNDEFINED;
3277           xfree (email);
3278           goto die;
3279         }
3280
3281       if (DBG_TRUST)
3282         log_debug ("TOFU: validity for <key: %s, user id: %s>: %s%s.\n",
3283                    fingerprint, email,
3284                    trust_value_to_string (tl),
3285                    user_id->flags ? " (but expired)" : "");
3286
3287       if (user_id->flags)
3288         tl = TRUST_EXPIRED;
3289
3290       if (tl != TRUST_EXPIRED)
3291         bindings_valid ++;
3292
3293       if (may_ask && tl != TRUST_ULTIMATE && tl != TRUST_EXPIRED)
3294         need_warning |=
3295           show_statistics (dbs, fingerprint, email, user_id->d, NULL, now);
3296
3297       if (tl == TRUST_NEVER)
3298         trust_level = TRUST_NEVER;
3299       else if (tl == TRUST_EXPIRED)
3300         /* Ignore expired bindings in the trust calculation.  */
3301         ;
3302       else if (tl > trust_level)
3303         {
3304           /* The expected values: */
3305           log_assert (tl == TRUST_UNKNOWN || tl == TRUST_UNDEFINED
3306                       || tl == TRUST_MARGINAL || tl == TRUST_FULLY
3307                       || tl == TRUST_ULTIMATE);
3308
3309           /* We assume the following ordering:  */
3310           log_assert (TRUST_UNKNOWN < TRUST_UNDEFINED);
3311           log_assert (TRUST_UNDEFINED < TRUST_MARGINAL);
3312           log_assert (TRUST_MARGINAL < TRUST_FULLY);
3313           log_assert (TRUST_FULLY < TRUST_ULTIMATE);
3314
3315           trust_level = tl;
3316         }
3317
3318       xfree (email);
3319     }
3320
3321   if (need_warning)
3322     show_warning (fingerprint, user_id_list);
3323
3324  die:
3325   tofu_end_batch_update (ctrl);
3326
3327   xfree (fingerprint);
3328
3329   if (bindings_valid == 0)
3330     {
3331       if (DBG_TRUST)
3332         log_debug ("no (of %d) valid bindings."
3333                    "  Can't get TOFU validity for this set of user ids.\n",
3334                    bindings);
3335       return TRUST_NEVER;
3336     }
3337
3338   return trust_level;
3339 }
3340
3341 /* Set the policy for all non-revoked user ids in the keyblock KB to
3342    POLICY.
3343
3344    If no key is available with the specified key id, then this
3345    function returns GPG_ERR_NO_PUBKEY.
3346
3347    Returns 0 on success and an error code otherwise.  */
3348 gpg_error_t
3349 tofu_set_policy (ctrl_t ctrl, kbnode_t kb, enum tofu_policy policy)
3350 {
3351   gpg_error_t err;
3352   time_t now = gnupg_get_time ();
3353   tofu_dbs_t dbs;
3354   PKT_public_key *pk;
3355   char *fingerprint = NULL;
3356
3357   log_assert (kb->pkt->pkttype == PKT_PUBLIC_KEY);
3358   pk = kb->pkt->pkt.public_key;
3359
3360   dbs = opendbs (ctrl);
3361   if (! dbs)
3362     {
3363       log_error (_("error opening TOFU database: %s\n"),
3364                  gpg_strerror (GPG_ERR_GENERAL));
3365       return gpg_error (GPG_ERR_GENERAL);
3366     }
3367
3368   if (DBG_TRUST)
3369     log_debug ("Setting TOFU policy for %s to %s\n",
3370                keystr (pk->keyid), tofu_policy_str (policy));
3371   if (keyid_cmp (pk_main_keyid (pk), pk_keyid (pk)) != 0)
3372     log_bug ("%s: Passed a subkey, but expecting a primary key.\n", __func__);
3373
3374   fingerprint = hexfingerprint (pk, NULL, 0);
3375
3376   begin_transaction (ctrl, 0);
3377
3378   for (; kb; kb = kb->next)
3379     {
3380       PKT_user_id *user_id;
3381       char *email;
3382
3383       if (kb->pkt->pkttype != PKT_USER_ID)
3384         continue;
3385
3386       user_id = kb->pkt->pkt.user_id;
3387       if (user_id->is_revoked)
3388         /* Skip revoked user ids.  (Don't skip expired user ids, the
3389            expiry can be changed.)  */
3390         continue;
3391
3392       email = email_from_user_id (user_id->name);
3393
3394       err = record_binding (dbs, fingerprint, email, user_id->name,
3395                             policy, NULL, 1, now);
3396       if (err)
3397         {
3398           log_error (_("error setting policy for key %s, user id \"%s\": %s"),
3399                      fingerprint, email, gpg_strerror (err));
3400           xfree (email);
3401           break;
3402         }
3403
3404       xfree (email);
3405     }
3406
3407   if (err)
3408     rollback_transaction (ctrl);
3409   else
3410     end_transaction (ctrl, 0);
3411
3412   xfree (fingerprint);
3413   return err;
3414 }
3415
3416 /* Set the TOFU policy for all non-revoked user ids in the KEY with
3417    the key id KEYID to POLICY.
3418
3419    If no key is available with the specified key id, then this
3420    function returns GPG_ERR_NO_PUBKEY.
3421
3422    Returns 0 on success and an error code otherwise.  */
3423 gpg_error_t
3424 tofu_set_policy_by_keyid (ctrl_t ctrl, u32 *keyid, enum tofu_policy policy)
3425 {
3426   kbnode_t keyblock = get_pubkeyblock (keyid);
3427   if (! keyblock)
3428     return gpg_error (GPG_ERR_NO_PUBKEY);
3429
3430   return tofu_set_policy (ctrl, keyblock, policy);
3431 }
3432
3433 /* Return the TOFU policy for the specified binding in *POLICY.  If no
3434    policy has been set for the binding, sets *POLICY to
3435    TOFU_POLICY_NONE.
3436
3437    PK is a primary public key and USER_ID is a user id.
3438
3439    Returns 0 on success and an error code otherwise.  */
3440 gpg_error_t
3441 tofu_get_policy (ctrl_t ctrl, PKT_public_key *pk, PKT_user_id *user_id,
3442                  enum tofu_policy *policy)
3443 {
3444   tofu_dbs_t dbs;
3445   char *fingerprint;
3446   char *email;
3447
3448   /* Make sure PK is a primary key.  */
3449   log_assert (pk->main_keyid[0] == pk->keyid[0]
3450               && pk->main_keyid[1] == pk->keyid[1]);
3451
3452   dbs = opendbs (ctrl);
3453   if (! dbs)
3454     {
3455       log_error (_("error opening TOFU database: %s\n"),
3456                  gpg_strerror (GPG_ERR_GENERAL));
3457       return gpg_error (GPG_ERR_GENERAL);
3458     }
3459
3460   fingerprint = hexfingerprint (pk, NULL, 0);
3461
3462   email = email_from_user_id (user_id->name);
3463
3464   *policy = get_policy (dbs, fingerprint, email, NULL);
3465
3466   xfree (email);
3467   xfree (fingerprint);
3468   if (*policy == _tofu_GET_POLICY_ERROR)
3469     return gpg_error (GPG_ERR_GENERAL);
3470   return 0;
3471 }