g10: Add missing static qualifier.
[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_AUTO, 0, now) != 0)
2089               {
2090                 log_error (_("error setting TOFU binding's trust level"
2091                              " to %s\n"), "auto");
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 rather then the sum of the magnitudes
2518      to ensure a balance between verified signatures and encrypted
2519      messages.  */
2520   messages = sqrtu32 (signature_count) + sqrtu32 (encryption_count);
2521
2522   if (messages < 1)
2523     validity = "1"; /* Key without history.  */
2524   else if (messages < sqrtu32 (2 * BASIC_TRUST_THRESHOLD))
2525     validity = "2"; /* Key with too little history.  */
2526   else if (messages < sqrtu32 (2 * FULL_TRUST_THRESHOLD))
2527     validity = "3"; /* Key with enough history for basic trust.  */
2528   else
2529     validity = "4"; /* Key with a lot of history.  */
2530
2531   if (fp)
2532     {
2533       es_fprintf (fp, "tfs:1:%s:%lu:%lu:%s:%lu:%lu:%lu:%lu:\n",
2534                   validity, signature_count, encryption_count,
2535                   tofu_policy_str (policy),
2536                   signature_first_seen, signature_most_recent,
2537                   encryption_first_done, encryption_most_recent);
2538     }
2539   else
2540     {
2541       write_status_printf (STATUS_TOFU_STATS,
2542                            "%s %lu %lu %s %lu %lu %lu %lu",
2543                            validity,
2544                            signature_count,
2545                            encryption_count,
2546                            tofu_policy_str (policy),
2547                            signature_first_seen,
2548                            signature_most_recent,
2549                            encryption_first_done,
2550                            encryption_most_recent);
2551     }
2552 }
2553
2554 /* Note: If OUTFP is not NULL, this function merely prints a "tfs" record
2555  * to OUTFP.  In this case USER_ID is not required.
2556  *
2557  * Returns whether the caller should call show_warning after iterating
2558  * over all user ids.
2559  */
2560 static int
2561 show_statistics (tofu_dbs_t dbs, const char *fingerprint,
2562                  const char *email, const char *user_id,
2563                  estream_t outfp, time_t now)
2564 {
2565   enum tofu_policy policy = get_policy (dbs, fingerprint, email, NULL);
2566
2567   char *fingerprint_pp;
2568   int rc;
2569   strlist_t strlist = NULL;
2570   char *err = NULL;
2571
2572   unsigned long signature_first_seen = 0;
2573   unsigned long signature_most_recent = 0;
2574   unsigned long signature_count = 0;
2575   unsigned long encryption_first_done = 0;
2576   unsigned long encryption_most_recent = 0;
2577   unsigned long encryption_count = 0;
2578
2579   int show_warning = 0;
2580
2581   (void) user_id;
2582
2583   fingerprint_pp = format_hexfingerprint (fingerprint, NULL, 0);
2584
2585   /* Get the signature stats.  */
2586   rc = gpgsql_exec_printf
2587     (dbs->db, strings_collect_cb, &strlist, &err,
2588      "select count (*), min (signatures.time), max (signatures.time)\n"
2589      " from signatures\n"
2590      " left join bindings on signatures.binding = bindings.oid\n"
2591      " where fingerprint = %Q and email = %Q;",
2592      fingerprint, email);
2593   if (rc)
2594     {
2595       log_error (_("error reading TOFU database: %s\n"), err);
2596       print_further_info ("getting statistics");
2597       sqlite3_free (err);
2598       goto out;
2599     }
2600
2601   if (strlist)
2602     {
2603       log_assert (strlist->next);
2604       log_assert (strlist->next->next);
2605       log_assert (! strlist->next->next->next);
2606
2607       string_to_ulong (&signature_count, strlist->d, -1, __LINE__);
2608       string_to_ulong (&signature_first_seen, strlist->next->d, -1, __LINE__);
2609       string_to_ulong (&signature_most_recent,
2610                        strlist->next->next->d, -1, __LINE__);
2611
2612       free_strlist (strlist);
2613       strlist = NULL;
2614     }
2615
2616   /* Get the encryption stats.  */
2617   rc = gpgsql_exec_printf
2618     (dbs->db, strings_collect_cb, &strlist, &err,
2619      "select count (*), min (encryptions.time), max (encryptions.time)\n"
2620      " from encryptions\n"
2621      " left join bindings on encryptions.binding = bindings.oid\n"
2622      " where fingerprint = %Q and email = %Q;",
2623      fingerprint, email);
2624   if (rc)
2625     {
2626       log_error (_("error reading TOFU database: %s\n"), err);
2627       print_further_info ("getting statistics");
2628       sqlite3_free (err);
2629       goto out;
2630     }
2631
2632   if (strlist)
2633     {
2634       log_assert (strlist->next);
2635       log_assert (strlist->next->next);
2636       log_assert (! strlist->next->next->next);
2637
2638       string_to_ulong (&encryption_count, strlist->d, -1, __LINE__);
2639       string_to_ulong (&encryption_first_done, strlist->next->d, -1, __LINE__);
2640       string_to_ulong (&encryption_most_recent,
2641                        strlist->next->next->d, -1, __LINE__);
2642
2643       free_strlist (strlist);
2644       strlist = NULL;
2645     }
2646
2647   if (!outfp)
2648     write_status_text_and_buffer (STATUS_TOFU_USER, fingerprint,
2649                                   email, strlen (email), 0);
2650
2651   write_stats_status (outfp, policy,
2652                       signature_count,
2653                       signature_first_seen,
2654                       signature_most_recent,
2655                       encryption_count,
2656                       encryption_first_done,
2657                       encryption_most_recent);
2658
2659   if (!outfp)
2660     {
2661       estream_t fp;
2662       char *msg;
2663
2664       fp = es_fopenmem (0, "rw,samethread");
2665       if (! fp)
2666         log_fatal ("error creating memory stream: %s\n",
2667                    gpg_strerror (gpg_error_from_syserror()));
2668
2669       es_fprintf (fp, _("%s: "), email);
2670
2671       if (signature_count == 0)
2672         {
2673           es_fprintf (fp, _("Verified %ld signatures"), 0L);
2674           es_fputc ('\n', fp);
2675         }
2676       else
2677         {
2678           char *first_seen_ago_str = time_ago_str (now - signature_first_seen);
2679
2680           /* TRANSLATORS: The final %s is replaced by a string like
2681              "7 months, 1 day, 5 minutes, 0 seconds". */
2682           es_fprintf (fp,
2683                       ngettext("Verified %ld signature in the past %s",
2684                                "Verified %ld signatures in the past %s",
2685                                signature_count),
2686                       signature_count, first_seen_ago_str);
2687
2688           xfree (first_seen_ago_str);
2689         }
2690
2691       if (encryption_count == 0)
2692         {
2693           es_fprintf (fp, _(", and encrypted %ld messages"), 0L);
2694         }
2695       else
2696         {
2697           char *first_done_ago_str = time_ago_str (now - encryption_first_done);
2698
2699           /* TRANSLATORS: The final %s is replaced by a string like
2700              "7 months, 1 day, 5 minutes, 0 seconds". */
2701           es_fprintf (fp,
2702                       ngettext(", and encrypted %ld message in the past %s",
2703                                ", and encrypted %ld messages in the past %s",
2704                                encryption_count),
2705                       encryption_count, first_done_ago_str);
2706
2707           xfree (first_done_ago_str);
2708         }
2709
2710       if (opt.verbose)
2711         {
2712           es_fputs ("  ", fp);
2713           es_fputc ('(', fp);
2714           es_fprintf (fp, _("policy: %s"), tofu_policy_str (policy));
2715           es_fputs (").\n", fp);
2716         }
2717       else
2718         es_fputs (".\n", fp);
2719
2720
2721       {
2722         char *tmpmsg, *p;
2723         es_fputc (0, fp);
2724         if (es_fclose_snatch (fp, (void **) &tmpmsg, NULL))
2725           log_fatal ("error snatching memory stream\n");
2726         msg = format_text (tmpmsg, 0, 72, 80);
2727         es_free (tmpmsg);
2728
2729         /* Print a status line but suppress the trailing LF.
2730          * Spaces are not percent escaped. */
2731         if (*msg)
2732           write_status_buffer (STATUS_TOFU_STATS_LONG,
2733                                msg, strlen (msg)-1, -1);
2734
2735         /* Remove the non-breaking space markers.  */
2736         for (p=msg; *p; p++)
2737           if (*p == '~')
2738             *p = ' ';
2739       }
2740
2741       log_string (GPGRT_LOG_INFO, msg);
2742       xfree (msg);
2743
2744       if (policy == TOFU_POLICY_AUTO)
2745         {
2746           if (signature_count == 0)
2747             log_info (_("Warning: we have yet to see"
2748                         " a message signed using this key and user id!\n"));
2749           else if (signature_count == 1)
2750             log_info (_("Warning: we've only seen one message"
2751                         " signed using this key and user id!\n"));
2752
2753           if (encryption_count == 0)
2754             log_info (_("Warning: you have yet to encrypt"
2755                         " a message to this key and user id!\n"));
2756           else if (encryption_count == 1)
2757             log_info (_("Warning: you have only encrypted"
2758                         "  one message to this key and user id!\n"));
2759
2760           /* Cf. write_stats_status  */
2761           if (sqrtu32 (encryption_count) + sqrtu32 (signature_count)
2762               < sqrtu32 (2 * BASIC_TRUST_THRESHOLD))
2763             show_warning = 1;
2764         }
2765     }
2766
2767  out:
2768   xfree (fingerprint_pp);
2769
2770   return show_warning;
2771 }
2772
2773 static void
2774 show_warning (const char *fingerprint, strlist_t user_id_list)
2775 {
2776   char *set_policy_command;
2777   char *text;
2778   char *tmpmsg;
2779
2780   set_policy_command =
2781     xasprintf ("gpg --tofu-policy bad %s", fingerprint);
2782
2783   tmpmsg = xasprintf
2784     (ngettext
2785      ("Warning: if you think you've seen more signatures "
2786       "by this key and user id, then this key might be a "
2787       "forgery!  Carefully examine the email address for small "
2788       "variations.  If the key is suspect, then use\n"
2789       "  %s\n"
2790       "to mark it as being bad.\n",
2791       "Warning: if you think you've seen more signatures "
2792       "by this key and these user ids, then this key might be a "
2793       "forgery!  Carefully examine the email addresses for small "
2794       "variations.  If the key is suspect, then use\n"
2795       "  %s\n"
2796       "to mark it as being bad.\n",
2797       strlist_length (user_id_list)),
2798      set_policy_command);
2799
2800   text = format_text (tmpmsg, 0, 72, 80);
2801   xfree (tmpmsg);
2802   log_string (GPGRT_LOG_INFO, text);
2803   xfree (text);
2804
2805   es_free (set_policy_command);
2806 }
2807
2808
2809 /* Extract the email address from a user id and normalize it.  If the
2810    user id doesn't contain an email address, then we use the whole
2811    user_id and normalize that.  The returned string must be freed.  */
2812 static char *
2813 email_from_user_id (const char *user_id)
2814 {
2815   char *email = mailbox_from_userid (user_id);
2816   if (! email)
2817     {
2818       /* Hmm, no email address was provided or we are out of core.  Just
2819          take the lower-case version of the whole user id.  It could be
2820          a hostname, for instance.  */
2821       email = ascii_strlwr (xstrdup (user_id));
2822     }
2823
2824   return email;
2825 }
2826
2827 /* Register the signature with the bindings <fingerprint, USER_ID>,
2828    for each USER_ID in USER_ID_LIST.  The fingerprint is taken from
2829    the primary key packet PK.
2830
2831    SIG_DIGEST_BIN is the binary representation of the message's
2832    digest.  SIG_DIGEST_BIN_LEN is its length.
2833
2834    SIG_TIME is the time that the signature was generated.
2835
2836    ORIGIN is a free-formed string describing the origin of the
2837    signature.  If this was from an email and the Claws MUA was used,
2838    then this should be something like: "email:claws".  If this is
2839    NULL, the default is simply "unknown".
2840
2841    If MAY_ASK is 1, then this function may interact with the user.
2842    This is necessary if there is a conflict or the binding's policy is
2843    TOFU_POLICY_ASK.
2844
2845    This function returns 0 on success and an error code if an error
2846    occured.  */
2847 gpg_error_t
2848 tofu_register_signature (ctrl_t ctrl,
2849                          PKT_public_key *pk, strlist_t user_id_list,
2850                          const byte *sig_digest_bin, int sig_digest_bin_len,
2851                          time_t sig_time, const char *origin)
2852 {
2853   time_t now = gnupg_get_time ();
2854   gpg_error_t rc;
2855   tofu_dbs_t dbs;
2856   char *fingerprint = NULL;
2857   strlist_t user_id;
2858   char *email = NULL;
2859   char *err = NULL;
2860   char *sig_digest;
2861   unsigned long c;
2862
2863   dbs = opendbs (ctrl);
2864   if (! dbs)
2865     {
2866       rc = gpg_error (GPG_ERR_GENERAL);
2867       log_error (_("error opening TOFU database: %s\n"),
2868                  gpg_strerror (rc));
2869       return rc;
2870     }
2871
2872   /* We do a query and then an insert.  Make sure they are atomic
2873      by wrapping them in a transaction.  */
2874   rc = begin_transaction (ctrl, 0);
2875   if (rc)
2876     return rc;
2877
2878   log_assert (keyid_cmp (pk_keyid (pk), pk->main_keyid) == 0);
2879
2880   sig_digest = make_radix64_string (sig_digest_bin, sig_digest_bin_len);
2881   fingerprint = hexfingerprint (pk, NULL, 0);
2882
2883   if (! origin)
2884     /* The default origin is simply "unknown".  */
2885     origin = "unknown";
2886
2887   for (user_id = user_id_list; user_id; user_id = user_id->next)
2888     {
2889       email = email_from_user_id (user_id->d);
2890
2891       if (DBG_TRUST)
2892         log_debug ("TOFU: Registering signature %s with binding"
2893                    " <key: %s, user id: %s>\n",
2894                    sig_digest, fingerprint, email);
2895
2896       /* Make sure the binding exists and record any TOFU
2897          conflicts.  */
2898       if (get_trust (ctrl, pk, fingerprint, email, user_id->d, 0, now)
2899           == _tofu_GET_TRUST_ERROR)
2900         {
2901           rc = gpg_error (GPG_ERR_GENERAL);
2902           xfree (email);
2903           break;
2904         }
2905
2906       /* If we've already seen this signature before, then don't add
2907          it again.  */
2908       rc = gpgsql_stepx
2909         (dbs->db, &dbs->s.register_already_seen,
2910          get_single_unsigned_long_cb2, &c, &err,
2911          "select count (*)\n"
2912          " from signatures left join bindings\n"
2913          "  on signatures.binding = bindings.oid\n"
2914          " where fingerprint = ? and email = ? and sig_time = ?\n"
2915          "  and sig_digest = ?",
2916          GPGSQL_ARG_STRING, fingerprint, GPGSQL_ARG_STRING, email,
2917          GPGSQL_ARG_LONG_LONG, (long long) sig_time,
2918          GPGSQL_ARG_STRING, sig_digest,
2919          GPGSQL_ARG_END);
2920       if (rc)
2921         {
2922           log_error (_("error reading TOFU database: %s\n"), err);
2923           print_further_info ("checking existence");
2924           sqlite3_free (err);
2925         }
2926       else if (c > 1)
2927         /* Duplicates!  This should not happen.  In particular,
2928            because <fingerprint, email, sig_time, sig_digest> is the
2929            primary key!  */
2930         log_debug ("SIGNATURES DB contains duplicate records"
2931                    " <key: %s, fingerprint: %s, time: 0x%lx, sig: %s,"
2932                    " origin: %s>."
2933                    "  Please report.\n",
2934                    fingerprint, email, (unsigned long) sig_time,
2935                    sig_digest, origin);
2936       else if (c == 1)
2937         {
2938           if (DBG_TRUST)
2939             log_debug ("Already observed the signature and binding"
2940                        " <key: %s, user id: %s, time: 0x%lx, sig: %s,"
2941                        " origin: %s>\n",
2942                        fingerprint, email, (unsigned long) sig_time,
2943                        sig_digest, origin);
2944         }
2945       else if (opt.dry_run)
2946         {
2947           log_info ("TOFU database update skipped due to --dry-run\n");
2948         }
2949       else
2950         /* This is the first time that we've seen this signature and
2951            binding.  Record it.  */
2952         {
2953           if (DBG_TRUST)
2954             log_debug ("TOFU: Saving signature"
2955                        " <key: %s, user id: %s, sig: %s>\n",
2956                        fingerprint, email, sig_digest);
2957
2958           log_assert (c == 0);
2959
2960           rc = gpgsql_stepx
2961             (dbs->db, &dbs->s.register_insert, NULL, NULL, &err,
2962              "insert into signatures\n"
2963              " (binding, sig_digest, origin, sig_time, time)\n"
2964              " values\n"
2965              " ((select oid from bindings\n"
2966              "    where fingerprint = ? and email = ?),\n"
2967              "  ?, ?, ?, ?);",
2968              GPGSQL_ARG_STRING, fingerprint, GPGSQL_ARG_STRING, email,
2969              GPGSQL_ARG_STRING, sig_digest, GPGSQL_ARG_STRING, origin,
2970              GPGSQL_ARG_LONG_LONG, (long long) sig_time,
2971              GPGSQL_ARG_LONG_LONG, (long long) now,
2972              GPGSQL_ARG_END);
2973           if (rc)
2974             {
2975               log_error (_("error updating TOFU database: %s\n"), err);
2976               print_further_info ("insert signatures");
2977               sqlite3_free (err);
2978             }
2979         }
2980
2981       xfree (email);
2982
2983       if (rc)
2984         break;
2985     }
2986
2987   if (rc)
2988     rollback_transaction (ctrl);
2989   else
2990     rc = end_transaction (ctrl, 0);
2991
2992   xfree (fingerprint);
2993   xfree (sig_digest);
2994
2995   return rc;
2996 }
2997
2998 gpg_error_t
2999 tofu_register_encryption (ctrl_t ctrl,
3000                           PKT_public_key *pk, strlist_t user_id_list,
3001                           int may_ask)
3002 {
3003   time_t now = gnupg_get_time ();
3004   gpg_error_t rc = 0;
3005   tofu_dbs_t dbs;
3006   kbnode_t kb = NULL;
3007   int free_user_id_list = 0;
3008   char *fingerprint = NULL;
3009   strlist_t user_id;
3010   char *err = NULL;
3011
3012   dbs = opendbs (ctrl);
3013   if (! dbs)
3014     {
3015       rc = gpg_error (GPG_ERR_GENERAL);
3016       log_error (_("error opening TOFU database: %s\n"),
3017                  gpg_strerror (rc));
3018       return rc;
3019     }
3020
3021   /* Make sure PK is a primary key.  */
3022   if (keyid_cmp (pk_keyid (pk), pk->main_keyid) != 0
3023       || user_id_list)
3024     kb = get_pubkeyblock (pk->keyid);
3025
3026   if (keyid_cmp (pk_keyid (pk), pk->main_keyid) != 0)
3027     pk = kb->pkt->pkt.public_key;
3028
3029   if (! user_id_list)
3030     {
3031       /* Use all non-revoked user ids.  Do use expired user ids.  */
3032       kbnode_t n = kb;
3033
3034       while ((n = find_next_kbnode (n, PKT_USER_ID)))
3035         {
3036           PKT_user_id *uid = n->pkt->pkt.user_id;
3037
3038           if (uid->is_revoked)
3039             continue;
3040
3041           add_to_strlist (&user_id_list, uid->name);
3042         }
3043
3044       free_user_id_list = 1;
3045
3046       if (! user_id_list)
3047         log_info ("WARNING: Encrypting to %s, which has no"
3048                   "non-revoked user ids.\n",
3049                   keystr (pk->keyid));
3050     }
3051
3052   fingerprint = hexfingerprint (pk, NULL, 0);
3053
3054   tofu_begin_batch_update (ctrl);
3055   tofu_resume_batch_transaction (ctrl);
3056
3057   for (user_id = user_id_list; user_id; user_id = user_id->next)
3058     {
3059       char *email = email_from_user_id (user_id->d);
3060
3061       /* Make sure the binding exists and that we recognize any
3062          conflicts.  */
3063       int tl = get_trust (ctrl, pk, fingerprint, email, user_id->d,
3064                           may_ask, now);
3065       if (tl == _tofu_GET_TRUST_ERROR)
3066         {
3067           /* An error.  */
3068           xfree (email);
3069           goto die;
3070         }
3071
3072       rc = gpgsql_stepx
3073         (dbs->db, &dbs->s.register_insert, NULL, NULL, &err,
3074          "insert into encryptions\n"
3075          " (binding, time)\n"
3076          " values\n"
3077          " ((select oid from bindings\n"
3078          "    where fingerprint = ? and email = ?),\n"
3079          "  ?);",
3080          GPGSQL_ARG_STRING, fingerprint, GPGSQL_ARG_STRING, email,
3081          GPGSQL_ARG_LONG_LONG, (long long) now,
3082          GPGSQL_ARG_END);
3083       if (rc)
3084         {
3085           log_error (_("error updating TOFU database: %s\n"), err);
3086           print_further_info ("insert encryption");
3087           sqlite3_free (err);
3088         }
3089
3090       xfree (email);
3091     }
3092
3093  die:
3094   tofu_end_batch_update (ctrl);
3095
3096   if (kb)
3097     release_kbnode (kb);
3098
3099   if (free_user_id_list)
3100     free_strlist (user_id_list);
3101
3102   xfree (fingerprint);
3103
3104   return rc;
3105 }
3106
3107
3108 /* Combine a trust level returned from the TOFU trust model with a
3109    trust level returned by the PGP trust model.  This is primarily of
3110    interest when the trust model is tofu+pgp (TM_TOFU_PGP).
3111
3112    This function ors together the upper bits (the values not covered
3113    by TRUST_MASK, i.e., TRUST_FLAG_REVOKED, etc.).  */
3114 int
3115 tofu_wot_trust_combine (int tofu_base, int wot_base)
3116 {
3117   int tofu = tofu_base & TRUST_MASK;
3118   int wot = wot_base & TRUST_MASK;
3119   int upper = (tofu_base & ~TRUST_MASK) | (wot_base & ~TRUST_MASK);
3120
3121   log_assert (tofu == TRUST_UNKNOWN
3122               || tofu == TRUST_EXPIRED
3123               || tofu == TRUST_UNDEFINED
3124               || tofu == TRUST_NEVER
3125               || tofu == TRUST_MARGINAL
3126               || tofu == TRUST_FULLY
3127               || tofu == TRUST_ULTIMATE);
3128   log_assert (wot == TRUST_UNKNOWN
3129               || wot == TRUST_EXPIRED
3130               || wot == TRUST_UNDEFINED
3131               || wot == TRUST_NEVER
3132               || wot == TRUST_MARGINAL
3133               || wot == TRUST_FULLY
3134               || wot == TRUST_ULTIMATE);
3135
3136   /* We first consider negative trust policys.  These trump positive
3137      trust policies.  */
3138   if (tofu == TRUST_NEVER || wot == TRUST_NEVER)
3139     /* TRUST_NEVER trumps everything else.  */
3140     return upper | TRUST_NEVER;
3141   if (tofu == TRUST_EXPIRED || wot == TRUST_EXPIRED)
3142     /* TRUST_EXPIRED trumps everything but TRUST_NEVER.  */
3143     return upper | TRUST_EXPIRED;
3144
3145   /* Now we only have positive or neutral trust policies.  We take
3146      the max.  */
3147   if (tofu == TRUST_ULTIMATE)
3148     return upper | TRUST_ULTIMATE | TRUST_FLAG_TOFU_BASED;
3149   if (wot == TRUST_ULTIMATE)
3150     return upper | TRUST_ULTIMATE;
3151
3152   if (tofu == TRUST_FULLY)
3153     return upper | TRUST_FULLY | TRUST_FLAG_TOFU_BASED;
3154   if (wot == TRUST_FULLY)
3155     return upper | TRUST_FULLY;
3156
3157   if (tofu == TRUST_MARGINAL)
3158     return upper | TRUST_MARGINAL | TRUST_FLAG_TOFU_BASED;
3159   if (wot == TRUST_MARGINAL)
3160     return upper | TRUST_MARGINAL;
3161
3162   if (tofu == TRUST_UNDEFINED)
3163     return upper | TRUST_UNDEFINED | TRUST_FLAG_TOFU_BASED;
3164   if (wot == TRUST_UNDEFINED)
3165     return upper | TRUST_UNDEFINED;
3166
3167   return upper | TRUST_UNKNOWN;
3168 }
3169
3170
3171 /* Write a "tfs" record for a --with-colons listing.  */
3172 gpg_error_t
3173 tofu_write_tfs_record (ctrl_t ctrl, estream_t fp,
3174                        PKT_public_key *pk, const char *user_id)
3175 {
3176   time_t now = gnupg_get_time ();
3177   gpg_error_t err;
3178   tofu_dbs_t dbs;
3179   char *fingerprint;
3180   char *email;
3181
3182   if (!*user_id)
3183     return 0;  /* No TOFU stats possible for an empty ID.  */
3184
3185   dbs = opendbs (ctrl);
3186   if (!dbs)
3187     {
3188       err = gpg_error (GPG_ERR_GENERAL);
3189       log_error (_("error opening TOFU database: %s\n"), gpg_strerror (err));
3190       return err;
3191     }
3192
3193   fingerprint = hexfingerprint (pk, NULL, 0);
3194   email = email_from_user_id (user_id);
3195
3196   show_statistics (dbs, fingerprint, email, user_id, fp, now);
3197
3198   xfree (email);
3199   xfree (fingerprint);
3200   return 0;
3201 }
3202
3203
3204 /* Return the validity (TRUST_NEVER, etc.) of the bindings
3205    <FINGERPRINT, USER_ID>, for each USER_ID in USER_ID_LIST.  If
3206    USER_ID_LIST->FLAG is set, then the id is considered to be expired.
3207
3208    PK is the primary key packet.
3209
3210    If MAY_ASK is 1 and the policy is TOFU_POLICY_ASK, then the user
3211    will be prompted to choose a policy.  If MAY_ASK is 0 and the
3212    policy is TOFU_POLICY_ASK, then TRUST_UNKNOWN is returned.
3213
3214    Returns TRUST_UNDEFINED if an error occurs.  */
3215 int
3216 tofu_get_validity (ctrl_t ctrl, PKT_public_key *pk, strlist_t user_id_list,
3217                    int may_ask)
3218 {
3219   time_t now = gnupg_get_time ();
3220   tofu_dbs_t dbs;
3221   char *fingerprint = NULL;
3222   strlist_t user_id;
3223   int trust_level = TRUST_UNKNOWN;
3224   int bindings = 0;
3225   int bindings_valid = 0;
3226   int need_warning = 0;
3227
3228   dbs = opendbs (ctrl);
3229   if (! dbs)
3230     {
3231       log_error (_("error opening TOFU database: %s\n"),
3232                  gpg_strerror (GPG_ERR_GENERAL));
3233       return TRUST_UNDEFINED;
3234     }
3235
3236   fingerprint = hexfingerprint (pk, NULL, 0);
3237
3238   tofu_begin_batch_update (ctrl);
3239   tofu_resume_batch_transaction (ctrl);
3240
3241   for (user_id = user_id_list; user_id; user_id = user_id->next, bindings ++)
3242     {
3243       char *email = email_from_user_id (user_id->d);
3244
3245       /* Always call get_trust to make sure the binding is
3246          registered.  */
3247       int tl = get_trust (ctrl, pk, fingerprint, email, user_id->d,
3248                           may_ask, now);
3249       if (tl == _tofu_GET_TRUST_ERROR)
3250         {
3251           /* An error.  */
3252           trust_level = TRUST_UNDEFINED;
3253           xfree (email);
3254           goto die;
3255         }
3256
3257       if (DBG_TRUST)
3258         log_debug ("TOFU: validity for <key: %s, user id: %s>: %s%s.\n",
3259                    fingerprint, email,
3260                    trust_value_to_string (tl),
3261                    user_id->flags ? " (but expired)" : "");
3262
3263       if (user_id->flags)
3264         tl = TRUST_EXPIRED;
3265
3266       if (tl != TRUST_EXPIRED)
3267         bindings_valid ++;
3268
3269       if (may_ask && tl != TRUST_ULTIMATE && tl != TRUST_EXPIRED)
3270         need_warning |=
3271           show_statistics (dbs, fingerprint, email, user_id->d, NULL, now);
3272
3273       if (tl == TRUST_NEVER)
3274         trust_level = TRUST_NEVER;
3275       else if (tl == TRUST_EXPIRED)
3276         /* Ignore expired bindings in the trust calculation.  */
3277         ;
3278       else if (tl > trust_level)
3279         {
3280           /* The expected values: */
3281           log_assert (tl == TRUST_UNKNOWN || tl == TRUST_UNDEFINED
3282                       || tl == TRUST_MARGINAL || tl == TRUST_FULLY
3283                       || tl == TRUST_ULTIMATE);
3284
3285           /* We assume the following ordering:  */
3286           log_assert (TRUST_UNKNOWN < TRUST_UNDEFINED);
3287           log_assert (TRUST_UNDEFINED < TRUST_MARGINAL);
3288           log_assert (TRUST_MARGINAL < TRUST_FULLY);
3289           log_assert (TRUST_FULLY < TRUST_ULTIMATE);
3290
3291           trust_level = tl;
3292         }
3293
3294       xfree (email);
3295     }
3296
3297   if (need_warning)
3298     show_warning (fingerprint, user_id_list);
3299
3300  die:
3301   tofu_end_batch_update (ctrl);
3302
3303   xfree (fingerprint);
3304
3305   if (bindings_valid == 0)
3306     {
3307       if (DBG_TRUST)
3308         log_debug ("no (of %d) valid bindings."
3309                    "  Can't get TOFU validity for this set of user ids.\n",
3310                    bindings);
3311       return TRUST_NEVER;
3312     }
3313
3314   return trust_level;
3315 }
3316
3317 /* Set the policy for all non-revoked user ids in the keyblock KB to
3318    POLICY.
3319
3320    If no key is available with the specified key id, then this
3321    function returns GPG_ERR_NO_PUBKEY.
3322
3323    Returns 0 on success and an error code otherwise.  */
3324 gpg_error_t
3325 tofu_set_policy (ctrl_t ctrl, kbnode_t kb, enum tofu_policy policy)
3326 {
3327   time_t now = gnupg_get_time ();
3328   tofu_dbs_t dbs;
3329   PKT_public_key *pk;
3330   char *fingerprint = NULL;
3331
3332   log_assert (kb->pkt->pkttype == PKT_PUBLIC_KEY);
3333   pk = kb->pkt->pkt.public_key;
3334
3335   dbs = opendbs (ctrl);
3336   if (! dbs)
3337     {
3338       log_error (_("error opening TOFU database: %s\n"),
3339                  gpg_strerror (GPG_ERR_GENERAL));
3340       return gpg_error (GPG_ERR_GENERAL);
3341     }
3342
3343   if (DBG_TRUST)
3344     log_debug ("Setting TOFU policy for %s to %s\n",
3345                keystr (pk->keyid), tofu_policy_str (policy));
3346   if (! (pk->main_keyid[0] == pk->keyid[0]
3347          && pk->main_keyid[1] == pk->keyid[1]))
3348     log_bug ("%s: Passed a subkey, but expecting a primary key.\n", __func__);
3349
3350   fingerprint = hexfingerprint (pk, NULL, 0);
3351
3352   begin_transaction (ctrl, 0);
3353
3354   for (; kb; kb = kb->next)
3355     {
3356       PKT_user_id *user_id;
3357       char *email;
3358
3359       if (kb->pkt->pkttype != PKT_USER_ID)
3360         continue;
3361
3362       user_id = kb->pkt->pkt.user_id;
3363       if (user_id->is_revoked)
3364         /* Skip revoked user ids.  (Don't skip expired user ids, the
3365            expiry can be changed.)  */
3366         continue;
3367
3368       email = email_from_user_id (user_id->name);
3369
3370       record_binding (dbs, fingerprint, email, user_id->name, policy, 1, now);
3371
3372       xfree (email);
3373     }
3374
3375   end_transaction (ctrl, 0);
3376
3377   xfree (fingerprint);
3378   return 0;
3379 }
3380
3381 /* Set the TOFU policy for all non-revoked user ids in the KEY with
3382    the key id KEYID to POLICY.
3383
3384    If no key is available with the specified key id, then this
3385    function returns GPG_ERR_NO_PUBKEY.
3386
3387    Returns 0 on success and an error code otherwise.  */
3388 gpg_error_t
3389 tofu_set_policy_by_keyid (ctrl_t ctrl, u32 *keyid, enum tofu_policy policy)
3390 {
3391   kbnode_t keyblock = get_pubkeyblock (keyid);
3392   if (! keyblock)
3393     return gpg_error (GPG_ERR_NO_PUBKEY);
3394
3395   return tofu_set_policy (ctrl, keyblock, policy);
3396 }
3397
3398 /* Return the TOFU policy for the specified binding in *POLICY.  If no
3399    policy has been set for the binding, sets *POLICY to
3400    TOFU_POLICY_NONE.
3401
3402    PK is a primary public key and USER_ID is a user id.
3403
3404    Returns 0 on success and an error code otherwise.  */
3405 gpg_error_t
3406 tofu_get_policy (ctrl_t ctrl, PKT_public_key *pk, PKT_user_id *user_id,
3407                  enum tofu_policy *policy)
3408 {
3409   tofu_dbs_t dbs;
3410   char *fingerprint;
3411   char *email;
3412
3413   /* Make sure PK is a primary key.  */
3414   log_assert (pk->main_keyid[0] == pk->keyid[0]
3415               && pk->main_keyid[1] == pk->keyid[1]);
3416
3417   dbs = opendbs (ctrl);
3418   if (! dbs)
3419     {
3420       log_error (_("error opening TOFU database: %s\n"),
3421                  gpg_strerror (GPG_ERR_GENERAL));
3422       return gpg_error (GPG_ERR_GENERAL);
3423     }
3424
3425   fingerprint = hexfingerprint (pk, NULL, 0);
3426
3427   email = email_from_user_id (user_id->name);
3428
3429   *policy = get_policy (dbs, fingerprint, email, NULL);
3430
3431   xfree (email);
3432   xfree (fingerprint);
3433   if (*policy == _tofu_GET_POLICY_ERROR)
3434     return gpg_error (GPG_ERR_GENERAL);
3435   return 0;
3436 }