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