g10: Always trust ultimately trusted keys.
[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   int in_transaction;
86   time_t batch_update_started;
87 };
88
89
90 #define STRINGIFY(s) STRINGIFY2(s)
91 #define STRINGIFY2(s) #s
92
93 /* The grouping parameters when collecting signature statistics.  */
94
95 /* If a message is signed a couple of hours in the future, just assume
96    some clock skew.  */
97 #define TIME_AGO_FUTURE_IGNORE (2 * 60 * 60)
98 #if 0
99 #  define TIME_AGO_UNIT_SMALL 60
100 #  define TIME_AGO_MEDIUM_THRESHOLD (60 * TIME_AGO_UNIT_SMALL)
101 #  define TIME_AGO_UNIT_MEDIUM (60 * 60)
102 #  define TIME_AGO_LARGE_THRESHOLD (24 * 60 * TIME_AGO_UNIT_SMALL)
103 #  define TIME_AGO_UNIT_LARGE (24 * 60 * 60)
104 #else
105 #  define TIME_AGO_UNIT_SMALL (24 * 60 * 60)
106 #  define TIME_AGO_MEDIUM_THRESHOLD (4 * TIME_AGO_UNIT_SMALL)
107 #  define TIME_AGO_UNIT_MEDIUM (7 * 24 * 60 * 60)
108 #  define TIME_AGO_LARGE_THRESHOLD (28 * TIME_AGO_UNIT_SMALL)
109 #  define TIME_AGO_UNIT_LARGE (30 * 24 * 60 * 60)
110 #endif
111
112 /* Local prototypes.  */
113 static gpg_error_t end_transaction (ctrl_t ctrl, int only_batch);
114
115
116 \f
117 const char *
118 tofu_policy_str (enum tofu_policy policy)
119 {
120   switch (policy)
121     {
122     case TOFU_POLICY_NONE: return "none";
123     case TOFU_POLICY_AUTO: return "auto";
124     case TOFU_POLICY_GOOD: return "good";
125     case TOFU_POLICY_UNKNOWN: return "unknown";
126     case TOFU_POLICY_BAD: return "bad";
127     case TOFU_POLICY_ASK: return "ask";
128     default: return "???";
129     }
130 }
131
132 /* Convert a binding policy (e.g., TOFU_POLICY_BAD) to a trust level
133    (e.g., TRUST_BAD) in light of the current configuration.  */
134 int
135 tofu_policy_to_trust_level (enum tofu_policy policy)
136 {
137   if (policy == TOFU_POLICY_AUTO)
138     /* If POLICY is AUTO, fallback to OPT.TOFU_DEFAULT_POLICY.  */
139     policy = opt.tofu_default_policy;
140
141   switch (policy)
142     {
143     case TOFU_POLICY_AUTO:
144       /* If POLICY and OPT.TOFU_DEFAULT_POLICY are both AUTO, default
145          to marginal trust.  */
146       return TRUST_MARGINAL;
147     case TOFU_POLICY_GOOD:
148       return TRUST_FULLY;
149     case TOFU_POLICY_UNKNOWN:
150       return TRUST_UNKNOWN;
151     case TOFU_POLICY_BAD:
152       return TRUST_NEVER;
153     case TOFU_POLICY_ASK:
154       return TRUST_UNKNOWN;
155     default:
156       log_bug ("Bad value for trust policy: %d\n",
157                opt.tofu_default_policy);
158       return 0;
159     }
160 }
161
162
163 \f
164 /* Start a transaction on DB.  */
165 static gpg_error_t
166 begin_transaction (ctrl_t ctrl)
167 {
168   tofu_dbs_t dbs = ctrl->tofu.dbs;
169   int rc;
170   char *err = NULL;
171
172   log_assert (dbs);
173
174   /* If we've been in batch update mode for a while (on average, more
175    * than 500 ms), to prevent starving other gpg processes, we drop
176    * and retake the batch lock.
177    *
178    * Note: if we wanted higher resolution, we could use
179    * npth_clock_gettime.  */
180   if (/* No real transactions.  */
181       dbs->in_transaction == 0
182       /* There is an open batch transaction.  */
183       && dbs->in_batch_transaction
184       /* And some time has gone by since it was started.  */
185       && dbs->batch_update_started != gnupg_get_time ())
186     {
187       /* If we are in a batch update, then batch updates better have
188          been enabled.  */
189       log_assert (ctrl->tofu.batch_updated_wanted);
190
191       end_transaction (ctrl, 2);
192
193       /* Yield to allow another process a chance to run.  */
194       gpgrt_yield ();
195     }
196
197   if (/* Batch mode is enabled.  */
198       ctrl->tofu.batch_updated_wanted
199       /* But we don't have an open batch transaction.  */
200       && !dbs->in_batch_transaction)
201     {
202       /* We are in batch mode, but we don't have an open batch
203        * transaction.  Since the batch save point must be the outer
204        * save point, it must be taken before the inner save point.  */
205       log_assert (dbs->in_transaction == 0);
206
207       rc = gpgsql_stepx (dbs->db, &dbs->s.savepoint_batch,
208                           NULL, NULL, &err,
209                           "savepoint batch;", GPGSQL_ARG_END);
210       if (rc)
211         {
212           log_error (_("error beginning transaction on TOFU database: %s\n"),
213                      err);
214           sqlite3_free (err);
215           return gpg_error (GPG_ERR_GENERAL);
216         }
217
218       dbs->in_batch_transaction = 1;
219       dbs->batch_update_started = gnupg_get_time ();
220     }
221
222   log_assert(dbs->in_transaction >= 0);
223   dbs->in_transaction ++;
224
225   rc = gpgsql_exec_printf (dbs->db, NULL, NULL, &err,
226                            "savepoint inner%d;",
227                            dbs->in_transaction);
228   if (rc)
229     {
230       log_error (_("error beginning transaction on TOFU database: %s\n"),
231                  err);
232       sqlite3_free (err);
233       return gpg_error (GPG_ERR_GENERAL);
234     }
235
236   return 0;
237 }
238
239
240 /* Commit a transaction.  If ONLY_BATCH is 1, then this only ends the
241  * batch transaction if we have left batch mode.  If ONLY_BATCH is 2,
242  * this ends any open batch transaction even if we are still in batch
243  * mode.  */
244 static gpg_error_t
245 end_transaction (ctrl_t ctrl, int only_batch)
246 {
247   tofu_dbs_t dbs = ctrl->tofu.dbs;
248   int rc;
249   char *err = NULL;
250
251   if (only_batch)
252     {
253       if (!dbs)
254         return 0;  /* Shortcut to allow for easier cleanup code.  */
255
256       /* If we are releasing the batch transaction, then we better not
257          be in a normal transaction.  */
258       log_assert (dbs->in_transaction == 0);
259
260       if (/* Batch mode disabled?  */
261           (!ctrl->tofu.batch_updated_wanted || only_batch == 2)
262           /* But, we still have an open batch transaction?  */
263           && dbs->in_batch_transaction)
264         {
265           /* The batch transaction is still in open, but we've left
266            * batch mode.  */
267           dbs->in_batch_transaction = 0;
268
269           rc = gpgsql_stepx (dbs->db, &dbs->s.savepoint_batch_commit,
270                              NULL, NULL, &err,
271                              "release batch;", GPGSQL_ARG_END);
272           if (rc)
273             {
274               log_error (_("error committing transaction on TOFU database: %s\n"),
275                          err);
276               sqlite3_free (err);
277               return gpg_error (GPG_ERR_GENERAL);
278             }
279
280           return 0;
281         }
282
283       return 0;
284     }
285
286   log_assert (dbs);
287   log_assert (dbs->in_transaction > 0);
288
289   rc = gpgsql_exec_printf (dbs->db, NULL, NULL, &err,
290                            "release inner%d;", dbs->in_transaction);
291   if (rc)
292     {
293       log_error (_("error committing transaction on TOFU database: %s\n"),
294                  err);
295       sqlite3_free (err);
296       return gpg_error (GPG_ERR_GENERAL);
297     }
298
299   dbs->in_transaction --;
300
301   return 0;
302 }
303
304
305 static gpg_error_t
306 rollback_transaction (ctrl_t ctrl)
307 {
308   tofu_dbs_t dbs = ctrl->tofu.dbs;
309   int rc;
310   char *err = NULL;
311
312   log_assert (dbs);
313   log_assert (dbs->in_transaction > 0);
314
315   /* Be careful to not any progress made by closed transactions in
316      batch mode.  */
317   rc = gpgsql_exec_printf (dbs->db, NULL, NULL, &err,
318                            "rollback to inner%d;",
319                            dbs->in_transaction);
320
321   dbs->in_transaction --;
322
323   if (rc)
324     {
325       log_error (_("error rolling back transaction on TOFU database: %s\n"),
326                  err);
327       sqlite3_free (err);
328       return gpg_error (GPG_ERR_GENERAL);
329     }
330
331   return 0;
332 }
333
334 void
335 tofu_begin_batch_update (ctrl_t ctrl)
336 {
337   ctrl->tofu.batch_updated_wanted ++;
338 }
339
340 void
341 tofu_end_batch_update (ctrl_t ctrl)
342 {
343   log_assert (ctrl->tofu.batch_updated_wanted > 0);
344   ctrl->tofu.batch_updated_wanted --;
345
346   if (!ctrl->tofu.batch_updated_wanted)
347     end_transaction (ctrl, 1);
348 }
349
350
351
352 \f
353 /* Wrapper around strtol which prints a warning in case of a
354  * conversion error.  On success the converted value is stored at
355  * R_VALUE and 0 is returned; on error FALLBACK is stored at R_VALUE
356  * and an error code is returned.  */
357 static gpg_error_t
358 string_to_long (long *r_value, const char *string, long fallback, int line)
359 {
360   gpg_error_t err;
361   char *tail = NULL;
362
363   gpg_err_set_errno (0);
364   *r_value = strtol (string, &tail, 0);
365   if (errno || !(!strcmp (tail, ".0") || !*tail))
366     {
367       err = errno? gpg_error_from_errno (errno) : gpg_error (GPG_ERR_BAD_DATA);
368       log_debug ("%s:%d: "
369                  "strtol failed for DB returned string (tail=%.10s): %s\n",
370                  __FILE__, line, tail, gpg_strerror (err));
371       *r_value = fallback;
372     }
373   else
374     err = 0;
375
376   return err;
377 }
378
379
380 /* Wrapper around strtoul which prints a warning in case of a
381  * conversion error.  On success the converted value is stored at
382  * R_VALUE and 0 is returned; on error FALLBACK is stored at R_VALUE
383  * and an error code is returned.  */
384 static gpg_error_t
385 string_to_ulong (unsigned long *r_value, const char *string,
386                  unsigned long fallback, int line)
387 {
388   gpg_error_t err;
389   char *tail = NULL;
390
391   gpg_err_set_errno (0);
392   *r_value = strtoul (string, &tail, 0);
393   if (errno || !(!strcmp (tail, ".0") || !*tail))
394     {
395       err = errno? gpg_error_from_errno (errno) : gpg_error (GPG_ERR_BAD_DATA);
396       log_debug ("%s:%d: "
397                  "strtoul failed for DB returned string (tail=%.10s): %s\n",
398                  __FILE__, line, tail, gpg_strerror (err));
399       *r_value = fallback;
400     }
401   else
402     err = 0;
403
404   return err;
405 }
406
407
408
409 /* Collect results of a select count (*) ...; style query.  Aborts if
410    the argument is not a valid integer (or real of the form X.0).  */
411 static int
412 get_single_unsigned_long_cb (void *cookie, int argc, char **argv,
413                              char **azColName)
414 {
415   unsigned long int *count = cookie;
416
417   (void) azColName;
418
419   log_assert (argc == 1);
420
421   if (string_to_ulong (count, argv[0], 0, __LINE__))
422     return 1; /* Abort.  */
423   return 0;
424 }
425
426 static int
427 get_single_unsigned_long_cb2 (void *cookie, int argc, char **argv,
428                              char **azColName, sqlite3_stmt *stmt)
429 {
430   (void) stmt;
431   return get_single_unsigned_long_cb (cookie, argc, argv, azColName);
432 }
433
434 /* We expect a single integer column whose name is "version".  COOKIE
435    must point to an int.  This function always aborts.  On error or a
436    if the version is bad, sets *VERSION to -1.  */
437 static int
438 version_check_cb (void *cookie, int argc, char **argv, char **azColName)
439 {
440   int *version = cookie;
441
442   if (argc != 1 || strcmp (azColName[0], "version") != 0)
443     {
444       *version = -1;
445       return 1;
446     }
447
448   if (strcmp (argv[0], "1") == 0)
449     *version = 1;
450   else
451     {
452       log_error (_("unsupported TOFU database version: %s\n"), argv[0]);
453       *version = -1;
454     }
455
456   /* Don't run again.  */
457   return 1;
458 }
459
460
461 /* If the DB is new, initialize it.  Otherwise, check the DB's
462    version.
463
464    Return 0 if the database is okay and 1 otherwise.  */
465 static int
466 initdb (sqlite3 *db)
467 {
468   char *err = NULL;
469   int rc;
470   unsigned long int count;
471   int version = -1;
472
473   rc = sqlite3_exec (db, "begin transaction;", NULL, NULL, &err);
474   if (rc)
475     {
476       log_error (_("error beginning transaction on TOFU database: %s\n"),
477                  err);
478       sqlite3_free (err);
479       return 1;
480     }
481
482   /* If the DB has no tables, then assume this is a new DB that needs
483      to be initialized.  */
484   rc = sqlite3_exec (db,
485                      "select count(*) from sqlite_master where type='table';",
486                      get_single_unsigned_long_cb, &count, &err);
487   if (rc)
488     {
489       log_error (_("error reading TOFU database: %s\n"), err);
490       print_further_info ("query available tables");
491       sqlite3_free (err);
492       goto out;
493     }
494   else if (count != 0)
495     /* Assume that the DB is already initialized.  Make sure the
496        version is okay.  */
497     {
498       rc = sqlite3_exec (db, "select version from version;", version_check_cb,
499                          &version, &err);
500       if (rc == SQLITE_ABORT && version == 1)
501         /* Happy, happy, joy, joy.  */
502         {
503           sqlite3_free (err);
504           rc = 0;
505           goto out;
506         }
507       else if (rc == SQLITE_ABORT && version == -1)
508         /* Unsupported version.  */
509         {
510           /* An error message was already displayed.  */
511           sqlite3_free (err);
512           goto out;
513         }
514       else if (rc)
515         /* Some error.  */
516         {
517           log_error (_("error determining TOFU database's version: %s\n"), err);
518           sqlite3_free (err);
519           goto out;
520         }
521       else
522         {
523           /* Unexpected success.  This can only happen if there are no
524              rows.  (select returned 0, but expected ABORT.)  */
525           log_error (_("error determining TOFU database's version: %s\n"),
526                      gpg_strerror (GPG_ERR_NO_DATA));
527           rc = 1;
528           goto out;
529         }
530     }
531
532   /* Create the version table.  */
533   rc = sqlite3_exec (db,
534                      "create table version (version INTEGER);",
535                      NULL, NULL, &err);
536   if (rc)
537     {
538       log_error (_("error initializing TOFU database: %s\n"), err);
539       print_further_info ("create version");
540       sqlite3_free (err);
541       goto out;
542     }
543
544   /* Initialize the version table, which contains a single integer
545      value.  */
546   rc = sqlite3_exec (db,
547                      "insert into version values (1);",
548                      NULL, NULL, &err);
549   if (rc)
550     {
551       log_error (_("error initializing TOFU database: %s\n"), err);
552       print_further_info ("insert version");
553       sqlite3_free (err);
554       goto out;
555     }
556
557   /* The list of <fingerprint, email> bindings and auxiliary data.
558    *
559    *  OID is a unique ID identifying this binding (and used by the
560    *    signatures table, see below).  Note: OIDs will never be
561    *    reused.
562    *
563    *  FINGERPRINT: The key's fingerprint.
564    *
565    *  EMAIL: The normalized email address.
566    *
567    *  USER_ID: The unmodified user id from which EMAIL was extracted.
568    *
569    *  TIME: The time this binding was first observed.
570    *
571    *  POLICY: The trust policy (TOFU_POLICY_BAD, etc. as an integer).
572    *
573    *  CONFLICT is either NULL or a fingerprint.  Assume that we have
574    *    a binding <0xdeadbeef, foo@example.com> and then we observe
575    *    <0xbaddecaf, foo@example.com>.  There two bindings conflict
576    *    (they have the same email address).  When we observe the
577    *    latter binding, we warn the user about the conflict and ask
578    *    for a policy decision about the new binding.  We also change
579    *    the old binding's policy to ask if it was auto.  So that we
580    *     know why this occurred, we also set conflict to 0xbaddecaf.
581    */
582   rc = gpgsql_exec_printf
583       (db, NULL, NULL, &err,
584        "create table bindings\n"
585        " (oid INTEGER PRIMARY KEY AUTOINCREMENT,\n"
586        "  fingerprint TEXT, email TEXT, user_id TEXT, time INTEGER,\n"
587        "  policy BOOLEAN CHECK (policy in (%d, %d, %d, %d, %d)),\n"
588        "  conflict STRING,\n"
589        "  unique (fingerprint, email));\n"
590        "create index bindings_fingerprint_email\n"
591        " on bindings (fingerprint, email);\n"
592        "create index bindings_email on bindings (email);\n",
593        TOFU_POLICY_AUTO, TOFU_POLICY_GOOD, TOFU_POLICY_UNKNOWN,
594        TOFU_POLICY_BAD, TOFU_POLICY_ASK);
595   if (rc)
596     {
597       log_error (_("error initializing TOFU database: %s\n"), err);
598       print_further_info ("create bindings");
599       sqlite3_free (err);
600       goto out;
601     }
602
603   /* The signatures that we have observed.
604    *
605    * BINDING refers to a record in the bindings table, which
606    * describes the binding (i.e., this is a foreign key that
607    * references bindings.oid).
608    *
609    * SIG_DIGEST is the digest stored in the signature.
610    *
611    * SIG_TIME is the timestamp stored in the signature.
612    *
613    * ORIGIN is a free-form string that describes who fed this
614    * signature to GnuPG (e.g., email:claws).
615    *
616    * TIME is the time this signature was registered.  */
617   rc = sqlite3_exec (db,
618                          "create table signatures "
619                          " (binding INTEGER NOT NULL, sig_digest TEXT,"
620                          "  origin TEXT, sig_time INTEGER, time INTEGER,"
621                          "  primary key (binding, sig_digest, origin));",
622                          NULL, NULL, &err);
623   if (rc)
624     {
625       log_error (_("error initializing TOFU database: %s\n"), err);
626       print_further_info ("create signatures");
627       sqlite3_free (err);
628       goto out;
629     }
630
631  out:
632   if (rc)
633     {
634       rc = sqlite3_exec (db, "rollback;", NULL, NULL, &err);
635       if (rc)
636         {
637           log_error (_("error rolling back transaction on TOFU database: %s\n"),
638                      err);
639           sqlite3_free (err);
640         }
641       return 1;
642     }
643   else
644     {
645       rc = sqlite3_exec (db, "end transaction;", NULL, NULL, &err);
646       if (rc)
647         {
648           log_error (_("error committing transaction on TOFU database: %s\n"),
649                      err);
650           sqlite3_free (err);
651           return 1;
652         }
653       return 0;
654     }
655 }
656
657
658 /* Create a new DB handle.  Returns NULL on error.  */
659 /* FIXME: Change to return an error code for better reporting by the
660    caller.  */
661 static tofu_dbs_t
662 opendbs (ctrl_t ctrl)
663 {
664   char *filename;
665   sqlite3 *db;
666   int rc;
667
668   if (!ctrl->tofu.dbs)
669     {
670       filename = make_filename (gnupg_homedir (), "tofu.db", NULL);
671
672       rc = sqlite3_open (filename, &db);
673       if (rc)
674         {
675           log_error (_("error opening TOFU database '%s': %s\n"),
676                      filename, sqlite3_errmsg (db));
677           /* Even if an error occurs, DB is guaranteed to be valid.  */
678           sqlite3_close (db);
679           db = NULL;
680         }
681       xfree (filename);
682
683       /* If a DB is locked wait up to 5 seconds for the lock to be cleared
684          before failing.  */
685       if (db)
686         sqlite3_busy_timeout (db, 5 * 1000);
687
688       if (db && initdb (db))
689         {
690           sqlite3_close (db);
691           db = NULL;
692         }
693
694       if (db)
695         {
696           ctrl->tofu.dbs = xmalloc_clear (sizeof *ctrl->tofu.dbs);
697           ctrl->tofu.dbs->db = db;
698         }
699     }
700   else
701     log_assert (ctrl->tofu.dbs->db);
702
703   return ctrl->tofu.dbs;
704 }
705
706
707 /* Release all of the resources associated with the DB handle.  */
708 void
709 tofu_closedbs (ctrl_t ctrl)
710 {
711   tofu_dbs_t dbs;
712   sqlite3_stmt **statements;
713
714   dbs = ctrl->tofu.dbs;
715   if (!dbs)
716     return;  /* Not initialized.  */
717
718   log_assert (dbs->in_transaction == 0);
719
720   end_transaction (ctrl, 2);
721
722   /* Arghh, that is a surprising use of the struct.  */
723   for (statements = (void *) &dbs->s;
724        (void *) statements < (void *) &(&dbs->s)[1];
725        statements ++)
726     sqlite3_finalize (*statements);
727
728   sqlite3_close (dbs->db);
729   xfree (dbs);
730   ctrl->tofu.dbs = NULL;
731 }
732
733
734 /* Collect results of a select min (foo) ...; style query.  Aborts if
735    the argument is not a valid integer (or real of the form X.0).  */
736 static int
737 get_single_long_cb (void *cookie, int argc, char **argv, char **azColName)
738 {
739   long *count = cookie;
740
741   (void) azColName;
742
743   log_assert (argc == 1);
744
745   if (string_to_long (count, argv[0], 0, __LINE__))
746     return 1; /* Abort.  */
747
748   return 0;
749 }
750
751 static int
752 get_single_long_cb2 (void *cookie, int argc, char **argv, char **azColName,
753                      sqlite3_stmt *stmt)
754 {
755   (void) stmt;
756   return get_single_long_cb (cookie, argc, argv, azColName);
757 }
758
759 /* Record (or update) a trust policy about a (possibly new)
760    binding.
761
762    If SHOW_OLD is set, the binding's old policy is displayed.  */
763 static gpg_error_t
764 record_binding (tofu_dbs_t dbs, const char *fingerprint, const char *email,
765                 const char *user_id, enum tofu_policy policy, int show_old)
766 {
767   char *fingerprint_pp = format_hexfingerprint (fingerprint, NULL, 0);
768   gpg_error_t rc;
769   char *err = NULL;
770
771   if (! (policy == TOFU_POLICY_AUTO
772          || policy == TOFU_POLICY_GOOD
773          || policy == TOFU_POLICY_UNKNOWN
774          || policy == TOFU_POLICY_BAD
775          || policy == TOFU_POLICY_ASK))
776     log_bug ("%s: Bad value for policy (%d)!\n", __func__, policy);
777
778
779   if (DBG_TRUST || show_old)
780     {
781       /* Get the old policy.  Since this is just for informational
782        * purposes, there is no need to start a transaction or to die
783        * if there is a failure.  */
784
785       /* policy_old needs to be a long and not an enum tofu_policy,
786          because we pass it by reference to get_single_long_cb2, which
787          expects a long.  */
788       long policy_old = TOFU_POLICY_NONE;
789
790       rc = gpgsql_stepx
791         (dbs->db, &dbs->s.record_binding_get_old_policy,
792          get_single_long_cb2, &policy_old, &err,
793          "select policy from bindings where fingerprint = ? and email = ?",
794          GPGSQL_ARG_STRING, fingerprint, GPGSQL_ARG_STRING, email,
795          GPGSQL_ARG_END);
796       if (rc)
797         {
798           log_debug ("TOFU: Error reading from binding database"
799                      " (reading policy for <key: %s, user id: %s>): %s\n",
800                      fingerprint, email, err);
801           sqlite3_free (err);
802         }
803
804       if (policy_old != TOFU_POLICY_NONE)
805         (show_old ? log_info : log_debug)
806           ("Changing TOFU trust policy for binding"
807            " <key: %s, user id: %s> from %s to %s.\n",
808            fingerprint, show_old ? user_id : email,
809            tofu_policy_str (policy_old),
810            tofu_policy_str (policy));
811       else
812         (show_old ? log_info : log_debug)
813           ("Setting TOFU trust policy for new binding"
814            " <key: %s, user id: %s> to %s.\n",
815            fingerprint, show_old ? user_id : email,
816            tofu_policy_str (policy));
817
818       if (policy_old == policy)
819         {
820           rc = 0;
821           goto leave; /* Nothing to do.  */
822         }
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      GPGSQL_ARG_STRING, fingerprint, GPGSQL_ARG_STRING, email,
843      GPGSQL_ARG_STRING, fingerprint, GPGSQL_ARG_STRING, email,
844      GPGSQL_ARG_STRING, user_id, GPGSQL_ARG_INT, (int) policy,
845      GPGSQL_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                       GPGSQL_ARG_STRING, fingerprint,
1040                       GPGSQL_ARG_STRING, email,
1041                       GPGSQL_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      GPGSQL_ARG_STRING, fingerprint, GPGSQL_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      GPGSQL_ARG_STRING, email, GPGSQL_ARG_STRING, fingerprint,
1305      GPGSQL_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   {
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      GPGSQL_ARG_STRING, email, GPGSQL_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 == -1)
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);
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          GPGSQL_ARG_STRING, fingerprint, GPGSQL_ARG_STRING, email,
2273          GPGSQL_ARG_LONG_LONG, (long long) sig_time,
2274          GPGSQL_ARG_STRING, sig_digest,
2275          GPGSQL_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              GPGSQL_ARG_STRING, fingerprint, GPGSQL_ARG_STRING, email,
2325              GPGSQL_ARG_STRING, sig_digest, GPGSQL_ARG_STRING, origin,
2326              GPGSQL_ARG_LONG_LONG, (long long) sig_time,
2327              GPGSQL_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);
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   begin_transaction (ctrl);
2588
2589   for (; kb; kb = kb->next)
2590     {
2591       PKT_user_id *user_id;
2592       char *email;
2593
2594       if (kb->pkt->pkttype != PKT_USER_ID)
2595         continue;
2596
2597       user_id = kb->pkt->pkt.user_id;
2598       if (user_id->is_revoked)
2599         /* Skip revoked user ids.  (Don't skip expired user ids, the
2600            expiry can be changed.)  */
2601         continue;
2602
2603       email = email_from_user_id (user_id->name);
2604
2605       record_binding (dbs, fingerprint, email, user_id->name, policy, 1);
2606
2607       xfree (email);
2608     }
2609
2610   end_transaction (ctrl, 0);
2611
2612   xfree (fingerprint);
2613   return 0;
2614 }
2615
2616 /* Set the TOFU policy for all non-revoked user ids in the KEY with
2617    the key id KEYID to POLICY.
2618
2619    If no key is available with the specified key id, then this
2620    function returns GPG_ERR_NO_PUBKEY.
2621
2622    Returns 0 on success and an error code otherwise.  */
2623 gpg_error_t
2624 tofu_set_policy_by_keyid (ctrl_t ctrl, u32 *keyid, enum tofu_policy policy)
2625 {
2626   kbnode_t keyblock = get_pubkeyblock (keyid);
2627   if (! keyblock)
2628     return gpg_error (GPG_ERR_NO_PUBKEY);
2629
2630   return tofu_set_policy (ctrl, keyblock, policy);
2631 }
2632
2633 /* Return the TOFU policy for the specified binding in *POLICY.  If no
2634    policy has been set for the binding, sets *POLICY to
2635    TOFU_POLICY_NONE.
2636
2637    PK is a primary public key and USER_ID is a user id.
2638
2639    Returns 0 on success and an error code otherwise.  */
2640 gpg_error_t
2641 tofu_get_policy (ctrl_t ctrl, PKT_public_key *pk, PKT_user_id *user_id,
2642                  enum tofu_policy *policy)
2643 {
2644   tofu_dbs_t dbs;
2645   char *fingerprint;
2646   char *email;
2647
2648   /* Make sure PK is a primary key.  */
2649   log_assert (pk->main_keyid[0] == pk->keyid[0]
2650               && pk->main_keyid[1] == pk->keyid[1]);
2651
2652   dbs = opendbs (ctrl);
2653   if (! dbs)
2654     {
2655       log_error (_("error opening TOFU database: %s\n"),
2656                  gpg_strerror (GPG_ERR_GENERAL));
2657       return gpg_error (GPG_ERR_GENERAL);
2658     }
2659
2660   fingerprint = hexfingerprint (pk, NULL, 0);
2661
2662   email = email_from_user_id (user_id->name);
2663
2664   *policy = get_policy (dbs, fingerprint, email, NULL);
2665
2666   xfree (email);
2667   xfree (fingerprint);
2668   if (*policy == _tofu_GET_POLICY_ERROR)
2669     return gpg_error (GPG_ERR_GENERAL);
2670   return 0;
2671 }