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