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