g10: Improve TOFU batch update code.
[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
45 #include "tofu.h"
46
47
48 #define CONTROL_L ('L' - 'A' + 1)
49
50 /* Number of signed messages required to indicate that enough history
51  * is available for basic trust.  */
52 #define BASIC_TRUST_THRESHOLD  10
53 /* Number of signed messages required to indicate that a lot of
54  * history is available.  */
55 #define FULL_TRUST_THRESHOLD  100
56
57
58 /* An struct with data pertaining to the tofu DB.
59
60    To initialize this data structure, call opendbs().  Cleanup is done
61    when the CTRL object is released.  To get a handle to a database,
62    use the getdb() function.  This will either return an existing
63    handle or open a new DB connection, as appropriate.  */
64 struct tofu_dbs_s
65 {
66   sqlite3 *db;
67
68   struct
69   {
70     sqlite3_stmt *savepoint_batch;
71     sqlite3_stmt *savepoint_batch_commit;
72
73     sqlite3_stmt *record_binding_get_old_policy;
74     sqlite3_stmt *record_binding_update;
75     sqlite3_stmt *record_binding_update2;
76     sqlite3_stmt *get_policy_select_policy_and_conflict;
77     sqlite3_stmt *get_trust_bindings_with_this_email;
78     sqlite3_stmt *get_trust_gather_other_user_ids;
79     sqlite3_stmt *get_trust_gather_other_keys;
80     sqlite3_stmt *register_already_seen;
81     sqlite3_stmt *register_insert;
82   } s;
83
84   int in_batch_transaction;
85 };
86
87
88 #define STRINGIFY(s) STRINGIFY2(s)
89 #define STRINGIFY2(s) #s
90
91 /* The grouping parameters when collecting signature statistics.  */
92
93 /* If a message is signed a couple of hours in the future, just assume
94    some clock skew.  */
95 #define TIME_AGO_FUTURE_IGNORE (2 * 60 * 60)
96 #if 0
97 #  define TIME_AGO_UNIT_SMALL 60
98 #  define TIME_AGO_MEDIUM_THRESHOLD (60 * TIME_AGO_UNIT_SMALL)
99 #  define TIME_AGO_UNIT_MEDIUM (60 * 60)
100 #  define TIME_AGO_LARGE_THRESHOLD (24 * 60 * TIME_AGO_UNIT_SMALL)
101 #  define TIME_AGO_UNIT_LARGE (24 * 60 * 60)
102 #else
103 #  define TIME_AGO_UNIT_SMALL (24 * 60 * 60)
104 #  define TIME_AGO_MEDIUM_THRESHOLD (4 * TIME_AGO_UNIT_SMALL)
105 #  define TIME_AGO_UNIT_MEDIUM (7 * 24 * 60 * 60)
106 #  define TIME_AGO_LARGE_THRESHOLD (28 * TIME_AGO_UNIT_SMALL)
107 #  define TIME_AGO_UNIT_LARGE (30 * 24 * 60 * 60)
108 #endif
109
110 /* Local prototypes.  */
111 static gpg_error_t end_transaction (ctrl_t ctrl, int only_batch);
112
113
114 \f
115 const char *
116 tofu_policy_str (enum tofu_policy policy)
117 {
118   switch (policy)
119     {
120     case TOFU_POLICY_NONE: return "none";
121     case TOFU_POLICY_AUTO: return "auto";
122     case TOFU_POLICY_GOOD: return "good";
123     case TOFU_POLICY_UNKNOWN: return "unknown";
124     case TOFU_POLICY_BAD: return "bad";
125     case TOFU_POLICY_ASK: return "ask";
126     default: return "???";
127     }
128 }
129
130 /* Convert a binding policy (e.g., TOFU_POLICY_BAD) to a trust level
131    (e.g., TRUST_BAD) in light of the current configuration.  */
132 int
133 tofu_policy_to_trust_level (enum tofu_policy policy)
134 {
135   if (policy == TOFU_POLICY_AUTO)
136     /* If POLICY is AUTO, fallback to OPT.TOFU_DEFAULT_POLICY.  */
137     policy = opt.tofu_default_policy;
138
139   switch (policy)
140     {
141     case TOFU_POLICY_AUTO:
142       /* If POLICY and OPT.TOFU_DEFAULT_POLICY are both AUTO, default
143          to marginal trust.  */
144       return TRUST_MARGINAL;
145     case TOFU_POLICY_GOOD:
146       return TRUST_FULLY;
147     case TOFU_POLICY_UNKNOWN:
148       return TRUST_UNKNOWN;
149     case TOFU_POLICY_BAD:
150       return TRUST_NEVER;
151     case TOFU_POLICY_ASK:
152       return TRUST_UNKNOWN;
153     default:
154       log_bug ("Bad value for trust policy: %d\n",
155                opt.tofu_default_policy);
156       return 0;
157     }
158 }
159
160
161 \f
162 /* Start a transaction on DB.  */
163 static gpg_error_t
164 begin_transaction (ctrl_t ctrl, int only_batch)
165 {
166   tofu_dbs_t dbs = ctrl->tofu.dbs;
167   int rc;
168   char *err = NULL;
169
170   log_assert (dbs);
171
172   /* If we've been in batch update mode for a while (on average, more
173    * than 500 ms), to prevent starving other gpg processes, we drop
174    * and retake the batch lock.
175    *
176    * Note: if we wanted higher resolution, we could use
177    * npth_clock_gettime.  */
178   if (/* No real transactions.  */
179       ctrl->tofu.in_transaction == 0
180       /* There is an open batch transaction.  */
181       && dbs->in_batch_transaction
182       /* And some time has gone by since it was started.  */
183       && ctrl->tofu.batch_update_started != gnupg_get_time ())
184     {
185       /* If we are in a batch update, then batch updates better have
186          been enabled.  */
187       log_assert (ctrl->tofu.batch_updated_wanted);
188
189       end_transaction (ctrl, 2);
190
191       /* Yield to allow another process a chance to run.  */
192       gpgrt_yield ();
193     }
194
195   if (/* Batch mode is enabled.  */
196       ctrl->tofu.batch_updated_wanted
197       /* But we don't have an open batch transaction.  */
198       && !dbs->in_batch_transaction)
199     {
200       /* We are in batch mode, but we don't have an open batch
201        * transaction.  Since the batch save point must be the outer
202        * save point, it must be taken before the inner save point.  */
203       log_assert (ctrl->tofu.in_transaction == 0);
204
205       rc = gpgsql_stepx (dbs->db, &dbs->s.savepoint_batch,
206                           NULL, NULL, &err,
207                           "savepoint batch;", SQLITE_ARG_END);
208       if (rc)
209         {
210           log_error (_("error beginning transaction on TOFU database: %s\n"),
211                      err);
212           sqlite3_free (err);
213           return gpg_error (GPG_ERR_GENERAL);
214         }
215
216       dbs->in_batch_transaction = 1;
217       ctrl->tofu.batch_update_started = gnupg_get_time ();
218     }
219
220   if (only_batch)
221     return 0;
222
223   log_assert(ctrl->tofu.in_transaction >= 0);
224   ctrl->tofu.in_transaction ++;
225
226   rc = gpgsql_exec_printf (dbs->db, NULL, NULL, &err,
227                            "savepoint inner%d;",
228                            ctrl->tofu.in_transaction);
229   if (rc)
230     {
231       log_error (_("error beginning transaction on TOFU database: %s\n"),
232                  err);
233       sqlite3_free (err);
234       return gpg_error (GPG_ERR_GENERAL);
235     }
236
237   return 0;
238 }
239
240
241 /* Commit a transaction.  If ONLY_BATCH is 1, then this only ends the
242  * batch transaction if we have left batch mode.  If ONLY_BATCH is 2,
243  * this ends any open batch transaction even if we are still in batch
244  * mode.  */
245 static gpg_error_t
246 end_transaction (ctrl_t ctrl, int only_batch)
247 {
248   tofu_dbs_t dbs = ctrl->tofu.dbs;
249   int rc;
250   char *err = NULL;
251
252   if (only_batch)
253     {
254       if (!dbs)
255         return 0;  /* Shortcut to allow for easier cleanup code.  */
256
257       /* If we are releasing the batch transaction, then we better not
258          be in a normal transaction.  */
259       log_assert (ctrl->tofu.in_transaction == 0);
260
261       if (/* Batch mode disabled?  */
262           (!ctrl->tofu.batch_updated_wanted || only_batch == 2)
263           /* But, we still have an open batch transaction?  */
264           && dbs->in_batch_transaction)
265         {
266           /* The batch transaction is still in open, but we've left
267            * batch mode.  */
268           dbs->in_batch_transaction = 0;
269
270           rc = gpgsql_stepx (dbs->db, &dbs->s.savepoint_batch_commit,
271                              NULL, NULL, &err,
272                              "release batch;", SQLITE_ARG_END);
273           if (rc)
274             {
275               log_error (_("error committing transaction on TOFU database: %s\n"),
276                          err);
277               sqlite3_free (err);
278               return gpg_error (GPG_ERR_GENERAL);
279             }
280
281           return 0;
282         }
283
284       return 0;
285     }
286
287   log_assert (dbs);
288   log_assert (ctrl->tofu.in_transaction > 0);
289
290   rc = gpgsql_exec_printf (dbs->db, NULL, NULL, &err,
291                            "release inner%d;", ctrl->tofu.in_transaction);
292   if (rc)
293     {
294       log_error (_("error committing transaction on TOFU database: %s\n"),
295                  err);
296       sqlite3_free (err);
297       return gpg_error (GPG_ERR_GENERAL);
298     }
299
300   ctrl->tofu.in_transaction --;
301
302   return 0;
303 }
304
305
306 static gpg_error_t
307 rollback_transaction (ctrl_t ctrl)
308 {
309   tofu_dbs_t dbs = ctrl->tofu.dbs;
310   int rc;
311   char *err = NULL;
312
313   log_assert (dbs);
314   log_assert (ctrl->tofu.in_transaction > 0);
315
316   /* Be careful to not any progress made by closed transactions in
317      batch mode.  */
318   rc = gpgsql_exec_printf (dbs->db, NULL, NULL, &err,
319                            "rollback to inner%d;",
320                            ctrl->tofu.in_transaction);
321
322   ctrl->tofu.in_transaction --;
323
324   if (rc)
325     {
326       log_error (_("error rolling back transaction on TOFU database: %s\n"),
327                  err);
328       sqlite3_free (err);
329       return gpg_error (GPG_ERR_GENERAL);
330     }
331
332   return 0;
333 }
334
335 void
336 tofu_begin_batch_update (ctrl_t ctrl)
337 {
338   ctrl->tofu.batch_updated_wanted ++;
339 }
340
341 void
342 tofu_end_batch_update (ctrl_t ctrl)
343 {
344   log_assert (ctrl->tofu.batch_updated_wanted > 0);
345   ctrl->tofu.batch_updated_wanted --;
346
347   if (!ctrl->tofu.batch_updated_wanted)
348     end_transaction (ctrl, 1);
349 }
350
351
352
353 \f
354 /* Wrapper around strtol which prints a warning in case of a
355  * conversion error.  On success the converted value is stored at
356  * R_VALUE and 0 is returned; on error FALLBACK is stored at R_VALUE
357  * and an error code is returned.  */
358 static gpg_error_t
359 string_to_long (long *r_value, const char *string, long fallback, int line)
360 {
361   gpg_error_t err;
362   char *tail = NULL;
363
364   gpg_err_set_errno (0);
365   *r_value = strtol (string, &tail, 0);
366   if (errno || !(!strcmp (tail, ".0") || !*tail))
367     {
368       err = errno? gpg_error_from_errno (errno) : gpg_error (GPG_ERR_BAD_DATA);
369       log_debug ("%s:%d: "
370                  "strtol failed for DB returned string (tail=%.10s): %s\n",
371                  __FILE__, line, tail, gpg_strerror (err));
372       *r_value = fallback;
373     }
374   else
375     err = 0;
376
377   return err;
378 }
379
380
381 /* Wrapper around strtoul which prints a warning in case of a
382  * conversion error.  On success the converted value is stored at
383  * R_VALUE and 0 is returned; on error FALLBACK is stored at R_VALUE
384  * and an error code is returned.  */
385 static gpg_error_t
386 string_to_ulong (unsigned long *r_value, const char *string,
387                  unsigned long fallback, int line)
388 {
389   gpg_error_t err;
390   char *tail = NULL;
391
392   gpg_err_set_errno (0);
393   *r_value = strtoul (string, &tail, 0);
394   if (errno || !(!strcmp (tail, ".0") || !*tail))
395     {
396       err = errno? gpg_error_from_errno (errno) : gpg_error (GPG_ERR_BAD_DATA);
397       log_debug ("%s:%d: "
398                  "strtoul failed for DB returned string (tail=%.10s): %s\n",
399                  __FILE__, line, tail, gpg_strerror (err));
400       *r_value = fallback;
401     }
402   else
403     err = 0;
404
405   return err;
406 }
407
408
409
410 /* Collect results of a select count (*) ...; style query.  Aborts if
411    the argument is not a valid integer (or real of the form X.0).  */
412 static int
413 get_single_unsigned_long_cb (void *cookie, int argc, char **argv,
414                              char **azColName)
415 {
416   unsigned long int *count = cookie;
417
418   (void) azColName;
419
420   log_assert (argc == 1);
421
422   if (string_to_ulong (count, argv[0], 0, __LINE__))
423     return 1; /* Abort.  */
424   return 0;
425 }
426
427 static int
428 get_single_unsigned_long_cb2 (void *cookie, int argc, char **argv,
429                              char **azColName, sqlite3_stmt *stmt)
430 {
431   (void) stmt;
432   return get_single_unsigned_long_cb (cookie, argc, argv, azColName);
433 }
434
435 /* We expect a single integer column whose name is "version".  COOKIE
436    must point to an int.  This function always aborts.  On error or a
437    if the version is bad, sets *VERSION to -1.  */
438 static int
439 version_check_cb (void *cookie, int argc, char **argv, char **azColName)
440 {
441   int *version = cookie;
442
443   if (argc != 1 || strcmp (azColName[0], "version") != 0)
444     {
445       *version = -1;
446       return 1;
447     }
448
449   if (strcmp (argv[0], "1") == 0)
450     *version = 1;
451   else
452     {
453       log_error (_("unsupported TOFU database version: %s\n"), argv[0]);
454       *version = -1;
455     }
456
457   /* Don't run again.  */
458   return 1;
459 }
460
461
462 /* If the DB is new, initialize it.  Otherwise, check the DB's
463    version.
464
465    Return 0 if the database is okay and 1 otherwise.  */
466 static int
467 initdb (sqlite3 *db)
468 {
469   char *err = NULL;
470   int rc;
471   unsigned long int count;
472   int version = -1;
473
474   rc = sqlite3_exec (db, "begin transaction;", NULL, NULL, &err);
475   if (rc)
476     {
477       log_error (_("error beginning transaction on TOFU database: %s\n"),
478                  err);
479       sqlite3_free (err);
480       return 1;
481     }
482
483   /* If the DB has no tables, then assume this is a new DB that needs
484      to be initialized.  */
485   rc = sqlite3_exec (db,
486                      "select count(*) from sqlite_master where type='table';",
487                      get_single_unsigned_long_cb, &count, &err);
488   if (rc)
489     {
490       log_error (_("error reading TOFU database: %s\n"), err);
491       print_further_info ("query available tables");
492       sqlite3_free (err);
493       goto out;
494     }
495   else if (count != 0)
496     /* Assume that the DB is already initialized.  Make sure the
497        version is okay.  */
498     {
499       rc = sqlite3_exec (db, "select version from version;", version_check_cb,
500                          &version, &err);
501       if (rc == SQLITE_ABORT && version == 1)
502         /* Happy, happy, joy, joy.  */
503         {
504           sqlite3_free (err);
505           rc = 0;
506           goto out;
507         }
508       else if (rc == SQLITE_ABORT && version == -1)
509         /* Unsupported version.  */
510         {
511           /* An error message was already displayed.  */
512           sqlite3_free (err);
513           goto out;
514         }
515       else if (rc)
516         /* Some error.  */
517         {
518           log_error (_("error determining TOFU database's version: %s\n"), err);
519           sqlite3_free (err);
520           goto out;
521         }
522       else
523         {
524           /* Unexpected success.  This can only happen if there are no
525              rows.  (select returned 0, but expected ABORT.)  */
526           log_error (_("error determining TOFU database's version: %s\n"),
527                      gpg_strerror (GPG_ERR_NO_DATA));
528           rc = 1;
529           goto out;
530         }
531     }
532
533   /* Create the version table.  */
534   rc = sqlite3_exec (db,
535                      "create table version (version INTEGER);",
536                      NULL, NULL, &err);
537   if (rc)
538     {
539       log_error (_("error initializing TOFU database: %s\n"), err);
540       print_further_info ("create version");
541       sqlite3_free (err);
542       goto out;
543     }
544
545   /* Initialize the version table, which contains a single integer
546      value.  */
547   rc = sqlite3_exec (db,
548                      "insert into version values (1);",
549                      NULL, NULL, &err);
550   if (rc)
551     {
552       log_error (_("error initializing TOFU database: %s\n"), err);
553       print_further_info ("insert version");
554       sqlite3_free (err);
555       goto out;
556     }
557
558   /* The list of <fingerprint, email> bindings and auxiliary data.
559    *
560    *  OID is a unique ID identifying this binding (and used by the
561    *    signatures table, see below).  Note: OIDs will never be
562    *    reused.
563    *
564    *  FINGERPRINT: The key's fingerprint.
565    *
566    *  EMAIL: The normalized email address.
567    *
568    *  USER_ID: The unmodified user id from which EMAIL was extracted.
569    *
570    *  TIME: The time this binding was first observed.
571    *
572    *  POLICY: The trust policy (TOFU_POLICY_BAD, etc. as an integer).
573    *
574    *  CONFLICT is either NULL or a fingerprint.  Assume that we have
575    *    a binding <0xdeadbeef, foo@example.com> and then we observe
576    *    <0xbaddecaf, foo@example.com>.  There two bindings conflict
577    *    (they have the same email address).  When we observe the
578    *    latter binding, we warn the user about the conflict and ask
579    *    for a policy decision about the new binding.  We also change
580    *    the old binding's policy to ask if it was auto.  So that we
581    *     know why this occurred, we also set conflict to 0xbaddecaf.
582    */
583   rc = gpgsql_exec_printf
584       (db, NULL, NULL, &err,
585        "create table bindings\n"
586        " (oid INTEGER PRIMARY KEY AUTOINCREMENT,\n"
587        "  fingerprint TEXT, email TEXT, user_id TEXT, time INTEGER,\n"
588        "  policy BOOLEAN CHECK (policy in (%d, %d, %d, %d, %d)),\n"
589        "  conflict STRING,\n"
590        "  unique (fingerprint, email));\n"
591        "create index bindings_fingerprint_email\n"
592        " on bindings (fingerprint, email);\n"
593        "create index bindings_email on bindings (email);\n",
594        TOFU_POLICY_AUTO, TOFU_POLICY_GOOD, TOFU_POLICY_UNKNOWN,
595        TOFU_POLICY_BAD, TOFU_POLICY_ASK);
596   if (rc)
597     {
598       log_error (_("error initializing TOFU database: %s\n"), err);
599       print_further_info ("create bindings");
600       sqlite3_free (err);
601       goto out;
602     }
603
604   /* The signatures that we have observed.
605    *
606    * BINDING refers to a record in the bindings table, which
607    * describes the binding (i.e., this is a foreign key that
608    * references bindings.oid).
609    *
610    * SIG_DIGEST is the digest stored in the signature.
611    *
612    * SIG_TIME is the timestamp stored in the signature.
613    *
614    * ORIGIN is a free-form string that describes who fed this
615    * signature to GnuPG (e.g., email:claws).
616    *
617    * TIME is the time this signature was registered.  */
618   rc = sqlite3_exec (db,
619                          "create table signatures "
620                          " (binding INTEGER NOT NULL, sig_digest TEXT,"
621                          "  origin TEXT, sig_time INTEGER, time INTEGER,"
622                          "  primary key (binding, sig_digest, origin));",
623                          NULL, NULL, &err);
624   if (rc)
625     {
626       log_error (_("error initializing TOFU database: %s\n"), err);
627       print_further_info ("create signatures");
628       sqlite3_free (err);
629       goto out;
630     }
631
632  out:
633   if (rc)
634     {
635       rc = sqlite3_exec (db, "rollback;", NULL, NULL, &err);
636       if (rc)
637         {
638           log_error (_("error rolling back transaction on TOFU database: %s\n"),
639                      err);
640           sqlite3_free (err);
641         }
642       return 1;
643     }
644   else
645     {
646       rc = sqlite3_exec (db, "end transaction;", NULL, NULL, &err);
647       if (rc)
648         {
649           log_error (_("error committing transaction on TOFU database: %s\n"),
650                      err);
651           sqlite3_free (err);
652           return 1;
653         }
654       return 0;
655     }
656 }
657
658
659 /* Create a new DB handle.  Returns NULL on error.  */
660 /* FIXME: Change to return an error code for better reporting by the
661    caller.  */
662 static tofu_dbs_t
663 opendbs (ctrl_t ctrl)
664 {
665   char *filename;
666   sqlite3 *db;
667   int rc;
668
669   if (!ctrl->tofu.dbs)
670     {
671       filename = make_filename (gnupg_homedir (), "tofu.db", NULL);
672
673       rc = sqlite3_open (filename, &db);
674       if (rc)
675         {
676           log_error (_("error opening TOFU database '%s': %s\n"),
677                      filename, sqlite3_errmsg (db));
678           /* Even if an error occurs, DB is guaranteed to be valid.  */
679           sqlite3_close (db);
680           db = NULL;
681         }
682       xfree (filename);
683
684       /* If a DB is locked wait up to 5 seconds for the lock to be cleared
685          before failing.  */
686       if (db)
687         sqlite3_busy_timeout (db, 5 * 1000);
688
689       if (db && initdb (db))
690         {
691           sqlite3_close (db);
692           db = NULL;
693         }
694
695       if (db)
696         {
697           ctrl->tofu.dbs = xmalloc_clear (sizeof *ctrl->tofu.dbs);
698           ctrl->tofu.dbs->db = db;
699         }
700     }
701   else
702     log_assert (ctrl->tofu.dbs->db);
703
704   return ctrl->tofu.dbs;
705 }
706
707
708 /* Release all of the resources associated with the DB handle.  */
709 void
710 tofu_closedbs (ctrl_t ctrl)
711 {
712   tofu_dbs_t dbs;
713   sqlite3_stmt **statements;
714
715   log_assert (ctrl->tofu.in_transaction == 0);
716
717   dbs = ctrl->tofu.dbs;
718   if (!dbs)
719     return;  /* Not initialized.  */
720
721   end_transaction (ctrl, 2);
722
723   /* Arghh, that is a surprising use of the struct.  */
724   for (statements = (void *) &dbs->s;
725        (void *) statements < (void *) &(&dbs->s)[1];
726        statements ++)
727     sqlite3_finalize (*statements);
728
729   sqlite3_close (dbs->db);
730   xfree (dbs);
731   ctrl->tofu.dbs = NULL;
732 }
733
734
735 /* Collect results of a select min (foo) ...; style query.  Aborts if
736    the argument is not a valid integer (or real of the form X.0).  */
737 static int
738 get_single_long_cb (void *cookie, int argc, char **argv, char **azColName)
739 {
740   long *count = cookie;
741
742   (void) azColName;
743
744   log_assert (argc == 1);
745
746   if (string_to_long (count, argv[0], 0, __LINE__))
747     return 1; /* Abort.  */
748
749   return 0;
750 }
751
752 static int
753 get_single_long_cb2 (void *cookie, int argc, char **argv, char **azColName,
754                      sqlite3_stmt *stmt)
755 {
756   (void) stmt;
757   return get_single_long_cb (cookie, argc, argv, azColName);
758 }
759
760 /* Record (or update) a trust policy about a (possibly new)
761    binding.
762
763    If SHOW_OLD is set, the binding's old policy is displayed.  */
764 static gpg_error_t
765 record_binding (tofu_dbs_t dbs, const char *fingerprint, const char *email,
766                 const char *user_id, enum tofu_policy policy, int show_old)
767 {
768   char *fingerprint_pp = format_hexfingerprint (fingerprint, NULL, 0);
769   gpg_error_t rc;
770   char *err = NULL;
771   /* policy_old needs to be a long and not an enum tofu_policy,
772      because we pass it by reference to get_single_long_cb2, which
773      expects a long.  */
774   long policy_old = TOFU_POLICY_NONE;
775
776   if (! (policy == TOFU_POLICY_AUTO
777          || policy == TOFU_POLICY_GOOD
778          || policy == TOFU_POLICY_UNKNOWN
779          || policy == TOFU_POLICY_BAD
780          || policy == TOFU_POLICY_ASK))
781     log_bug ("%s: Bad value for policy (%d)!\n", __func__, policy);
782
783
784   if (show_old)
785     {
786       /* Get the old policy.  Since this is just for informational
787        * purposes, there is no need to start a transaction or to die
788        * if there is a failure.  */
789       rc = gpgsql_stepx
790         (dbs->db, &dbs->s.record_binding_get_old_policy,
791          get_single_long_cb2, &policy_old, &err,
792          "select policy from bindings where fingerprint = ? and email = ?",
793          SQLITE_ARG_STRING, fingerprint, SQLITE_ARG_STRING, email,
794          SQLITE_ARG_END);
795       if (rc)
796         {
797           log_debug ("TOFU: Error reading from binding database"
798                      " (reading policy for <key: %s, user id: %s>): %s\n",
799                      fingerprint, email, err);
800           sqlite3_free (err);
801         }
802
803       if (DBG_TRUST)
804         {
805           if (policy_old != TOFU_POLICY_NONE)
806             log_debug ("Changing TOFU trust policy for binding"
807                        " <key: %s, user id: %s> from %s to %s.\n",
808                        fingerprint, email,
809                        tofu_policy_str (policy_old),
810                        tofu_policy_str (policy));
811           else
812             log_debug ("Setting TOFU trust policy for new binding"
813                        " <key: %s, user id: %s> to %s.\n",
814                        fingerprint, email,
815                        tofu_policy_str (policy));
816         }
817     }
818
819   if (policy_old == policy)
820     {
821       rc = 0;
822       goto leave; /* Nothing to do.  */
823     }
824
825   if (opt.dry_run)
826     {
827       log_info ("TOFU database update skipped due to --dry-run\n");
828       rc = 0;
829       goto leave;
830     }
831
832   rc = gpgsql_stepx
833     (dbs->db, &dbs->s.record_binding_update, NULL, NULL, &err,
834      "insert or replace into bindings\n"
835      " (oid, fingerprint, email, user_id, time, policy)\n"
836      " values (\n"
837      /* If we don't explicitly reuse the OID, then SQLite will
838         reallocate a new one.  We just need to search for the OID
839         based on the fingerprint and email since they are unique.  */
840      "  (select oid from bindings where fingerprint = ? and email = ?),\n"
841      "  ?, ?, ?, strftime('%s','now'), ?);",
842      SQLITE_ARG_STRING, fingerprint, SQLITE_ARG_STRING, email,
843      SQLITE_ARG_STRING, fingerprint, SQLITE_ARG_STRING, email,
844      SQLITE_ARG_STRING, user_id, SQLITE_ARG_INT, (int) policy,
845      SQLITE_ARG_END);
846   if (rc)
847     {
848       log_error (_("error updating TOFU database: %s\n"), err);
849       print_further_info (" insert bindings <key: %s, user id: %s> = %s",
850                           fingerprint, email, tofu_policy_str (policy));
851       sqlite3_free (err);
852       goto leave;
853     }
854
855  leave:
856   xfree (fingerprint_pp);
857   return rc;
858 }
859
860
861 /* Collect the strings returned by a query in a simply string list.
862    Any NULL values are converted to the empty string.
863
864    If a result has 3 rows and each row contains two columns, then the
865    results are added to the list as follows (the value is parentheses
866    is the 1-based index in the final list):
867
868      row 1, col 2 (6)
869      row 1, col 1 (5)
870      row 2, col 2 (4)
871      row 2, col 1 (3)
872      row 3, col 2 (2)
873      row 3, col 1 (1)
874
875    This is because add_to_strlist pushes the results onto the front of
876    the list.  The end result is that the rows are backwards, but the
877    columns are in the expected order.  */
878 static int
879 strings_collect_cb (void *cookie, int argc, char **argv, char **azColName)
880 {
881   int i;
882   strlist_t *strlist = cookie;
883
884   (void) azColName;
885
886   for (i = argc - 1; i >= 0; i --)
887     add_to_strlist (strlist, argv[i] ? argv[i] : "");
888
889   return 0;
890 }
891
892 static int
893 strings_collect_cb2 (void *cookie, int argc, char **argv, char **azColName,
894                      sqlite3_stmt *stmt)
895 {
896   (void) stmt;
897   return strings_collect_cb (cookie, argc, argv, azColName);
898
899 }
900
901 /* Auxiliary data structure to collect statistics about
902    signatures.  */
903 struct signature_stats
904 {
905   struct signature_stats *next;
906
907   /* The user-assigned policy for this binding.  */
908   enum tofu_policy policy;
909
910   /* How long ago the signature was created (rounded to a multiple of
911      TIME_AGO_UNIT_SMALL, etc.).  */
912   long time_ago;
913   /* Number of signatures during this time.  */
914   unsigned long count;
915
916   /* The key that generated this signature.  */
917   char fingerprint[1];
918 };
919
920 static void
921 signature_stats_free (struct signature_stats *stats)
922 {
923   while (stats)
924     {
925       struct signature_stats *next = stats->next;
926       xfree (stats);
927       stats = next;
928     }
929 }
930
931 static void
932 signature_stats_prepend (struct signature_stats **statsp,
933                          const char *fingerprint,
934                          enum tofu_policy policy,
935                          long time_ago,
936                          unsigned long count)
937 {
938   struct signature_stats *stats =
939     xmalloc (sizeof (*stats) + strlen (fingerprint));
940
941   stats->next = *statsp;
942   *statsp = stats;
943
944   strcpy (stats->fingerprint, fingerprint);
945   stats->policy = policy;
946   stats->time_ago = time_ago;
947   stats->count = count;
948 }
949
950
951 /* Process rows that contain the four columns:
952
953      <fingerprint, policy, time ago, count>.  */
954 static int
955 signature_stats_collect_cb (void *cookie, int argc, char **argv,
956                             char **azColName, sqlite3_stmt *stmt)
957 {
958   struct signature_stats **statsp = cookie;
959   int i = 0;
960   enum tofu_policy policy;
961   long time_ago;
962   unsigned long count;
963   long along;
964
965   (void) azColName;
966   (void) stmt;
967
968   i ++;
969
970   if (string_to_long (&along, argv[i], 0, __LINE__))
971     return 1;  /* Abort */
972   policy = along;
973   i ++;
974
975   if (! argv[i])
976     time_ago = 0;
977   else
978     {
979       if (string_to_long (&time_ago, argv[i], 0, __LINE__))
980         return 1; /* Abort.  */
981     }
982   i ++;
983
984   /* If time_ago is NULL, then we had no messages, but we still have a
985      single row, which count(*) turns into 1.  */
986   if (! argv[i - 1])
987     count = 0;
988   else
989     {
990       if (string_to_ulong (&count, argv[i], 0, __LINE__))
991         return 1; /* Abort */
992     }
993   i ++;
994
995   log_assert (argc == i);
996
997   signature_stats_prepend (statsp, argv[0], policy, time_ago, count);
998
999   return 0;
1000 }
1001
1002 /* Convert from seconds to time units.
1003
1004    Note: T should already be a multiple of TIME_AGO_UNIT_SMALL or
1005    TIME_AGO_UNIT_MEDIUM or TIME_AGO_UNIT_LARGE.  */
1006 signed long
1007 time_ago_scale (signed long t)
1008 {
1009   if (t < TIME_AGO_UNIT_MEDIUM)
1010     return t / TIME_AGO_UNIT_SMALL;
1011   if (t < TIME_AGO_UNIT_LARGE)
1012     return t / TIME_AGO_UNIT_MEDIUM;
1013   return t / TIME_AGO_UNIT_LARGE;
1014 }
1015
1016
1017 /* Return the policy for the binding <FINGERPRINT, EMAIL> (email has
1018    already been normalized) and any conflict information in *CONFLICT
1019    if CONFLICT is not NULL.  Returns _tofu_GET_POLICY_ERROR if an error
1020    occurs.  */
1021 static enum tofu_policy
1022 get_policy (tofu_dbs_t dbs, const char *fingerprint, const char *email,
1023             char **conflict)
1024 {
1025   int rc;
1026   char *err = NULL;
1027   strlist_t strlist = NULL;
1028   enum tofu_policy policy = _tofu_GET_POLICY_ERROR;
1029   long along;
1030
1031   /* Check if the <FINGERPRINT, EMAIL> binding is known
1032      (TOFU_POLICY_NONE cannot appear in the DB.  Thus, if POLICY is
1033      still TOFU_POLICY_NONE after executing the query, then the
1034      result set was empty.)  */
1035   rc = gpgsql_stepx (dbs->db, &dbs->s.get_policy_select_policy_and_conflict,
1036                       strings_collect_cb2, &strlist, &err,
1037                       "select policy, conflict from bindings\n"
1038                       " where fingerprint = ? and email = ?",
1039                       SQLITE_ARG_STRING, fingerprint,
1040                       SQLITE_ARG_STRING, email,
1041                       SQLITE_ARG_END);
1042   if (rc)
1043     {
1044       log_error (_("error reading TOFU database: %s\n"), err);
1045       print_further_info ("checking for existing bad bindings");
1046       sqlite3_free (err);
1047       goto out;
1048     }
1049
1050   if (strlist_length (strlist) == 0)
1051     /* No results.  */
1052     {
1053       policy = TOFU_POLICY_NONE;
1054       goto out;
1055     }
1056   else if (strlist_length (strlist) != 2)
1057     /* The result has the wrong form.  */
1058     {
1059       log_error (_("error reading TOFU database: %s\n"),
1060                  gpg_strerror (GPG_ERR_BAD_DATA));
1061       print_further_info ("checking for existing bad bindings:"
1062                           " expected 2 results, got %d\n",
1063                           strlist_length (strlist));
1064       goto out;
1065     }
1066
1067   /* The result has the right form.  */
1068
1069   if (string_to_long (&along, strlist->d, 0, __LINE__))
1070     {
1071       log_error (_("error reading TOFU database: %s\n"),
1072                  gpg_strerror (GPG_ERR_BAD_DATA));
1073       print_further_info ("bad value for policy: %s", strlist->d);
1074       goto out;
1075     }
1076   policy = along;
1077
1078   if (! (policy == TOFU_POLICY_AUTO
1079          || policy == TOFU_POLICY_GOOD
1080          || policy == TOFU_POLICY_UNKNOWN
1081          || policy == TOFU_POLICY_BAD
1082          || policy == TOFU_POLICY_ASK))
1083     {
1084       log_error (_("error reading TOFU database: %s\n"),
1085                  gpg_strerror (GPG_ERR_DB_CORRUPTED));
1086       print_further_info ("invalid value for policy (%d)", policy);
1087       policy = _tofu_GET_POLICY_ERROR;
1088       goto out;
1089     }
1090
1091
1092   /* If CONFLICT is set, then policy should be TOFU_POLICY_ASK.  But,
1093      just in case, we do the check again here and ignore the conflict
1094      if POLICY is not TOFU_POLICY_ASK.  */
1095   if (conflict)
1096     {
1097       if (policy == TOFU_POLICY_ASK && *strlist->next->d)
1098         *conflict = xstrdup (strlist->next->d);
1099       else
1100         *conflict = NULL;
1101     }
1102
1103  out:
1104   log_assert (policy == _tofu_GET_POLICY_ERROR
1105               || policy == TOFU_POLICY_NONE
1106               || policy == TOFU_POLICY_AUTO
1107               || policy == TOFU_POLICY_GOOD
1108               || policy == TOFU_POLICY_UNKNOWN
1109               || policy == TOFU_POLICY_BAD
1110               || policy == TOFU_POLICY_ASK);
1111
1112   free_strlist (strlist);
1113
1114   return policy;
1115 }
1116
1117
1118 /* Format the first part of a conflict message and return that as a
1119  * malloced string.  */
1120 static char *
1121 format_conflict_msg_part1 (int policy, const char *conflict,
1122                            const char *fingerprint, const char *email)
1123 {
1124   estream_t fp;
1125   char *binding;
1126   int binding_shown = 0;
1127   char *tmpstr, *text;
1128
1129   binding = xasprintf ("<%s, %s>", fingerprint, email);
1130
1131   fp = es_fopenmem (0, "rw,samethread");
1132   if (!fp)
1133     log_fatal ("error creating memory stream: %s\n",
1134                gpg_strerror (gpg_error_from_syserror()));
1135
1136   if (policy == TOFU_POLICY_NONE)
1137     {
1138       es_fprintf (fp, _("The binding %s is NOT known."), binding);
1139       es_fputs ("  ", fp);
1140       binding_shown = 1;
1141     }
1142   else if (policy == TOFU_POLICY_ASK
1143            /* If there the conflict is with itself, then don't
1144             * display this message.  */
1145            && conflict && strcmp (conflict, fingerprint))
1146     {
1147       es_fprintf (fp,
1148                   _("The key with fingerprint %s raised a conflict "
1149                     "with the binding %s."
1150                     "  Since this binding's policy was 'auto', it was "
1151                     "changed to 'ask'."),
1152                   conflict, binding);
1153       es_fputs ("  ", fp);
1154       binding_shown = 1;
1155     }
1156
1157   /* TRANSLATORS: The %s%s is replaced by either a fingerprint and a
1158      blank or by two empty strings.  */
1159   es_fprintf (fp,
1160               _("Please indicate whether you believe the binding %s%s"
1161                 "is legitimate (the key belongs to the stated owner) "
1162                 "or a forgery (bad)."),
1163               binding_shown ? "" : binding,
1164               binding_shown ? "" : " ");
1165   es_fputc ('\n', fp);
1166
1167   xfree (binding);
1168
1169   es_fputc (0, fp);
1170   if (es_fclose_snatch (fp, (void **)&tmpstr, NULL))
1171     log_fatal ("error snatching memory stream\n");
1172   text = format_text (tmpstr, 0, 72, 80);
1173   es_free (tmpstr);
1174
1175   return text;
1176 }
1177
1178
1179 /* Ask the user about the binding.  There are three ways we could end
1180  * up here:
1181  *
1182  *   - This is a new binding and there is a conflict
1183  *     (policy == TOFU_POLICY_NONE && bindings_with_this_email_count > 0),
1184  *
1185  *   - This is a new binding and opt.tofu_default_policy is set to
1186  *     ask.  (policy == TOFU_POLICY_NONE && opt.tofu_default_policy ==
1187  *     TOFU_POLICY_ASK), or,
1188  *
1189  *   - The policy is ask (the user deferred last time) (policy ==
1190  *     TOFU_POLICY_ASK).
1191  */
1192 static void
1193 ask_about_binding (tofu_dbs_t dbs,
1194                    enum tofu_policy *policy,
1195                    int *trust_level,
1196                    int bindings_with_this_email_count,
1197                    strlist_t bindings_with_this_email,
1198                    char *conflict,
1199                    const char *fingerprint,
1200                    const char *email,
1201                    const char *user_id)
1202 {
1203   char *sqerr = NULL;
1204   int rc;
1205   estream_t fp;
1206   strlist_t other_user_ids = NULL;
1207   struct signature_stats *stats = NULL;
1208   struct signature_stats *stats_iter = NULL;
1209   char *prompt;
1210   char *choices;
1211
1212   fp = es_fopenmem (0, "rw,samethread");
1213   if (!fp)
1214     log_fatal ("error creating memory stream: %s\n",
1215                gpg_strerror (gpg_error_from_syserror()));
1216
1217   {
1218     char *text = format_conflict_msg_part1 (*policy, conflict,
1219                                             fingerprint, email);
1220     es_fputs (text, fp);
1221     es_fputc ('\n', fp);
1222     xfree (text);
1223   }
1224
1225   /* Find other user ids associated with this key and whether the
1226    * bindings are marked as good or bad.  */
1227   rc = gpgsql_stepx
1228     (dbs->db, &dbs->s.get_trust_gather_other_user_ids,
1229      strings_collect_cb2, &other_user_ids, &sqerr,
1230      "select user_id, policy from bindings where fingerprint = ?;",
1231      SQLITE_ARG_STRING, fingerprint, SQLITE_ARG_END);
1232   if (rc)
1233     {
1234       log_error (_("error gathering other user IDs: %s\n"), sqerr);
1235       sqlite3_free (sqerr);
1236       sqerr = NULL;
1237     }
1238
1239   if (other_user_ids)
1240     {
1241       strlist_t strlist_iter;
1242
1243       es_fprintf (fp, _("Known user IDs associated with this key:\n"));
1244       for (strlist_iter = other_user_ids;
1245            strlist_iter;
1246            strlist_iter = strlist_iter->next)
1247         {
1248           char *other_user_id = strlist_iter->d;
1249           char *other_thing;
1250           enum tofu_policy other_policy;
1251
1252           log_assert (strlist_iter->next);
1253           strlist_iter = strlist_iter->next;
1254           other_thing = strlist_iter->d;
1255
1256           other_policy = atoi (other_thing);
1257
1258           es_fprintf (fp, "  %s (", other_user_id);
1259           es_fprintf (fp, _("policy: %s"), tofu_policy_str (other_policy));
1260           es_fprintf (fp, ")\n");
1261         }
1262       es_fprintf (fp, "\n");
1263
1264       free_strlist (other_user_ids);
1265     }
1266
1267   /* Find other keys associated with this email address.  */
1268   /* FIXME: When generating the statistics, do we want the time
1269      embedded in the signature (column 'sig_time') or the time that
1270      we first verified the signature (column 'time').  */
1271   rc = gpgsql_stepx
1272     (dbs->db, &dbs->s.get_trust_gather_other_keys,
1273      signature_stats_collect_cb, &stats, &sqerr,
1274      "select fingerprint, policy, time_ago, count(*)\n"
1275      " from (select bindings.*,\n"
1276      "        case\n"
1277      /* From the future (but if its just a couple of hours in the
1278       * future don't turn it into a warning)?  Or should we use
1279       * small, medium or large units?  (Note: whatever we do, we
1280       * keep the value in seconds.  Then when we group, everything
1281       * that rounds to the same number of seconds is grouped.)  */
1282      "         when delta < -("STRINGIFY (TIME_AGO_FUTURE_IGNORE)") then -1\n"
1283      "         when delta < ("STRINGIFY (TIME_AGO_MEDIUM_THRESHOLD)")\n"
1284      "          then max(0,\n"
1285      "                   round(delta / ("STRINGIFY (TIME_AGO_UNIT_SMALL)"))\n"
1286      "               * ("STRINGIFY (TIME_AGO_UNIT_SMALL)"))\n"
1287      "         when delta < ("STRINGIFY (TIME_AGO_LARGE_THRESHOLD)")\n"
1288      "          then round(delta / ("STRINGIFY (TIME_AGO_UNIT_MEDIUM)"))\n"
1289      "               * ("STRINGIFY (TIME_AGO_UNIT_MEDIUM)")\n"
1290      "         else round(delta / ("STRINGIFY (TIME_AGO_UNIT_LARGE)"))\n"
1291      "              * ("STRINGIFY (TIME_AGO_UNIT_LARGE)")\n"
1292      "        end time_ago,\n"
1293      "        delta time_ago_raw\n"
1294      "       from bindings\n"
1295      "       left join\n"
1296      "         (select *,\n"
1297      "            cast(strftime('%s','now') - sig_time as real) delta\n"
1298      "           from signatures) ss\n"
1299      "        on ss.binding = bindings.oid)\n"
1300      " where email = ?\n"
1301      " group by fingerprint, time_ago\n"
1302      /* Make sure the current key is first.  */
1303      " order by fingerprint = ? asc, fingerprint desc, time_ago desc;\n",
1304      SQLITE_ARG_STRING, email, SQLITE_ARG_STRING, fingerprint,
1305      SQLITE_ARG_END);
1306   if (rc)
1307     {
1308       strlist_t strlist_iter;
1309
1310       log_error (_("error gathering signature stats: %s\n"), sqerr);
1311       sqlite3_free (sqerr);
1312       sqerr = NULL;
1313
1314       es_fprintf (fp, ngettext("The email address \"%s\" is"
1315                                " associated with %d key:\n",
1316                                "The email address \"%s\" is"
1317                                " associated with %d keys:\n",
1318                                bindings_with_this_email_count),
1319                   email, bindings_with_this_email_count);
1320       for (strlist_iter = bindings_with_this_email;
1321            strlist_iter;
1322            strlist_iter = strlist_iter->next)
1323         es_fprintf (fp, "  %s\n", strlist_iter->d);
1324     }
1325   else
1326     {
1327       char *key = NULL;
1328
1329       if (! stats || strcmp (stats->fingerprint, fingerprint))
1330         {
1331           /* If we have already added this key to the DB, then it will
1332            * be first (see the above select).  Since the first key on
1333            * the list is not this key, we must not yet have verified any
1334            * messages signed by this key.  Add a dummy entry.  */
1335           signature_stats_prepend (&stats, fingerprint, TOFU_POLICY_AUTO, 0, 0);
1336         }
1337
1338       es_fprintf (fp, _("Statistics for keys with the email address \"%s\":\n"),
1339                   email);
1340       for (stats_iter = stats; stats_iter; stats_iter = stats_iter->next)
1341         {
1342           if (! key || strcmp (key, stats_iter->fingerprint))
1343             {
1344               int this_key;
1345               char *key_pp;
1346
1347               key = stats_iter->fingerprint;
1348               this_key = strcmp (key, fingerprint) == 0;
1349               key_pp = format_hexfingerprint (key, NULL, 0);
1350               es_fprintf (fp, "  %s (", key_pp);
1351               if (this_key)
1352                 es_fprintf (fp, _("this key"));
1353               else
1354                 es_fprintf (fp, _("policy: %s"),
1355                             tofu_policy_str (stats_iter->policy));
1356               es_fputs ("):\n", fp);
1357               xfree (key_pp);
1358             }
1359
1360           es_fputs ("    ", fp);
1361           if (stats_iter->time_ago == -1)
1362             es_fprintf (fp, ngettext("%ld message signed in the future.",
1363                                      "%ld messages signed in the future.",
1364                                      stats_iter->count), stats_iter->count);
1365           else
1366             {
1367               long t_scaled = time_ago_scale (stats_iter->time_ago);
1368
1369               /* TANSLATORS: This string is concatenated with one of
1370                * the day/week/month strings to form one sentence.  */
1371               es_fprintf (fp, ngettext("%ld message signed",
1372                                        "%ld messages signed",
1373                                        stats_iter->count), stats_iter->count);
1374               if (!stats_iter->count)
1375                 es_fputs (".", fp);
1376               else if (stats_iter->time_ago < TIME_AGO_UNIT_MEDIUM)
1377                 es_fprintf (fp, ngettext(" over the past %ld day.",
1378                                          " over the past %ld days.",
1379                                          t_scaled), t_scaled);
1380               else if (stats_iter->time_ago < TIME_AGO_UNIT_LARGE)
1381                 es_fprintf (fp, ngettext(" over the past %ld week.",
1382                                          " over the past %ld weeks.",
1383                                          t_scaled), t_scaled);
1384               else
1385                 es_fprintf (fp, ngettext(" over the past %ld month.",
1386                                          " over the past %ld months.",
1387                                          t_scaled), t_scaled);
1388             }
1389           es_fputs ("\n", fp);
1390         }
1391     }
1392
1393
1394   if ((*policy == TOFU_POLICY_NONE && bindings_with_this_email_count > 0)
1395       || (*policy == TOFU_POLICY_ASK
1396           && (conflict || bindings_with_this_email_count > 0)))
1397     {
1398       /* This is a conflict.  */
1399
1400       /* TRANSLATORS: Please translate the text found in the source
1401        * file below.  We don't directly internationalize that text so
1402        * that we can tweak it without breaking translations.  */
1403       char *text = _("TOFU detected a binding conflict");
1404       char *textbuf;
1405       if (!strcmp (text, "TOFU detected a binding conflict"))
1406         {
1407           /* No translation.  Use the English text.  */
1408           text =
1409             "Normally, there is only a single key associated with an email "
1410             "address.  However, people sometimes generate a new key if "
1411             "their key is too old or they think it might be compromised.  "
1412             "Alternatively, a new key may indicate a man-in-the-middle "
1413             "attack!  Before accepting this key, you should talk to or "
1414             "call the person to make sure this new key is legitimate.";
1415         }
1416       textbuf = format_text (text, 0, 72, 80);
1417       es_fprintf (fp, "\n%s\n", textbuf);
1418       xfree (textbuf);
1419     }
1420
1421   es_fputc ('\n', fp);
1422
1423   /* Add a NUL terminator.  */
1424   es_fputc (0, fp);
1425   if (es_fclose_snatch (fp, (void **) &prompt, NULL))
1426     log_fatal ("error snatching memory stream\n");
1427
1428   /* I think showing the large message once is sufficient.  If we
1429    * would move it right before the cpr_get many lines will scroll
1430    * away and the user might not realize that he merely entered a
1431    * wrong choise (because he does not see that either).  As a small
1432    * benefit we allow C-L to redisplay everything.  */
1433   tty_printf ("%s", prompt);
1434   while (1)
1435     {
1436       char *response;
1437
1438       /* TRANSLATORS: Two letters (normally the lower and upper case
1439        * version of the hotkey) for each of the five choices.  If
1440        * there is only one choice in your language, repeat it.  */
1441       choices = _("gG" "aA" "uU" "rR" "bB");
1442       if (strlen (choices) != 10)
1443         log_bug ("Bad TOFU conflict translation!  Please report.");
1444
1445       response = cpr_get
1446         ("tofu.conflict",
1447          _("(G)ood, (A)ccept once, (U)nknown, (R)eject once, (B)ad? "));
1448       trim_spaces (response);
1449       cpr_kill_prompt ();
1450       if (*response == CONTROL_L)
1451         tty_printf ("%s", prompt);
1452       else if (strlen (response) == 1)
1453         {
1454           char *choice = strchr (choices, *response);
1455           if (choice)
1456             {
1457               int c = ((size_t) choice - (size_t) choices) / 2;
1458
1459               switch (c)
1460                 {
1461                 case 0: /* Good.  */
1462                   *policy = TOFU_POLICY_GOOD;
1463                   *trust_level = tofu_policy_to_trust_level (*policy);
1464                   break;
1465                 case 1: /* Accept once.  */
1466                   *policy = TOFU_POLICY_ASK;
1467                   *trust_level = tofu_policy_to_trust_level (TOFU_POLICY_GOOD);
1468                   break;
1469                 case 2: /* Unknown.  */
1470                   *policy = TOFU_POLICY_UNKNOWN;
1471                   *trust_level = tofu_policy_to_trust_level (*policy);
1472                   break;
1473                 case 3: /* Reject once.  */
1474                   *policy = TOFU_POLICY_ASK;
1475                   *trust_level = tofu_policy_to_trust_level (TOFU_POLICY_BAD);
1476                   break;
1477                 case 4: /* Bad.  */
1478                   *policy = TOFU_POLICY_BAD;
1479                   *trust_level = tofu_policy_to_trust_level (*policy);
1480                   break;
1481                 default:
1482                   log_bug ("c should be between 0 and 4 but it is %d!", c);
1483                 }
1484
1485               if (record_binding (dbs, fingerprint, email, user_id,
1486                                   *policy, 0))
1487                 {
1488                   /* If there's an error registering the
1489                    * binding, don't save the signature.  */
1490                   *trust_level = _tofu_GET_TRUST_ERROR;
1491                 }
1492               break;
1493             }
1494         }
1495       xfree (response);
1496     }
1497
1498   xfree (prompt);
1499
1500   signature_stats_free (stats);
1501 }
1502
1503
1504 /* Return the trust level (TRUST_NEVER, etc.) for the binding
1505  * <FINGERPRINT, EMAIL> (email is already normalized).  If no policy
1506  * is registered, returns TOFU_POLICY_NONE.  If an error occurs,
1507  * returns _tofu_GET_TRUST_ERROR.
1508  *
1509  * PK is the public key object for FINGERPRINT.
1510  *
1511  * USER_ID is the unadulterated user id.
1512  *
1513  * If MAY_ASK is set, then we may interact with the user.  This is
1514  * necessary if there is a conflict or the binding's policy is
1515  * TOFU_POLICY_ASK.  In the case of a conflict, we set the new
1516  * conflicting binding's policy to TOFU_POLICY_ASK.  In either case,
1517  * we return TRUST_UNDEFINED.  */
1518 static enum tofu_policy
1519 get_trust (tofu_dbs_t dbs, PKT_public_key *pk,
1520            const char *fingerprint, const char *email,
1521            const char *user_id, int may_ask)
1522 {
1523   enum tofu_policy policy;
1524   char *conflict = NULL;
1525   int rc;
1526   char *sqerr = NULL;
1527   strlist_t bindings_with_this_email = NULL;
1528   int bindings_with_this_email_count;
1529   int change_conflicting_to_ask = 0;
1530   int trust_level = TRUST_UNKNOWN;
1531
1532   if (opt.batch)
1533     may_ask = 0;
1534
1535   /* Make sure _tofu_GET_TRUST_ERROR isn't equal to any of the trust
1536      levels.  */
1537   log_assert (_tofu_GET_TRUST_ERROR != TRUST_UNKNOWN
1538               && _tofu_GET_TRUST_ERROR != TRUST_EXPIRED
1539               && _tofu_GET_TRUST_ERROR != TRUST_UNDEFINED
1540               && _tofu_GET_TRUST_ERROR != TRUST_NEVER
1541               && _tofu_GET_TRUST_ERROR != TRUST_MARGINAL
1542               && _tofu_GET_TRUST_ERROR != TRUST_FULLY
1543               && _tofu_GET_TRUST_ERROR != TRUST_ULTIMATE);
1544
1545   policy = get_policy (dbs, fingerprint, email, &conflict);
1546   if (policy == TOFU_POLICY_AUTO || policy == TOFU_POLICY_NONE)
1547     { /* See if the key is ultimately trusted.  If so, we're done.  */
1548       u32 kid[2];
1549
1550       keyid_from_pk (pk, kid);
1551
1552       if (tdb_keyid_is_utk (kid))
1553         {
1554           if (policy == TOFU_POLICY_NONE)
1555             {
1556               if (record_binding (dbs, fingerprint, email, user_id,
1557                                   TOFU_POLICY_AUTO, 0) != 0)
1558                 {
1559                   log_error (_("error setting TOFU binding's trust level"
1560                                " to %s\n"), "auto");
1561                   trust_level = _tofu_GET_TRUST_ERROR;
1562                   goto out;
1563                 }
1564             }
1565
1566           trust_level = TRUST_ULTIMATE;
1567           goto out;
1568         }
1569     }
1570
1571   if (policy == TOFU_POLICY_AUTO)
1572     {
1573       policy = opt.tofu_default_policy;
1574       if (DBG_TRUST)
1575         log_debug ("TOFU: binding <key: %s, user id: %s>'s policy is "
1576                    " auto (default: %s).\n",
1577                    fingerprint, email,
1578                    tofu_policy_str (opt.tofu_default_policy));
1579     }
1580   switch (policy)
1581     {
1582     case TOFU_POLICY_AUTO:
1583     case TOFU_POLICY_GOOD:
1584     case TOFU_POLICY_UNKNOWN:
1585     case TOFU_POLICY_BAD:
1586       /* The saved judgement is auto -> auto, good, unknown or bad.
1587        * We don't need to ask the user anything.  */
1588       if (DBG_TRUST)
1589         log_debug ("TOFU: Known binding <key: %s, user id: %s>'s policy: %s\n",
1590                    fingerprint, email, tofu_policy_str (policy));
1591       trust_level = tofu_policy_to_trust_level (policy);
1592       goto out;
1593
1594     case TOFU_POLICY_ASK:
1595       /* We need to ask the user what to do.  Case #1 or #2 below.  */
1596       if (! may_ask)
1597         {
1598           trust_level = TRUST_UNDEFINED;
1599           goto out;
1600         }
1601
1602       break;
1603
1604     case TOFU_POLICY_NONE:
1605       /* The binding is new, we need to check for conflicts.  Case #3
1606        * below.  */
1607       break;
1608
1609     case _tofu_GET_POLICY_ERROR:
1610       trust_level = _tofu_GET_TRUST_ERROR;
1611       goto out;
1612
1613     default:
1614       log_bug ("%s: Impossible value for policy (%d)\n", __func__, policy);
1615     }
1616
1617
1618   /* We get here if:
1619    *
1620    *   1. The saved policy is auto and the default policy is ask
1621    *      (get_policy() == TOFU_POLICY_AUTO
1622    *       && opt.tofu_default_policy == TOFU_POLICY_ASK)
1623    *
1624    *   2. The saved policy is ask (either last time the user selected
1625    *      accept once or reject once or there was a conflict and this
1626    *      binding's policy was changed from auto to ask)
1627    *      (policy == TOFU_POLICY_ASK), or,
1628    *
1629    *   3. We don't have a saved policy (policy == TOFU_POLICY_NONE)
1630    *      (need to check for a conflict).
1631    */
1632
1633   /* Look for conflicts.  This is needed in all 3 cases.
1634    *
1635    * Get the fingerprints of any bindings that share the email
1636    * address.  Note: if the binding in question is in the DB, it will
1637    * also be returned.  Thus, if the result set is empty, then this is
1638    * a new binding.  */
1639   rc = gpgsql_stepx
1640     (dbs->db, &dbs->s.get_trust_bindings_with_this_email,
1641      strings_collect_cb2, &bindings_with_this_email, &sqerr,
1642      "select distinct fingerprint from bindings where email = ?;",
1643      SQLITE_ARG_STRING, email, SQLITE_ARG_END);
1644   if (rc)
1645     {
1646       log_error (_("error reading TOFU database: %s\n"), sqerr);
1647       print_further_info ("listing fingerprints");
1648       sqlite3_free (sqerr);
1649       goto out;
1650     }
1651
1652   bindings_with_this_email_count = strlist_length (bindings_with_this_email);
1653   if (bindings_with_this_email_count == 0
1654       && opt.tofu_default_policy != TOFU_POLICY_ASK)
1655     {
1656       /* New binding with no conflict and a concrete default policy.
1657        *
1658        * We've never observed a binding with this email address
1659        * BINDINGS_WITH_THIS_EMAIL_COUNT is 0 and the above query would
1660        * return the current binding if it were in the DB) and we have
1661        * a default policy, which is not to ask the user.
1662        */
1663
1664       /* If we've seen this binding, then we've seen this email and
1665          policy couldn't possibly be TOFU_POLICY_NONE.  */
1666       log_assert (policy == TOFU_POLICY_NONE);
1667
1668       if (DBG_TRUST)
1669         log_debug ("TOFU: New binding <key: %s, user id: %s>, no conflict.\n",
1670                    fingerprint, email);
1671
1672       if (record_binding (dbs, fingerprint, email, user_id,
1673                           TOFU_POLICY_AUTO, 0) != 0)
1674         {
1675           log_error (_("error setting TOFU binding's trust level to %s\n"),
1676                        "auto");
1677           trust_level = _tofu_GET_TRUST_ERROR;
1678           goto out;
1679         }
1680
1681       trust_level = tofu_policy_to_trust_level (TOFU_POLICY_AUTO);
1682       goto out;
1683     }
1684
1685   if (policy == TOFU_POLICY_NONE)
1686     {
1687       /* This is a new binding and we have a conflict.  Mark any
1688        * conflicting bindings that have an automatic policy as now
1689        * requiring confirmation.  Note: we delay this until after we
1690        * ask for confirmation so that when the current policy is
1691        * printed, it is correct.  */
1692       change_conflicting_to_ask = 1;
1693     }
1694
1695   if (! may_ask)
1696     {
1697       /* We can only get here in the third case (no saved policy) and
1698        * if there is a conflict.  (If the policy was ask (cases #1 and
1699        * #2) and we weren't allowed to ask, we'd have already exited).  */
1700       log_assert (policy == TOFU_POLICY_NONE);
1701
1702       if (record_binding (dbs, fingerprint, email, user_id,
1703                           TOFU_POLICY_ASK, 0) != 0)
1704         log_error (_("error setting TOFU binding's trust level to %s\n"),
1705                    "ask");
1706
1707       trust_level = TRUST_UNDEFINED;
1708       goto out;
1709     }
1710
1711   /* If we get here, we need to ask the user about the binding.  */
1712   ask_about_binding (dbs,
1713                      &policy,
1714                      &trust_level,
1715                      bindings_with_this_email_count,
1716                      bindings_with_this_email,
1717                      conflict,
1718                      fingerprint,
1719                      email,
1720                      user_id);
1721
1722  out:
1723   if (change_conflicting_to_ask)
1724     {
1725       if (! may_ask)
1726         {
1727           /* If we weren't allowed to ask, also update this key as
1728              conflicting with itself.  */
1729           rc = gpgsql_exec_printf
1730             (dbs->db, NULL, NULL, &sqerr,
1731              "update bindings set policy = %d, conflict = %Q"
1732              " where email = %Q"
1733              "  and (policy = %d or (policy = %d and fingerprint = %Q));",
1734              TOFU_POLICY_ASK, fingerprint, email, TOFU_POLICY_AUTO,
1735              TOFU_POLICY_ASK, fingerprint);
1736         }
1737       else
1738         {
1739           rc = gpgsql_exec_printf
1740             (dbs->db, NULL, NULL, &sqerr,
1741              "update bindings set policy = %d, conflict = %Q"
1742              " where email = %Q and fingerprint != %Q and policy = %d;",
1743              TOFU_POLICY_ASK, fingerprint, email, fingerprint,
1744              TOFU_POLICY_AUTO);
1745         }
1746
1747       if (rc)
1748         {
1749           log_error (_("error changing TOFU policy: %s\n"), sqerr);
1750           sqlite3_free (sqerr);
1751           sqerr = NULL;
1752         }
1753     }
1754
1755   xfree (conflict);
1756   free_strlist (bindings_with_this_email);
1757
1758   return trust_level;
1759 }
1760
1761
1762 /* Return a malloced string of the form
1763  *    "7 months, 1 day, 5 minutes, 0 seconds"
1764  * The caller should replace all '~' in the returned string by a space
1765  * and also free the returned string.
1766  *
1767  * This is actually a bad hack which may not work correctly with all
1768  * languages.
1769  */
1770 static char *
1771 time_ago_str (long long int t)
1772 {
1773   estream_t fp;
1774   int years = 0;
1775   int months = 0;
1776   int days = 0;
1777   int hours = 0;
1778   int minutes = 0;
1779   int seconds = 0;
1780
1781   /* The number of units that we've printed so far.  */
1782   int count = 0;
1783   /* The first unit that we printed (year = 0, month = 1,
1784      etc.).  */
1785   int first = -1;
1786   /* The current unit.  */
1787   int i = 0;
1788
1789   char *str;
1790
1791   /* It would be nice to use a macro to do this, but gettext
1792      works on the unpreprocessed code.  */
1793 #define MIN_SECS (60)
1794 #define HOUR_SECS (60 * MIN_SECS)
1795 #define DAY_SECS (24 * HOUR_SECS)
1796 #define MONTH_SECS (30 * DAY_SECS)
1797 #define YEAR_SECS (365 * DAY_SECS)
1798
1799   if (t > YEAR_SECS)
1800     {
1801       years = t / YEAR_SECS;
1802       t -= years * YEAR_SECS;
1803     }
1804   if (t > MONTH_SECS)
1805     {
1806       months = t / MONTH_SECS;
1807       t -= months * MONTH_SECS;
1808     }
1809   if (t > DAY_SECS)
1810     {
1811       days = t / DAY_SECS;
1812       t -= days * DAY_SECS;
1813     }
1814   if (t > HOUR_SECS)
1815     {
1816       hours = t / HOUR_SECS;
1817       t -= hours * HOUR_SECS;
1818     }
1819   if (t > MIN_SECS)
1820     {
1821       minutes = t / MIN_SECS;
1822       t -= minutes * MIN_SECS;
1823     }
1824   seconds = t;
1825
1826 #undef MIN_SECS
1827 #undef HOUR_SECS
1828 #undef DAY_SECS
1829 #undef MONTH_SECS
1830 #undef YEAR_SECS
1831
1832   fp = es_fopenmem (0, "rw,samethread");
1833   if (! fp)
1834     log_fatal ("error creating memory stream: %s\n",
1835                gpg_strerror (gpg_error_from_syserror()));
1836
1837   if (years)
1838     {
1839       /* TRANSLATORS: The tilde ('~') is used here to indicate a
1840        * non-breakable space  */
1841       es_fprintf (fp, ngettext("%d~year", "%d~years", years), years);
1842       count ++;
1843       first = i;
1844     }
1845   i ++;
1846   if ((first == -1 || i - first <= 3) && months)
1847     {
1848       if (count)
1849         es_fprintf (fp, ", ");
1850       es_fprintf (fp, ngettext("%d~month", "%d~months", months), months);
1851       count ++;
1852       first = i;
1853     }
1854   i ++;
1855   if ((first == -1 || i - first <= 3) && count < 2 && days)
1856     {
1857       if (count)
1858         es_fprintf (fp, ", ");
1859       es_fprintf (fp, ngettext("%d~day", "%d~days", days), days);
1860       count ++;
1861       first = i;
1862     }
1863   i ++;
1864   if ((first == -1 || i - first <= 3) && count < 2 && hours)
1865     {
1866       if (count)
1867         es_fprintf (fp, ", ");
1868       es_fprintf (fp, ngettext("%d~hour", "%d~hours", hours), hours);
1869       count ++;
1870       first = i;
1871     }
1872   i ++;
1873   if ((first == -1 || i - first <= 3) && count < 2 && minutes)
1874     {
1875       if (count)
1876         es_fprintf (fp, ", ");
1877       es_fprintf (fp, ngettext("%d~minute", "%d~minutes", minutes), minutes);
1878       count ++;
1879       first = i;
1880     }
1881   i ++;
1882   if ((first == -1 || i - first <= 3) && count < 2)
1883     {
1884       if (count)
1885         es_fprintf (fp, ", ");
1886       es_fprintf (fp, ngettext("%d~second", "%d~seconds", seconds), seconds);
1887     }
1888
1889   es_fputc (0, fp);
1890   if (es_fclose_snatch (fp, (void **) &str, NULL))
1891     log_fatal ("error snatching memory stream\n");
1892
1893   return str;
1894 }
1895
1896
1897 /* If FP is NULL, write TOFU_STATS status line.  If FP is not NULL
1898  * write a "tfs" record to that stream. */
1899 static void
1900 write_stats_status (estream_t fp, long messages, enum tofu_policy policy,
1901                     unsigned long first_seen,
1902                     unsigned long most_recent_seen)
1903 {
1904   const char *validity;
1905
1906   if (messages < 1)
1907     validity = "1"; /* Key without history.  */
1908   else if (messages < BASIC_TRUST_THRESHOLD)
1909     validity = "2"; /* Key with too little history.  */
1910   else if (messages < FULL_TRUST_THRESHOLD)
1911     validity = "3"; /* Key with enough history for basic trust.  */
1912   else
1913     validity = "4"; /* Key with a lot of history.  */
1914
1915   if (fp)
1916     {
1917       es_fprintf (fp, "tfs:1:%s:%ld:0:%s:%lu:%lu:\n",
1918                   validity, messages,
1919                   tofu_policy_str (policy),
1920                   first_seen, most_recent_seen);
1921     }
1922   else
1923     {
1924       char numbuf1[35];
1925       char numbuf2[35];
1926       char numbuf3[35];
1927
1928       snprintf (numbuf1, sizeof numbuf1, " %ld", messages);
1929       *numbuf2 = *numbuf3 = 0;
1930       if (first_seen && most_recent_seen)
1931         {
1932           snprintf (numbuf2, sizeof numbuf2, " %lu", first_seen);
1933           snprintf (numbuf3, sizeof numbuf3, " %lu", most_recent_seen);
1934         }
1935
1936       write_status_strings (STATUS_TOFU_STATS,
1937                             validity, numbuf1, " 0",
1938                             " ", tofu_policy_str (policy),
1939                             numbuf2, numbuf3,
1940                             NULL);
1941     }
1942 }
1943
1944
1945 /* Note: If OUTFP is not NULL, this function merely prints a "tfs" record
1946  * to OUTFP.  In this case USER_ID is not required.  */
1947 static void
1948 show_statistics (tofu_dbs_t dbs, const char *fingerprint,
1949                  const char *email, const char *user_id,
1950                  const char *sig_exclude, estream_t outfp)
1951 {
1952   char *fingerprint_pp;
1953   int rc;
1954   strlist_t strlist = NULL;
1955   char *err = NULL;
1956
1957   fingerprint_pp = format_hexfingerprint (fingerprint, NULL, 0);
1958
1959   rc = gpgsql_exec_printf
1960     (dbs->db, strings_collect_cb, &strlist, &err,
1961      "select count (*), min (signatures.time), max (signatures.time)\n"
1962      " from signatures\n"
1963      " left join bindings on signatures.binding = bindings.oid\n"
1964      " where fingerprint = %Q and email = %Q and sig_digest %s%s%s;",
1965      fingerprint, email,
1966      /* We want either: sig_digest != 'SIG_EXCLUDE' or sig_digest is
1967         not NULL.  */
1968      sig_exclude ? "!= '" : "is not NULL",
1969      sig_exclude ? sig_exclude : "",
1970      sig_exclude ? "'" : "");
1971   if (rc)
1972     {
1973       log_error (_("error reading TOFU database: %s\n"), err);
1974       print_further_info ("getting statistics");
1975       sqlite3_free (err);
1976       goto out;
1977     }
1978
1979   if (!outfp)
1980     write_status_text_and_buffer (STATUS_TOFU_USER, fingerprint,
1981                                   email, strlen (email), 0);
1982
1983   if (! strlist)
1984     {
1985       if (!outfp)
1986         log_info (_("Have never verified a message signed by key %s!\n"),
1987                   fingerprint_pp);
1988       write_stats_status (outfp, 0, TOFU_POLICY_NONE, 0, 0);
1989     }
1990   else
1991     {
1992       unsigned long now = gnupg_get_time ();
1993       signed long messages;
1994       unsigned long first_seen;
1995       unsigned long most_recent_seen;
1996
1997       log_assert (strlist_length (strlist) == 3);
1998
1999       string_to_long (&messages, strlist->d, -1, __LINE__);
2000
2001       if (messages == 0 && *strlist->next->d == '\0')
2002         { /* min(NULL) => NULL => "".  */
2003           first_seen = 0;
2004           most_recent_seen = 0;
2005         }
2006       else
2007         {
2008           string_to_ulong (&first_seen, strlist->next->d, -1, __LINE__);
2009           if (first_seen > now)
2010             {
2011               log_debug ("time-warp - tofu DB has a future value (%lu, %lu)\n",
2012                          first_seen, now);
2013               first_seen = now;
2014             }
2015           string_to_ulong (&most_recent_seen, strlist->next->next->d, -1,
2016                            __LINE__);
2017           if (most_recent_seen > now)
2018             {
2019               log_debug ("time-warp - tofu DB has a future value (%lu, %lu)\n",
2020                          most_recent_seen, now);
2021               most_recent_seen = now;
2022             }
2023
2024         }
2025
2026       if (messages == -1 || !first_seen)
2027         {
2028           write_stats_status (outfp, 0, TOFU_POLICY_NONE, 0, 0);
2029           if (!outfp)
2030             log_info (_("Failed to collect signature statistics for \"%s\"\n"
2031                         "(key %s)\n"),
2032                       user_id, fingerprint_pp);
2033         }
2034       else if (outfp)
2035         {
2036           write_stats_status (outfp, messages,
2037                               get_policy (dbs, fingerprint, email, NULL),
2038                               first_seen, most_recent_seen);
2039         }
2040       else
2041         {
2042           enum tofu_policy policy = get_policy (dbs, fingerprint, email, NULL);
2043           estream_t fp;
2044           char *msg;
2045
2046           write_stats_status (NULL, messages,
2047                               policy,
2048                               first_seen, most_recent_seen);
2049
2050           fp = es_fopenmem (0, "rw,samethread");
2051           if (! fp)
2052             log_fatal ("error creating memory stream: %s\n",
2053                        gpg_strerror (gpg_error_from_syserror()));
2054
2055           if (messages == 0)
2056             {
2057               es_fprintf (fp, _("Verified %ld messages signed by \"%s\"."),
2058                           0L, user_id);
2059               es_fputc ('\n', fp);
2060             }
2061           else
2062             {
2063               char *first_seen_ago_str = time_ago_str (now - first_seen);
2064
2065               /* TRANSLATORS: The final %s is replaced by a string like
2066                  "7 months, 1 day, 5 minutes, 0 seconds". */
2067               es_fprintf (fp,
2068                           ngettext("Verified %ld message signed by \"%s\"\n"
2069                                    "in the past %s.",
2070                                    "Verified %ld messages signed by \"%s\"\n"
2071                                    "in the past %s.",
2072                                    messages),
2073                           messages, user_id, first_seen_ago_str);
2074
2075               if (messages > 1)
2076                 {
2077                   char *tmpstr = time_ago_str (now - most_recent_seen);
2078                   es_fputs ("  ", fp);
2079                   es_fprintf (fp, _("The most recent message was"
2080                                     " verified %s ago."), tmpstr);
2081                   xfree (tmpstr);
2082                 }
2083               xfree (first_seen_ago_str);
2084
2085               if (opt.verbose)
2086                 {
2087                   es_fputs ("  ", fp);
2088                   es_fputc ('(', fp);
2089                   es_fprintf (fp, _("policy: %s"), tofu_policy_str (policy));
2090                   es_fputs (")\n", fp);
2091                 }
2092               else
2093                 es_fputs ("\n", fp);
2094             }
2095
2096           {
2097             char *tmpmsg, *p;
2098             es_fputc (0, fp);
2099             if (es_fclose_snatch (fp, (void **) &tmpmsg, NULL))
2100               log_fatal ("error snatching memory stream\n");
2101             msg = format_text (tmpmsg, 0, 72, 80);
2102             es_free (tmpmsg);
2103
2104             /* Print a status line but suppress the trailing LF.
2105              * Spaces are not percent escaped. */
2106             if (*msg)
2107               write_status_buffer (STATUS_TOFU_STATS_LONG,
2108                                    msg, strlen (msg)-1, -1);
2109
2110             /* Remove the non-breaking space markers.  */
2111             for (p=msg; *p; p++)
2112               if (*p == '~')
2113                 *p = ' ';
2114
2115           }
2116
2117           log_string (GPGRT_LOG_INFO, msg);
2118           xfree (msg);
2119
2120           if (policy == TOFU_POLICY_AUTO && messages < BASIC_TRUST_THRESHOLD)
2121             {
2122               char *set_policy_command;
2123               char *text;
2124               char *tmpmsg;
2125
2126               if (messages == 0)
2127                 log_info (_("Warning: we've have yet to see"
2128                             " a message signed by this key!\n"));
2129               else if (messages == 1)
2130                 log_info (_("Warning: we've only seen a"
2131                             " single message signed by this key!\n"));
2132
2133               set_policy_command =
2134                 xasprintf ("gpg --tofu-policy bad %s", fingerprint);
2135
2136               tmpmsg = xasprintf
2137                 (ngettext
2138                  ("Warning: if you think you've seen more than %ld message "
2139                   "signed by this key, then this key might be a forgery!  "
2140                   "Carefully examine the email address for small "
2141                   "variations.  If the key is suspect, then use\n"
2142                   "  %s\n"
2143                   "to mark it as being bad.\n",
2144                   "Warning: if you think you've seen more than %ld messages "
2145                   "signed by this key, then this key might be a forgery!  "
2146                       "Carefully examine the email address for small "
2147                   "variations.  If the key is suspect, then use\n"
2148                   "  %s\n"
2149                   "to mark it as being bad.\n",
2150                   messages),
2151                   messages, set_policy_command);
2152               text = format_text (tmpmsg, 0, 72, 80);
2153               xfree (tmpmsg);
2154               log_string (GPGRT_LOG_INFO, text);
2155               xfree (text);
2156
2157               es_free (set_policy_command);
2158             }
2159         }
2160     }
2161
2162  out:
2163   free_strlist (strlist);
2164   xfree (fingerprint_pp);
2165
2166   return;
2167 }
2168
2169 /* Extract the email address from a user id and normalize it.  If the
2170    user id doesn't contain an email address, then we use the whole
2171    user_id and normalize that.  The returned string must be freed.  */
2172 static char *
2173 email_from_user_id (const char *user_id)
2174 {
2175   char *email = mailbox_from_userid (user_id);
2176   if (! email)
2177     {
2178       /* Hmm, no email address was provided or we are out of core.  Just
2179          take the lower-case version of the whole user id.  It could be
2180          a hostname, for instance.  */
2181       email = ascii_strlwr (xstrdup (user_id));
2182     }
2183
2184   return email;
2185 }
2186
2187 /* Register the signature with the bindings <fingerprint, USER_ID>,
2188    for each USER_ID in USER_ID_LIST.  The fingerprint is taken from
2189    the primary key packet PK.
2190
2191    SIG_DIGEST_BIN is the binary representation of the message's
2192    digest.  SIG_DIGEST_BIN_LEN is its length.
2193
2194    SIG_TIME is the time that the signature was generated.
2195
2196    ORIGIN is a free-formed string describing the origin of the
2197    signature.  If this was from an email and the Claws MUA was used,
2198    then this should be something like: "email:claws".  If this is
2199    NULL, the default is simply "unknown".
2200
2201    If MAY_ASK is 1, then this function may interact with the user.
2202    This is necessary if there is a conflict or the binding's policy is
2203    TOFU_POLICY_ASK.
2204
2205    This function returns 0 on success and an error code if an error
2206    occured.  */
2207 gpg_error_t
2208 tofu_register (ctrl_t ctrl, PKT_public_key *pk, strlist_t user_id_list,
2209                const byte *sig_digest_bin, int sig_digest_bin_len,
2210                time_t sig_time, const char *origin)
2211 {
2212   gpg_error_t rc;
2213   tofu_dbs_t dbs;
2214   char *fingerprint = NULL;
2215   strlist_t user_id;
2216   char *email = NULL;
2217   char *err = NULL;
2218   char *sig_digest;
2219   unsigned long c;
2220
2221   dbs = opendbs (ctrl);
2222   if (! dbs)
2223     {
2224       rc = gpg_error (GPG_ERR_GENERAL);
2225       log_error (_("error opening TOFU database: %s\n"),
2226                  gpg_strerror (rc));
2227       return rc;
2228     }
2229
2230   /* We do a query and then an insert.  Make sure they are atomic
2231      by wrapping them in a transaction.  */
2232   rc = begin_transaction (ctrl, 0);
2233   if (rc)
2234     return rc;
2235
2236   sig_digest = make_radix64_string (sig_digest_bin, sig_digest_bin_len);
2237   fingerprint = hexfingerprint (pk, NULL, 0);
2238
2239   if (! origin)
2240     /* The default origin is simply "unknown".  */
2241     origin = "unknown";
2242
2243   for (user_id = user_id_list; user_id; user_id = user_id->next)
2244     {
2245       email = email_from_user_id (user_id->d);
2246
2247       if (DBG_TRUST)
2248         log_debug ("TOFU: Registering signature %s with binding"
2249                    " <key: %s, user id: %s>\n",
2250                    sig_digest, fingerprint, email);
2251
2252       /* Make sure the binding exists and record any TOFU
2253          conflicts.  */
2254       if (get_trust (dbs, pk, fingerprint, email, user_id->d, 0)
2255           == _tofu_GET_TRUST_ERROR)
2256         {
2257           rc = gpg_error (GPG_ERR_GENERAL);
2258           xfree (email);
2259           break;
2260         }
2261
2262       /* If we've already seen this signature before, then don't add
2263          it again.  */
2264       rc = gpgsql_stepx
2265         (dbs->db, &dbs->s.register_already_seen,
2266          get_single_unsigned_long_cb2, &c, &err,
2267          "select count (*)\n"
2268          " from signatures left join bindings\n"
2269          "  on signatures.binding = bindings.oid\n"
2270          " where fingerprint = ? and email = ? and sig_time = ?\n"
2271          "  and sig_digest = ?",
2272          SQLITE_ARG_STRING, fingerprint, SQLITE_ARG_STRING, email,
2273          SQLITE_ARG_LONG_LONG, (long long) sig_time,
2274          SQLITE_ARG_STRING, sig_digest,
2275          SQLITE_ARG_END);
2276       if (rc)
2277         {
2278           log_error (_("error reading TOFU database: %s\n"), err);
2279           print_further_info ("checking existence");
2280           sqlite3_free (err);
2281         }
2282       else if (c > 1)
2283         /* Duplicates!  This should not happen.  In particular,
2284            because <fingerprint, email, sig_time, sig_digest> is the
2285            primary key!  */
2286         log_debug ("SIGNATURES DB contains duplicate records"
2287                    " <key: %s, fingerprint: %s, time: 0x%lx, sig: %s,"
2288                    " origin: %s>."
2289                    "  Please report.\n",
2290                    fingerprint, email, (unsigned long) sig_time,
2291                    sig_digest, origin);
2292       else if (c == 1)
2293         {
2294           if (DBG_TRUST)
2295             log_debug ("Already observed the signature and binding"
2296                        " <key: %s, user id: %s, time: 0x%lx, sig: %s,"
2297                        " origin: %s>\n",
2298                        fingerprint, email, (unsigned long) sig_time,
2299                        sig_digest, origin);
2300         }
2301       else if (opt.dry_run)
2302         {
2303           log_info ("TOFU database update skipped due to --dry-run\n");
2304         }
2305       else
2306         /* This is the first time that we've seen this signature and
2307            binding.  Record it.  */
2308         {
2309           if (DBG_TRUST)
2310             log_debug ("TOFU: Saving signature"
2311                        " <key: %s, user id: %s, sig: %s>\n",
2312                        fingerprint, email, sig_digest);
2313
2314           log_assert (c == 0);
2315
2316           rc = gpgsql_stepx
2317             (dbs->db, &dbs->s.register_insert, NULL, NULL, &err,
2318              "insert into signatures\n"
2319              " (binding, sig_digest, origin, sig_time, time)\n"
2320              " values\n"
2321              " ((select oid from bindings\n"
2322              "    where fingerprint = ? and email = ?),\n"
2323              "  ?, ?, ?, strftime('%s', 'now'));",
2324              SQLITE_ARG_STRING, fingerprint, SQLITE_ARG_STRING, email,
2325              SQLITE_ARG_STRING, sig_digest, SQLITE_ARG_STRING, origin,
2326              SQLITE_ARG_LONG_LONG, (long long) sig_time,
2327              SQLITE_ARG_END);
2328           if (rc)
2329             {
2330               log_error (_("error updating TOFU database: %s\n"), err);
2331               print_further_info ("insert signatures");
2332               sqlite3_free (err);
2333             }
2334         }
2335
2336       xfree (email);
2337
2338       if (rc)
2339         break;
2340     }
2341
2342   if (rc)
2343     rollback_transaction (ctrl);
2344   else
2345     rc = end_transaction (ctrl, 0);
2346
2347   xfree (fingerprint);
2348   xfree (sig_digest);
2349
2350   return rc;
2351 }
2352
2353 /* Combine a trust level returned from the TOFU trust model with a
2354    trust level returned by the PGP trust model.  This is primarily of
2355    interest when the trust model is tofu+pgp (TM_TOFU_PGP).
2356
2357    This function ors together the upper bits (the values not covered
2358    by TRUST_MASK, i.e., TRUST_FLAG_REVOKED, etc.).  */
2359 int
2360 tofu_wot_trust_combine (int tofu_base, int wot_base)
2361 {
2362   int tofu = tofu_base & TRUST_MASK;
2363   int wot = wot_base & TRUST_MASK;
2364   int upper = (tofu_base & ~TRUST_MASK) | (wot_base & ~TRUST_MASK);
2365
2366   log_assert (tofu == TRUST_UNKNOWN
2367               || tofu == TRUST_EXPIRED
2368               || tofu == TRUST_UNDEFINED
2369               || tofu == TRUST_NEVER
2370               || tofu == TRUST_MARGINAL
2371               || tofu == TRUST_FULLY
2372               || tofu == TRUST_ULTIMATE);
2373   log_assert (wot == TRUST_UNKNOWN
2374               || wot == TRUST_EXPIRED
2375               || wot == TRUST_UNDEFINED
2376               || wot == TRUST_NEVER
2377               || wot == TRUST_MARGINAL
2378               || wot == TRUST_FULLY
2379               || wot == TRUST_ULTIMATE);
2380
2381   /* We first consider negative trust policys.  These trump positive
2382      trust policies.  */
2383   if (tofu == TRUST_NEVER || wot == TRUST_NEVER)
2384     /* TRUST_NEVER trumps everything else.  */
2385     return upper | TRUST_NEVER;
2386   if (tofu == TRUST_EXPIRED || wot == TRUST_EXPIRED)
2387     /* TRUST_EXPIRED trumps everything but TRUST_NEVER.  */
2388     return upper | TRUST_EXPIRED;
2389
2390   /* Now we only have positive or neutral trust policies.  We take
2391      the max.  */
2392   if (tofu == TRUST_ULTIMATE)
2393     return upper | TRUST_ULTIMATE | TRUST_FLAG_TOFU_BASED;
2394   if (wot == TRUST_ULTIMATE)
2395     return upper | TRUST_ULTIMATE;
2396
2397   if (tofu == TRUST_FULLY)
2398     return upper | TRUST_FULLY | TRUST_FLAG_TOFU_BASED;
2399   if (wot == TRUST_FULLY)
2400     return upper | TRUST_FULLY;
2401
2402   if (tofu == TRUST_MARGINAL)
2403     return upper | TRUST_MARGINAL | TRUST_FLAG_TOFU_BASED;
2404   if (wot == TRUST_MARGINAL)
2405     return upper | TRUST_MARGINAL;
2406
2407   if (tofu == TRUST_UNDEFINED)
2408     return upper | TRUST_UNDEFINED | TRUST_FLAG_TOFU_BASED;
2409   if (wot == TRUST_UNDEFINED)
2410     return upper | TRUST_UNDEFINED;
2411
2412   return upper | TRUST_UNKNOWN;
2413 }
2414
2415
2416 /* Write a "tfs" record for a --with-colons listing.  */
2417 gpg_error_t
2418 tofu_write_tfs_record (ctrl_t ctrl, estream_t fp,
2419                        PKT_public_key *pk, const char *user_id)
2420 {
2421   gpg_error_t err;
2422   tofu_dbs_t dbs;
2423   char *fingerprint;
2424   char *email;
2425
2426   if (!*user_id)
2427     return 0;  /* No TOFU stats possible for an empty ID.  */
2428
2429   dbs = opendbs (ctrl);
2430   if (!dbs)
2431     {
2432       err = gpg_error (GPG_ERR_GENERAL);
2433       log_error (_("error opening TOFU database: %s\n"), gpg_strerror (err));
2434       return err;
2435     }
2436
2437   fingerprint = hexfingerprint (pk, NULL, 0);
2438   email = email_from_user_id (user_id);
2439
2440   show_statistics (dbs, fingerprint, email, user_id, NULL, fp);
2441
2442   xfree (email);
2443   xfree (fingerprint);
2444   return 0;
2445 }
2446
2447
2448 /* Return the validity (TRUST_NEVER, etc.) of the bindings
2449    <FINGERPRINT, USER_ID>, for each USER_ID in USER_ID_LIST.  If
2450    USER_ID_LIST->FLAG is set, then the id is considered to be expired.
2451
2452    PK is the primary key packet.
2453
2454    If MAY_ASK is 1 and the policy is TOFU_POLICY_ASK, then the user
2455    will be prompted to choose a different policy.  If MAY_ASK is 0 and
2456    the policy is TOFU_POLICY_ASK, then TRUST_UNKNOWN is returned.
2457
2458    Returns TRUST_UNDEFINED if an error occurs.  */
2459 int
2460 tofu_get_validity (ctrl_t ctrl, PKT_public_key *pk, strlist_t user_id_list,
2461                    int may_ask)
2462 {
2463   tofu_dbs_t dbs;
2464   char *fingerprint = NULL;
2465   strlist_t user_id;
2466   int trust_level = TRUST_UNKNOWN;
2467   int bindings = 0;
2468   int bindings_valid = 0;
2469
2470   dbs = opendbs (ctrl);
2471   if (! dbs)
2472     {
2473       log_error (_("error opening TOFU database: %s\n"),
2474                  gpg_strerror (GPG_ERR_GENERAL));
2475       return TRUST_UNDEFINED;
2476     }
2477
2478   fingerprint = hexfingerprint (pk, NULL, 0);
2479
2480   begin_transaction (ctrl, 0);
2481
2482   for (user_id = user_id_list; user_id; user_id = user_id->next, bindings ++)
2483     {
2484       char *email = email_from_user_id (user_id->d);
2485
2486       /* Always call get_trust to make sure the binding is
2487          registered.  */
2488       int tl = get_trust (dbs, pk, fingerprint, email, user_id->d, may_ask);
2489       if (tl == _tofu_GET_TRUST_ERROR)
2490         {
2491           /* An error.  */
2492           trust_level = TRUST_UNDEFINED;
2493           xfree (email);
2494           goto die;
2495         }
2496
2497       if (DBG_TRUST)
2498         log_debug ("TOFU: validity for <key: %s, user id: %s>: %s%s.\n",
2499                    fingerprint, email,
2500                    trust_value_to_string (tl),
2501                    user_id->flags ? " (but expired)" : "");
2502
2503       if (user_id->flags)
2504         tl = TRUST_EXPIRED;
2505
2506       if (tl != TRUST_EXPIRED)
2507         bindings_valid ++;
2508
2509       if (may_ask && tl != TRUST_ULTIMATE && tl != TRUST_EXPIRED)
2510         show_statistics (dbs, fingerprint, email, user_id->d, NULL, NULL);
2511
2512       if (tl == TRUST_NEVER)
2513         trust_level = TRUST_NEVER;
2514       else if (tl == TRUST_EXPIRED)
2515         /* Ignore expired bindings in the trust calculation.  */
2516         ;
2517       else if (tl > trust_level)
2518         {
2519           /* The expected values: */
2520           log_assert (tl == TRUST_UNKNOWN || tl == TRUST_UNDEFINED
2521                       || tl == TRUST_MARGINAL || tl == TRUST_FULLY
2522                       || tl == TRUST_ULTIMATE);
2523
2524           /* We assume the following ordering:  */
2525           log_assert (TRUST_UNKNOWN < TRUST_UNDEFINED);
2526           log_assert (TRUST_UNDEFINED < TRUST_MARGINAL);
2527           log_assert (TRUST_MARGINAL < TRUST_FULLY);
2528           log_assert (TRUST_FULLY < TRUST_ULTIMATE);
2529
2530           trust_level = tl;
2531         }
2532
2533       xfree (email);
2534     }
2535
2536  die:
2537   end_transaction (ctrl, 0);
2538
2539   xfree (fingerprint);
2540
2541   if (bindings_valid == 0)
2542     {
2543       if (DBG_TRUST)
2544         log_debug ("no (of %d) valid bindings."
2545                    "  Can't get TOFU validity for this set of user ids.\n",
2546                    bindings);
2547       return TRUST_NEVER;
2548     }
2549
2550   return trust_level;
2551 }
2552
2553 /* Set the policy for all non-revoked user ids in the keyblock KB to
2554    POLICY.
2555
2556    If no key is available with the specified key id, then this
2557    function returns GPG_ERR_NO_PUBKEY.
2558
2559    Returns 0 on success and an error code otherwise.  */
2560 gpg_error_t
2561 tofu_set_policy (ctrl_t ctrl, kbnode_t kb, enum tofu_policy policy)
2562 {
2563   tofu_dbs_t dbs;
2564   PKT_public_key *pk;
2565   char *fingerprint = NULL;
2566
2567   log_assert (kb->pkt->pkttype == PKT_PUBLIC_KEY);
2568   pk = kb->pkt->pkt.public_key;
2569
2570   dbs = opendbs (ctrl);
2571   if (! dbs)
2572     {
2573       log_error (_("error opening TOFU database: %s\n"),
2574                  gpg_strerror (GPG_ERR_GENERAL));
2575       return gpg_error (GPG_ERR_GENERAL);
2576     }
2577
2578   if (DBG_TRUST)
2579     log_debug ("Setting TOFU policy for %s to %s\n",
2580                keystr (pk->keyid), tofu_policy_str (policy));
2581   if (! (pk->main_keyid[0] == pk->keyid[0]
2582          && pk->main_keyid[1] == pk->keyid[1]))
2583     log_bug ("%s: Passed a subkey, but expecting a primary key.\n", __func__);
2584
2585   fingerprint = hexfingerprint (pk, NULL, 0);
2586
2587   for (; kb; kb = kb->next)
2588     {
2589       PKT_user_id *user_id;
2590       char *email;
2591
2592       if (kb->pkt->pkttype != PKT_USER_ID)
2593         continue;
2594
2595       user_id = kb->pkt->pkt.user_id;
2596       if (user_id->is_revoked)
2597         /* Skip revoked user ids.  (Don't skip expired user ids, the
2598            expiry can be changed.)  */
2599         continue;
2600
2601       email = email_from_user_id (user_id->name);
2602
2603       record_binding (dbs, fingerprint, email, user_id->name, policy, 1);
2604
2605       xfree (email);
2606     }
2607
2608   xfree (fingerprint);
2609   return 0;
2610 }
2611
2612 /* Set the TOFU policy for all non-revoked user ids in the KEY with
2613    the key id KEYID to POLICY.
2614
2615    If no key is available with the specified key id, then this
2616    function returns GPG_ERR_NO_PUBKEY.
2617
2618    Returns 0 on success and an error code otherwise.  */
2619 gpg_error_t
2620 tofu_set_policy_by_keyid (ctrl_t ctrl, u32 *keyid, enum tofu_policy policy)
2621 {
2622   kbnode_t keyblock = get_pubkeyblock (keyid);
2623   if (! keyblock)
2624     return gpg_error (GPG_ERR_NO_PUBKEY);
2625
2626   return tofu_set_policy (ctrl, keyblock, policy);
2627 }
2628
2629 /* Return the TOFU policy for the specified binding in *POLICY.  If no
2630    policy has been set for the binding, sets *POLICY to
2631    TOFU_POLICY_NONE.
2632
2633    PK is a primary public key and USER_ID is a user id.
2634
2635    Returns 0 on success and an error code otherwise.  */
2636 gpg_error_t
2637 tofu_get_policy (ctrl_t ctrl, PKT_public_key *pk, PKT_user_id *user_id,
2638                  enum tofu_policy *policy)
2639 {
2640   tofu_dbs_t dbs;
2641   char *fingerprint;
2642   char *email;
2643
2644   /* Make sure PK is a primary key.  */
2645   log_assert (pk->main_keyid[0] == pk->keyid[0]
2646               && pk->main_keyid[1] == pk->keyid[1]);
2647
2648   dbs = opendbs (ctrl);
2649   if (! dbs)
2650     {
2651       log_error (_("error opening TOFU database: %s\n"),
2652                  gpg_strerror (GPG_ERR_GENERAL));
2653       return gpg_error (GPG_ERR_GENERAL);
2654     }
2655
2656   fingerprint = hexfingerprint (pk, NULL, 0);
2657
2658   email = email_from_user_id (user_id->name);
2659
2660   *policy = get_policy (dbs, fingerprint, email, NULL);
2661
2662   xfree (email);
2663   xfree (fingerprint);
2664   if (*policy == _tofu_GET_POLICY_ERROR)
2665     return gpg_error (GPG_ERR_GENERAL);
2666   return 0;
2667 }