g10: Drop unused argument.
[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   /* policy_old needs to be a long and not an enum tofu_policy,
771      because we pass it by reference to get_single_long_cb2, which
772      expects a long.  */
773   long policy_old = TOFU_POLICY_NONE;
774
775   if (! (policy == TOFU_POLICY_AUTO
776          || policy == TOFU_POLICY_GOOD
777          || policy == TOFU_POLICY_UNKNOWN
778          || policy == TOFU_POLICY_BAD
779          || policy == TOFU_POLICY_ASK))
780     log_bug ("%s: Bad value for policy (%d)!\n", __func__, policy);
781
782
783   if (show_old)
784     {
785       /* Get the old policy.  Since this is just for informational
786        * purposes, there is no need to start a transaction or to die
787        * if there is a failure.  */
788       rc = gpgsql_stepx
789         (dbs->db, &dbs->s.record_binding_get_old_policy,
790          get_single_long_cb2, &policy_old, &err,
791          "select policy from bindings where fingerprint = ? and email = ?",
792          GPGSQL_ARG_STRING, fingerprint, GPGSQL_ARG_STRING, email,
793          GPGSQL_ARG_END);
794       if (rc)
795         {
796           log_debug ("TOFU: Error reading from binding database"
797                      " (reading policy for <key: %s, user id: %s>): %s\n",
798                      fingerprint, email, err);
799           sqlite3_free (err);
800         }
801
802       if (DBG_TRUST)
803         {
804           if (policy_old != TOFU_POLICY_NONE)
805             log_debug ("Changing TOFU trust policy for binding"
806                        " <key: %s, user id: %s> from %s to %s.\n",
807                        fingerprint, email,
808                        tofu_policy_str (policy_old),
809                        tofu_policy_str (policy));
810           else
811             log_debug ("Setting TOFU trust policy for new binding"
812                        " <key: %s, user id: %s> to %s.\n",
813                        fingerprint, email,
814                        tofu_policy_str (policy));
815         }
816     }
817
818   if (policy_old == policy)
819     {
820       rc = 0;
821       goto leave; /* Nothing to do.  */
822     }
823
824   if (opt.dry_run)
825     {
826       log_info ("TOFU database update skipped due to --dry-run\n");
827       rc = 0;
828       goto leave;
829     }
830
831   rc = gpgsql_stepx
832     (dbs->db, &dbs->s.record_binding_update, NULL, NULL, &err,
833      "insert or replace into bindings\n"
834      " (oid, fingerprint, email, user_id, time, policy)\n"
835      " values (\n"
836      /* If we don't explicitly reuse the OID, then SQLite will
837         reallocate a new one.  We just need to search for the OID
838         based on the fingerprint and email since they are unique.  */
839      "  (select oid from bindings where fingerprint = ? and email = ?),\n"
840      "  ?, ?, ?, strftime('%s','now'), ?);",
841      GPGSQL_ARG_STRING, fingerprint, GPGSQL_ARG_STRING, email,
842      GPGSQL_ARG_STRING, fingerprint, GPGSQL_ARG_STRING, email,
843      GPGSQL_ARG_STRING, user_id, GPGSQL_ARG_INT, (int) policy,
844      GPGSQL_ARG_END);
845   if (rc)
846     {
847       log_error (_("error updating TOFU database: %s\n"), err);
848       print_further_info (" insert bindings <key: %s, user id: %s> = %s",
849                           fingerprint, email, tofu_policy_str (policy));
850       sqlite3_free (err);
851       goto leave;
852     }
853
854  leave:
855   xfree (fingerprint_pp);
856   return rc;
857 }
858
859
860 /* Collect the strings returned by a query in a simply string list.
861    Any NULL values are converted to the empty string.
862
863    If a result has 3 rows and each row contains two columns, then the
864    results are added to the list as follows (the value is parentheses
865    is the 1-based index in the final list):
866
867      row 1, col 2 (6)
868      row 1, col 1 (5)
869      row 2, col 2 (4)
870      row 2, col 1 (3)
871      row 3, col 2 (2)
872      row 3, col 1 (1)
873
874    This is because add_to_strlist pushes the results onto the front of
875    the list.  The end result is that the rows are backwards, but the
876    columns are in the expected order.  */
877 static int
878 strings_collect_cb (void *cookie, int argc, char **argv, char **azColName)
879 {
880   int i;
881   strlist_t *strlist = cookie;
882
883   (void) azColName;
884
885   for (i = argc - 1; i >= 0; i --)
886     add_to_strlist (strlist, argv[i] ? argv[i] : "");
887
888   return 0;
889 }
890
891 static int
892 strings_collect_cb2 (void *cookie, int argc, char **argv, char **azColName,
893                      sqlite3_stmt *stmt)
894 {
895   (void) stmt;
896   return strings_collect_cb (cookie, argc, argv, azColName);
897
898 }
899
900 /* Auxiliary data structure to collect statistics about
901    signatures.  */
902 struct signature_stats
903 {
904   struct signature_stats *next;
905
906   /* The user-assigned policy for this binding.  */
907   enum tofu_policy policy;
908
909   /* How long ago the signature was created (rounded to a multiple of
910      TIME_AGO_UNIT_SMALL, etc.).  */
911   long time_ago;
912   /* Number of signatures during this time.  */
913   unsigned long count;
914
915   /* The key that generated this signature.  */
916   char fingerprint[1];
917 };
918
919 static void
920 signature_stats_free (struct signature_stats *stats)
921 {
922   while (stats)
923     {
924       struct signature_stats *next = stats->next;
925       xfree (stats);
926       stats = next;
927     }
928 }
929
930 static void
931 signature_stats_prepend (struct signature_stats **statsp,
932                          const char *fingerprint,
933                          enum tofu_policy policy,
934                          long time_ago,
935                          unsigned long count)
936 {
937   struct signature_stats *stats =
938     xmalloc (sizeof (*stats) + strlen (fingerprint));
939
940   stats->next = *statsp;
941   *statsp = stats;
942
943   strcpy (stats->fingerprint, fingerprint);
944   stats->policy = policy;
945   stats->time_ago = time_ago;
946   stats->count = count;
947 }
948
949
950 /* Process rows that contain the four columns:
951
952      <fingerprint, policy, time ago, count>.  */
953 static int
954 signature_stats_collect_cb (void *cookie, int argc, char **argv,
955                             char **azColName, sqlite3_stmt *stmt)
956 {
957   struct signature_stats **statsp = cookie;
958   int i = 0;
959   enum tofu_policy policy;
960   long time_ago;
961   unsigned long count;
962   long along;
963
964   (void) azColName;
965   (void) stmt;
966
967   i ++;
968
969   if (string_to_long (&along, argv[i], 0, __LINE__))
970     return 1;  /* Abort */
971   policy = along;
972   i ++;
973
974   if (! argv[i])
975     time_ago = 0;
976   else
977     {
978       if (string_to_long (&time_ago, argv[i], 0, __LINE__))
979         return 1; /* Abort.  */
980     }
981   i ++;
982
983   /* If time_ago is NULL, then we had no messages, but we still have a
984      single row, which count(*) turns into 1.  */
985   if (! argv[i - 1])
986     count = 0;
987   else
988     {
989       if (string_to_ulong (&count, argv[i], 0, __LINE__))
990         return 1; /* Abort */
991     }
992   i ++;
993
994   log_assert (argc == i);
995
996   signature_stats_prepend (statsp, argv[0], policy, time_ago, count);
997
998   return 0;
999 }
1000
1001 /* Convert from seconds to time units.
1002
1003    Note: T should already be a multiple of TIME_AGO_UNIT_SMALL or
1004    TIME_AGO_UNIT_MEDIUM or TIME_AGO_UNIT_LARGE.  */
1005 signed long
1006 time_ago_scale (signed long t)
1007 {
1008   if (t < TIME_AGO_UNIT_MEDIUM)
1009     return t / TIME_AGO_UNIT_SMALL;
1010   if (t < TIME_AGO_UNIT_LARGE)
1011     return t / TIME_AGO_UNIT_MEDIUM;
1012   return t / TIME_AGO_UNIT_LARGE;
1013 }
1014
1015
1016 /* Return the policy for the binding <FINGERPRINT, EMAIL> (email has
1017    already been normalized) and any conflict information in *CONFLICT
1018    if CONFLICT is not NULL.  Returns _tofu_GET_POLICY_ERROR if an error
1019    occurs.  */
1020 static enum tofu_policy
1021 get_policy (tofu_dbs_t dbs, const char *fingerprint, const char *email,
1022             char **conflict)
1023 {
1024   int rc;
1025   char *err = NULL;
1026   strlist_t strlist = NULL;
1027   enum tofu_policy policy = _tofu_GET_POLICY_ERROR;
1028   long along;
1029
1030   /* Check if the <FINGERPRINT, EMAIL> binding is known
1031      (TOFU_POLICY_NONE cannot appear in the DB.  Thus, if POLICY is
1032      still TOFU_POLICY_NONE after executing the query, then the
1033      result set was empty.)  */
1034   rc = gpgsql_stepx (dbs->db, &dbs->s.get_policy_select_policy_and_conflict,
1035                       strings_collect_cb2, &strlist, &err,
1036                       "select policy, conflict from bindings\n"
1037                       " where fingerprint = ? and email = ?",
1038                       GPGSQL_ARG_STRING, fingerprint,
1039                       GPGSQL_ARG_STRING, email,
1040                       GPGSQL_ARG_END);
1041   if (rc)
1042     {
1043       log_error (_("error reading TOFU database: %s\n"), err);
1044       print_further_info ("checking for existing bad bindings");
1045       sqlite3_free (err);
1046       goto out;
1047     }
1048
1049   if (strlist_length (strlist) == 0)
1050     /* No results.  */
1051     {
1052       policy = TOFU_POLICY_NONE;
1053       goto out;
1054     }
1055   else if (strlist_length (strlist) != 2)
1056     /* The result has the wrong form.  */
1057     {
1058       log_error (_("error reading TOFU database: %s\n"),
1059                  gpg_strerror (GPG_ERR_BAD_DATA));
1060       print_further_info ("checking for existing bad bindings:"
1061                           " expected 2 results, got %d\n",
1062                           strlist_length (strlist));
1063       goto out;
1064     }
1065
1066   /* The result has the right form.  */
1067
1068   if (string_to_long (&along, strlist->d, 0, __LINE__))
1069     {
1070       log_error (_("error reading TOFU database: %s\n"),
1071                  gpg_strerror (GPG_ERR_BAD_DATA));
1072       print_further_info ("bad value for policy: %s", strlist->d);
1073       goto out;
1074     }
1075   policy = along;
1076
1077   if (! (policy == TOFU_POLICY_AUTO
1078          || policy == TOFU_POLICY_GOOD
1079          || policy == TOFU_POLICY_UNKNOWN
1080          || policy == TOFU_POLICY_BAD
1081          || policy == TOFU_POLICY_ASK))
1082     {
1083       log_error (_("error reading TOFU database: %s\n"),
1084                  gpg_strerror (GPG_ERR_DB_CORRUPTED));
1085       print_further_info ("invalid value for policy (%d)", policy);
1086       policy = _tofu_GET_POLICY_ERROR;
1087       goto out;
1088     }
1089
1090
1091   /* If CONFLICT is set, then policy should be TOFU_POLICY_ASK.  But,
1092      just in case, we do the check again here and ignore the conflict
1093      if POLICY is not TOFU_POLICY_ASK.  */
1094   if (conflict)
1095     {
1096       if (policy == TOFU_POLICY_ASK && *strlist->next->d)
1097         *conflict = xstrdup (strlist->next->d);
1098       else
1099         *conflict = NULL;
1100     }
1101
1102  out:
1103   log_assert (policy == _tofu_GET_POLICY_ERROR
1104               || policy == TOFU_POLICY_NONE
1105               || policy == TOFU_POLICY_AUTO
1106               || policy == TOFU_POLICY_GOOD
1107               || policy == TOFU_POLICY_UNKNOWN
1108               || policy == TOFU_POLICY_BAD
1109               || policy == TOFU_POLICY_ASK);
1110
1111   free_strlist (strlist);
1112
1113   return policy;
1114 }
1115
1116
1117 /* Format the first part of a conflict message and return that as a
1118  * malloced string.  */
1119 static char *
1120 format_conflict_msg_part1 (int policy, const char *conflict,
1121                            const char *fingerprint, const char *email)
1122 {
1123   estream_t fp;
1124   char *binding;
1125   int binding_shown = 0;
1126   char *tmpstr, *text;
1127
1128   binding = xasprintf ("<%s, %s>", fingerprint, email);
1129
1130   fp = es_fopenmem (0, "rw,samethread");
1131   if (!fp)
1132     log_fatal ("error creating memory stream: %s\n",
1133                gpg_strerror (gpg_error_from_syserror()));
1134
1135   if (policy == TOFU_POLICY_NONE)
1136     {
1137       es_fprintf (fp, _("The binding %s is NOT known."), binding);
1138       es_fputs ("  ", fp);
1139       binding_shown = 1;
1140     }
1141   else if (policy == TOFU_POLICY_ASK
1142            /* If there the conflict is with itself, then don't
1143             * display this message.  */
1144            && conflict && strcmp (conflict, fingerprint))
1145     {
1146       es_fprintf (fp,
1147                   _("The key with fingerprint %s raised a conflict "
1148                     "with the binding %s."
1149                     "  Since this binding's policy was 'auto', it was "
1150                     "changed to 'ask'."),
1151                   conflict, binding);
1152       es_fputs ("  ", fp);
1153       binding_shown = 1;
1154     }
1155
1156   /* TRANSLATORS: The %s%s is replaced by either a fingerprint and a
1157      blank or by two empty strings.  */
1158   es_fprintf (fp,
1159               _("Please indicate whether you believe the binding %s%s"
1160                 "is legitimate (the key belongs to the stated owner) "
1161                 "or a forgery (bad)."),
1162               binding_shown ? "" : binding,
1163               binding_shown ? "" : " ");
1164   es_fputc ('\n', fp);
1165
1166   xfree (binding);
1167
1168   es_fputc (0, fp);
1169   if (es_fclose_snatch (fp, (void **)&tmpstr, NULL))
1170     log_fatal ("error snatching memory stream\n");
1171   text = format_text (tmpstr, 0, 72, 80);
1172   es_free (tmpstr);
1173
1174   return text;
1175 }
1176
1177
1178 /* Ask the user about the binding.  There are three ways we could end
1179  * up here:
1180  *
1181  *   - This is a new binding and there is a conflict
1182  *     (policy == TOFU_POLICY_NONE && bindings_with_this_email_count > 0),
1183  *
1184  *   - This is a new binding and opt.tofu_default_policy is set to
1185  *     ask.  (policy == TOFU_POLICY_NONE && opt.tofu_default_policy ==
1186  *     TOFU_POLICY_ASK), or,
1187  *
1188  *   - The policy is ask (the user deferred last time) (policy ==
1189  *     TOFU_POLICY_ASK).
1190  */
1191 static void
1192 ask_about_binding (tofu_dbs_t dbs,
1193                    enum tofu_policy *policy,
1194                    int *trust_level,
1195                    int bindings_with_this_email_count,
1196                    strlist_t bindings_with_this_email,
1197                    char *conflict,
1198                    const char *fingerprint,
1199                    const char *email,
1200                    const char *user_id)
1201 {
1202   char *sqerr = NULL;
1203   int rc;
1204   estream_t fp;
1205   strlist_t other_user_ids = NULL;
1206   struct signature_stats *stats = NULL;
1207   struct signature_stats *stats_iter = NULL;
1208   char *prompt;
1209   char *choices;
1210
1211   fp = es_fopenmem (0, "rw,samethread");
1212   if (!fp)
1213     log_fatal ("error creating memory stream: %s\n",
1214                gpg_strerror (gpg_error_from_syserror()));
1215
1216   {
1217     char *text = format_conflict_msg_part1 (*policy, conflict,
1218                                             fingerprint, email);
1219     es_fputs (text, fp);
1220     es_fputc ('\n', fp);
1221     xfree (text);
1222   }
1223
1224   /* Find other user ids associated with this key and whether the
1225    * bindings are marked as good or bad.  */
1226   rc = gpgsql_stepx
1227     (dbs->db, &dbs->s.get_trust_gather_other_user_ids,
1228      strings_collect_cb2, &other_user_ids, &sqerr,
1229      "select user_id, policy from bindings where fingerprint = ?;",
1230      GPGSQL_ARG_STRING, fingerprint, GPGSQL_ARG_END);
1231   if (rc)
1232     {
1233       log_error (_("error gathering other user IDs: %s\n"), sqerr);
1234       sqlite3_free (sqerr);
1235       sqerr = NULL;
1236     }
1237
1238   if (other_user_ids)
1239     {
1240       strlist_t strlist_iter;
1241
1242       es_fprintf (fp, _("Known user IDs associated with this key:\n"));
1243       for (strlist_iter = other_user_ids;
1244            strlist_iter;
1245            strlist_iter = strlist_iter->next)
1246         {
1247           char *other_user_id = strlist_iter->d;
1248           char *other_thing;
1249           enum tofu_policy other_policy;
1250
1251           log_assert (strlist_iter->next);
1252           strlist_iter = strlist_iter->next;
1253           other_thing = strlist_iter->d;
1254
1255           other_policy = atoi (other_thing);
1256
1257           es_fprintf (fp, "  %s (", other_user_id);
1258           es_fprintf (fp, _("policy: %s"), tofu_policy_str (other_policy));
1259           es_fprintf (fp, ")\n");
1260         }
1261       es_fprintf (fp, "\n");
1262
1263       free_strlist (other_user_ids);
1264     }
1265
1266   /* Find other keys associated with this email address.  */
1267   /* FIXME: When generating the statistics, do we want the time
1268      embedded in the signature (column 'sig_time') or the time that
1269      we first verified the signature (column 'time').  */
1270   rc = gpgsql_stepx
1271     (dbs->db, &dbs->s.get_trust_gather_other_keys,
1272      signature_stats_collect_cb, &stats, &sqerr,
1273      "select fingerprint, policy, time_ago, count(*)\n"
1274      " from (select bindings.*,\n"
1275      "        case\n"
1276      /* From the future (but if its just a couple of hours in the
1277       * future don't turn it into a warning)?  Or should we use
1278       * small, medium or large units?  (Note: whatever we do, we
1279       * keep the value in seconds.  Then when we group, everything
1280       * that rounds to the same number of seconds is grouped.)  */
1281      "         when delta < -("STRINGIFY (TIME_AGO_FUTURE_IGNORE)") then -1\n"
1282      "         when delta < ("STRINGIFY (TIME_AGO_MEDIUM_THRESHOLD)")\n"
1283      "          then max(0,\n"
1284      "                   round(delta / ("STRINGIFY (TIME_AGO_UNIT_SMALL)"))\n"
1285      "               * ("STRINGIFY (TIME_AGO_UNIT_SMALL)"))\n"
1286      "         when delta < ("STRINGIFY (TIME_AGO_LARGE_THRESHOLD)")\n"
1287      "          then round(delta / ("STRINGIFY (TIME_AGO_UNIT_MEDIUM)"))\n"
1288      "               * ("STRINGIFY (TIME_AGO_UNIT_MEDIUM)")\n"
1289      "         else round(delta / ("STRINGIFY (TIME_AGO_UNIT_LARGE)"))\n"
1290      "              * ("STRINGIFY (TIME_AGO_UNIT_LARGE)")\n"
1291      "        end time_ago,\n"
1292      "        delta time_ago_raw\n"
1293      "       from bindings\n"
1294      "       left join\n"
1295      "         (select *,\n"
1296      "            cast(strftime('%s','now') - sig_time as real) delta\n"
1297      "           from signatures) ss\n"
1298      "        on ss.binding = bindings.oid)\n"
1299      " where email = ?\n"
1300      " group by fingerprint, time_ago\n"
1301      /* Make sure the current key is first.  */
1302      " order by fingerprint = ? asc, fingerprint desc, time_ago desc;\n",
1303      GPGSQL_ARG_STRING, email, GPGSQL_ARG_STRING, fingerprint,
1304      GPGSQL_ARG_END);
1305   if (rc)
1306     {
1307       strlist_t strlist_iter;
1308
1309       log_error (_("error gathering signature stats: %s\n"), sqerr);
1310       sqlite3_free (sqerr);
1311       sqerr = NULL;
1312
1313       es_fprintf (fp, ngettext("The email address \"%s\" is"
1314                                " associated with %d key:\n",
1315                                "The email address \"%s\" is"
1316                                " associated with %d keys:\n",
1317                                bindings_with_this_email_count),
1318                   email, bindings_with_this_email_count);
1319       for (strlist_iter = bindings_with_this_email;
1320            strlist_iter;
1321            strlist_iter = strlist_iter->next)
1322         es_fprintf (fp, "  %s\n", strlist_iter->d);
1323     }
1324   else
1325     {
1326       char *key = NULL;
1327
1328       if (! stats || strcmp (stats->fingerprint, fingerprint))
1329         {
1330           /* If we have already added this key to the DB, then it will
1331            * be first (see the above select).  Since the first key on
1332            * the list is not this key, we must not yet have verified any
1333            * messages signed by this key.  Add a dummy entry.  */
1334           signature_stats_prepend (&stats, fingerprint, TOFU_POLICY_AUTO, 0, 0);
1335         }
1336
1337       es_fprintf (fp, _("Statistics for keys with the email address \"%s\":\n"),
1338                   email);
1339       for (stats_iter = stats; stats_iter; stats_iter = stats_iter->next)
1340         {
1341           if (! key || strcmp (key, stats_iter->fingerprint))
1342             {
1343               int this_key;
1344               char *key_pp;
1345
1346               key = stats_iter->fingerprint;
1347               this_key = strcmp (key, fingerprint) == 0;
1348               key_pp = format_hexfingerprint (key, NULL, 0);
1349               es_fprintf (fp, "  %s (", key_pp);
1350               if (this_key)
1351                 es_fprintf (fp, _("this key"));
1352               else
1353                 es_fprintf (fp, _("policy: %s"),
1354                             tofu_policy_str (stats_iter->policy));
1355               es_fputs ("):\n", fp);
1356               xfree (key_pp);
1357             }
1358
1359           es_fputs ("    ", fp);
1360           if (stats_iter->time_ago == -1)
1361             es_fprintf (fp, ngettext("%ld message signed in the future.",
1362                                      "%ld messages signed in the future.",
1363                                      stats_iter->count), stats_iter->count);
1364           else
1365             {
1366               long t_scaled = time_ago_scale (stats_iter->time_ago);
1367
1368               /* TANSLATORS: This string is concatenated with one of
1369                * the day/week/month strings to form one sentence.  */
1370               es_fprintf (fp, ngettext("%ld message signed",
1371                                        "%ld messages signed",
1372                                        stats_iter->count), stats_iter->count);
1373               if (!stats_iter->count)
1374                 es_fputs (".", fp);
1375               else if (stats_iter->time_ago < TIME_AGO_UNIT_MEDIUM)
1376                 es_fprintf (fp, ngettext(" over the past %ld day.",
1377                                          " over the past %ld days.",
1378                                          t_scaled), t_scaled);
1379               else if (stats_iter->time_ago < TIME_AGO_UNIT_LARGE)
1380                 es_fprintf (fp, ngettext(" over the past %ld week.",
1381                                          " over the past %ld weeks.",
1382                                          t_scaled), t_scaled);
1383               else
1384                 es_fprintf (fp, ngettext(" over the past %ld month.",
1385                                          " over the past %ld months.",
1386                                          t_scaled), t_scaled);
1387             }
1388           es_fputs ("\n", fp);
1389         }
1390     }
1391
1392
1393   if ((*policy == TOFU_POLICY_NONE && bindings_with_this_email_count > 0)
1394       || (*policy == TOFU_POLICY_ASK
1395           && (conflict || bindings_with_this_email_count > 0)))
1396     {
1397       /* This is a conflict.  */
1398
1399       /* TRANSLATORS: Please translate the text found in the source
1400        * file below.  We don't directly internationalize that text so
1401        * that we can tweak it without breaking translations.  */
1402       char *text = _("TOFU detected a binding conflict");
1403       char *textbuf;
1404       if (!strcmp (text, "TOFU detected a binding conflict"))
1405         {
1406           /* No translation.  Use the English text.  */
1407           text =
1408             "Normally, there is only a single key associated with an email "
1409             "address.  However, people sometimes generate a new key if "
1410             "their key is too old or they think it might be compromised.  "
1411             "Alternatively, a new key may indicate a man-in-the-middle "
1412             "attack!  Before accepting this key, you should talk to or "
1413             "call the person to make sure this new key is legitimate.";
1414         }
1415       textbuf = format_text (text, 0, 72, 80);
1416       es_fprintf (fp, "\n%s\n", textbuf);
1417       xfree (textbuf);
1418     }
1419
1420   es_fputc ('\n', fp);
1421
1422   /* Add a NUL terminator.  */
1423   es_fputc (0, fp);
1424   if (es_fclose_snatch (fp, (void **) &prompt, NULL))
1425     log_fatal ("error snatching memory stream\n");
1426
1427   /* I think showing the large message once is sufficient.  If we
1428    * would move it right before the cpr_get many lines will scroll
1429    * away and the user might not realize that he merely entered a
1430    * wrong choise (because he does not see that either).  As a small
1431    * benefit we allow C-L to redisplay everything.  */
1432   tty_printf ("%s", prompt);
1433   while (1)
1434     {
1435       char *response;
1436
1437       /* TRANSLATORS: Two letters (normally the lower and upper case
1438        * version of the hotkey) for each of the five choices.  If
1439        * there is only one choice in your language, repeat it.  */
1440       choices = _("gG" "aA" "uU" "rR" "bB");
1441       if (strlen (choices) != 10)
1442         log_bug ("Bad TOFU conflict translation!  Please report.");
1443
1444       response = cpr_get
1445         ("tofu.conflict",
1446          _("(G)ood, (A)ccept once, (U)nknown, (R)eject once, (B)ad? "));
1447       trim_spaces (response);
1448       cpr_kill_prompt ();
1449       if (*response == CONTROL_L)
1450         tty_printf ("%s", prompt);
1451       else if (strlen (response) == 1)
1452         {
1453           char *choice = strchr (choices, *response);
1454           if (choice)
1455             {
1456               int c = ((size_t) choice - (size_t) choices) / 2;
1457
1458               switch (c)
1459                 {
1460                 case 0: /* Good.  */
1461                   *policy = TOFU_POLICY_GOOD;
1462                   *trust_level = tofu_policy_to_trust_level (*policy);
1463                   break;
1464                 case 1: /* Accept once.  */
1465                   *policy = TOFU_POLICY_ASK;
1466                   *trust_level = tofu_policy_to_trust_level (TOFU_POLICY_GOOD);
1467                   break;
1468                 case 2: /* Unknown.  */
1469                   *policy = TOFU_POLICY_UNKNOWN;
1470                   *trust_level = tofu_policy_to_trust_level (*policy);
1471                   break;
1472                 case 3: /* Reject once.  */
1473                   *policy = TOFU_POLICY_ASK;
1474                   *trust_level = tofu_policy_to_trust_level (TOFU_POLICY_BAD);
1475                   break;
1476                 case 4: /* Bad.  */
1477                   *policy = TOFU_POLICY_BAD;
1478                   *trust_level = tofu_policy_to_trust_level (*policy);
1479                   break;
1480                 default:
1481                   log_bug ("c should be between 0 and 4 but it is %d!", c);
1482                 }
1483
1484               if (record_binding (dbs, fingerprint, email, user_id,
1485                                   *policy, 0))
1486                 {
1487                   /* If there's an error registering the
1488                    * binding, don't save the signature.  */
1489                   *trust_level = _tofu_GET_TRUST_ERROR;
1490                 }
1491               break;
1492             }
1493         }
1494       xfree (response);
1495     }
1496
1497   xfree (prompt);
1498
1499   signature_stats_free (stats);
1500 }
1501
1502
1503 /* Return the trust level (TRUST_NEVER, etc.) for the binding
1504  * <FINGERPRINT, EMAIL> (email is already normalized).  If no policy
1505  * is registered, returns TOFU_POLICY_NONE.  If an error occurs,
1506  * returns _tofu_GET_TRUST_ERROR.
1507  *
1508  * PK is the public key object for FINGERPRINT.
1509  *
1510  * USER_ID is the unadulterated user id.
1511  *
1512  * If MAY_ASK is set, then we may interact with the user.  This is
1513  * necessary if there is a conflict or the binding's policy is
1514  * TOFU_POLICY_ASK.  In the case of a conflict, we set the new
1515  * conflicting binding's policy to TOFU_POLICY_ASK.  In either case,
1516  * we return TRUST_UNDEFINED.  */
1517 static enum tofu_policy
1518 get_trust (tofu_dbs_t dbs, PKT_public_key *pk,
1519            const char *fingerprint, const char *email,
1520            const char *user_id, int may_ask)
1521 {
1522   enum tofu_policy policy;
1523   char *conflict = NULL;
1524   int rc;
1525   char *sqerr = NULL;
1526   strlist_t bindings_with_this_email = NULL;
1527   int bindings_with_this_email_count;
1528   int change_conflicting_to_ask = 0;
1529   int trust_level = TRUST_UNKNOWN;
1530
1531   if (opt.batch)
1532     may_ask = 0;
1533
1534   /* Make sure _tofu_GET_TRUST_ERROR isn't equal to any of the trust
1535      levels.  */
1536   log_assert (_tofu_GET_TRUST_ERROR != TRUST_UNKNOWN
1537               && _tofu_GET_TRUST_ERROR != TRUST_EXPIRED
1538               && _tofu_GET_TRUST_ERROR != TRUST_UNDEFINED
1539               && _tofu_GET_TRUST_ERROR != TRUST_NEVER
1540               && _tofu_GET_TRUST_ERROR != TRUST_MARGINAL
1541               && _tofu_GET_TRUST_ERROR != TRUST_FULLY
1542               && _tofu_GET_TRUST_ERROR != TRUST_ULTIMATE);
1543
1544   policy = get_policy (dbs, fingerprint, email, &conflict);
1545   if (policy == TOFU_POLICY_AUTO || policy == TOFU_POLICY_NONE)
1546     { /* See if the key is ultimately trusted.  If so, we're done.  */
1547       u32 kid[2];
1548
1549       keyid_from_pk (pk, kid);
1550
1551       if (tdb_keyid_is_utk (kid))
1552         {
1553           if (policy == TOFU_POLICY_NONE)
1554             {
1555               if (record_binding (dbs, fingerprint, email, user_id,
1556                                   TOFU_POLICY_AUTO, 0) != 0)
1557                 {
1558                   log_error (_("error setting TOFU binding's trust level"
1559                                " to %s\n"), "auto");
1560                   trust_level = _tofu_GET_TRUST_ERROR;
1561                   goto out;
1562                 }
1563             }
1564
1565           trust_level = TRUST_ULTIMATE;
1566           goto out;
1567         }
1568     }
1569
1570   if (policy == TOFU_POLICY_AUTO)
1571     {
1572       policy = opt.tofu_default_policy;
1573       if (DBG_TRUST)
1574         log_debug ("TOFU: binding <key: %s, user id: %s>'s policy is "
1575                    " auto (default: %s).\n",
1576                    fingerprint, email,
1577                    tofu_policy_str (opt.tofu_default_policy));
1578     }
1579   switch (policy)
1580     {
1581     case TOFU_POLICY_AUTO:
1582     case TOFU_POLICY_GOOD:
1583     case TOFU_POLICY_UNKNOWN:
1584     case TOFU_POLICY_BAD:
1585       /* The saved judgement is auto -> auto, good, unknown or bad.
1586        * We don't need to ask the user anything.  */
1587       if (DBG_TRUST)
1588         log_debug ("TOFU: Known binding <key: %s, user id: %s>'s policy: %s\n",
1589                    fingerprint, email, tofu_policy_str (policy));
1590       trust_level = tofu_policy_to_trust_level (policy);
1591       goto out;
1592
1593     case TOFU_POLICY_ASK:
1594       /* We need to ask the user what to do.  Case #1 or #2 below.  */
1595       if (! may_ask)
1596         {
1597           trust_level = TRUST_UNDEFINED;
1598           goto out;
1599         }
1600
1601       break;
1602
1603     case TOFU_POLICY_NONE:
1604       /* The binding is new, we need to check for conflicts.  Case #3
1605        * below.  */
1606       break;
1607
1608     case _tofu_GET_POLICY_ERROR:
1609       trust_level = _tofu_GET_TRUST_ERROR;
1610       goto out;
1611
1612     default:
1613       log_bug ("%s: Impossible value for policy (%d)\n", __func__, policy);
1614     }
1615
1616
1617   /* We get here if:
1618    *
1619    *   1. The saved policy is auto and the default policy is ask
1620    *      (get_policy() == TOFU_POLICY_AUTO
1621    *       && opt.tofu_default_policy == TOFU_POLICY_ASK)
1622    *
1623    *   2. The saved policy is ask (either last time the user selected
1624    *      accept once or reject once or there was a conflict and this
1625    *      binding's policy was changed from auto to ask)
1626    *      (policy == TOFU_POLICY_ASK), or,
1627    *
1628    *   3. We don't have a saved policy (policy == TOFU_POLICY_NONE)
1629    *      (need to check for a conflict).
1630    */
1631
1632   /* Look for conflicts.  This is needed in all 3 cases.
1633    *
1634    * Get the fingerprints of any bindings that share the email
1635    * address.  Note: if the binding in question is in the DB, it will
1636    * also be returned.  Thus, if the result set is empty, then this is
1637    * a new binding.  */
1638   rc = gpgsql_stepx
1639     (dbs->db, &dbs->s.get_trust_bindings_with_this_email,
1640      strings_collect_cb2, &bindings_with_this_email, &sqerr,
1641      "select distinct fingerprint from bindings where email = ?;",
1642      GPGSQL_ARG_STRING, email, GPGSQL_ARG_END);
1643   if (rc)
1644     {
1645       log_error (_("error reading TOFU database: %s\n"), sqerr);
1646       print_further_info ("listing fingerprints");
1647       sqlite3_free (sqerr);
1648       goto out;
1649     }
1650
1651   bindings_with_this_email_count = strlist_length (bindings_with_this_email);
1652   if (bindings_with_this_email_count == 0
1653       && opt.tofu_default_policy != TOFU_POLICY_ASK)
1654     {
1655       /* New binding with no conflict and a concrete default policy.
1656        *
1657        * We've never observed a binding with this email address
1658        * BINDINGS_WITH_THIS_EMAIL_COUNT is 0 and the above query would
1659        * return the current binding if it were in the DB) and we have
1660        * a default policy, which is not to ask the user.
1661        */
1662
1663       /* If we've seen this binding, then we've seen this email and
1664          policy couldn't possibly be TOFU_POLICY_NONE.  */
1665       log_assert (policy == TOFU_POLICY_NONE);
1666
1667       if (DBG_TRUST)
1668         log_debug ("TOFU: New binding <key: %s, user id: %s>, no conflict.\n",
1669                    fingerprint, email);
1670
1671       if (record_binding (dbs, fingerprint, email, user_id,
1672                           TOFU_POLICY_AUTO, 0) != 0)
1673         {
1674           log_error (_("error setting TOFU binding's trust level to %s\n"),
1675                        "auto");
1676           trust_level = _tofu_GET_TRUST_ERROR;
1677           goto out;
1678         }
1679
1680       trust_level = tofu_policy_to_trust_level (TOFU_POLICY_AUTO);
1681       goto out;
1682     }
1683
1684   if (policy == TOFU_POLICY_NONE)
1685     {
1686       /* This is a new binding and we have a conflict.  Mark any
1687        * conflicting bindings that have an automatic policy as now
1688        * requiring confirmation.  Note: we delay this until after we
1689        * ask for confirmation so that when the current policy is
1690        * printed, it is correct.  */
1691       change_conflicting_to_ask = 1;
1692     }
1693
1694   if (! may_ask)
1695     {
1696       /* We can only get here in the third case (no saved policy) and
1697        * if there is a conflict.  (If the policy was ask (cases #1 and
1698        * #2) and we weren't allowed to ask, we'd have already exited).  */
1699       log_assert (policy == TOFU_POLICY_NONE);
1700
1701       if (record_binding (dbs, fingerprint, email, user_id,
1702                           TOFU_POLICY_ASK, 0) != 0)
1703         log_error (_("error setting TOFU binding's trust level to %s\n"),
1704                    "ask");
1705
1706       trust_level = TRUST_UNDEFINED;
1707       goto out;
1708     }
1709
1710   /* If we get here, we need to ask the user about the binding.  */
1711   ask_about_binding (dbs,
1712                      &policy,
1713                      &trust_level,
1714                      bindings_with_this_email_count,
1715                      bindings_with_this_email,
1716                      conflict,
1717                      fingerprint,
1718                      email,
1719                      user_id);
1720
1721  out:
1722   if (change_conflicting_to_ask)
1723     {
1724       if (! may_ask)
1725         {
1726           /* If we weren't allowed to ask, also update this key as
1727              conflicting with itself.  */
1728           rc = gpgsql_exec_printf
1729             (dbs->db, NULL, NULL, &sqerr,
1730              "update bindings set policy = %d, conflict = %Q"
1731              " where email = %Q"
1732              "  and (policy = %d or (policy = %d and fingerprint = %Q));",
1733              TOFU_POLICY_ASK, fingerprint, email, TOFU_POLICY_AUTO,
1734              TOFU_POLICY_ASK, fingerprint);
1735         }
1736       else
1737         {
1738           rc = gpgsql_exec_printf
1739             (dbs->db, NULL, NULL, &sqerr,
1740              "update bindings set policy = %d, conflict = %Q"
1741              " where email = %Q and fingerprint != %Q and policy = %d;",
1742              TOFU_POLICY_ASK, fingerprint, email, fingerprint,
1743              TOFU_POLICY_AUTO);
1744         }
1745
1746       if (rc)
1747         {
1748           log_error (_("error changing TOFU policy: %s\n"), sqerr);
1749           sqlite3_free (sqerr);
1750           sqerr = NULL;
1751         }
1752     }
1753
1754   xfree (conflict);
1755   free_strlist (bindings_with_this_email);
1756
1757   return trust_level;
1758 }
1759
1760
1761 /* Return a malloced string of the form
1762  *    "7 months, 1 day, 5 minutes, 0 seconds"
1763  * The caller should replace all '~' in the returned string by a space
1764  * and also free the returned string.
1765  *
1766  * This is actually a bad hack which may not work correctly with all
1767  * languages.
1768  */
1769 static char *
1770 time_ago_str (long long int t)
1771 {
1772   estream_t fp;
1773   int years = 0;
1774   int months = 0;
1775   int days = 0;
1776   int hours = 0;
1777   int minutes = 0;
1778   int seconds = 0;
1779
1780   /* The number of units that we've printed so far.  */
1781   int count = 0;
1782   /* The first unit that we printed (year = 0, month = 1,
1783      etc.).  */
1784   int first = -1;
1785   /* The current unit.  */
1786   int i = 0;
1787
1788   char *str;
1789
1790   /* It would be nice to use a macro to do this, but gettext
1791      works on the unpreprocessed code.  */
1792 #define MIN_SECS (60)
1793 #define HOUR_SECS (60 * MIN_SECS)
1794 #define DAY_SECS (24 * HOUR_SECS)
1795 #define MONTH_SECS (30 * DAY_SECS)
1796 #define YEAR_SECS (365 * DAY_SECS)
1797
1798   if (t > YEAR_SECS)
1799     {
1800       years = t / YEAR_SECS;
1801       t -= years * YEAR_SECS;
1802     }
1803   if (t > MONTH_SECS)
1804     {
1805       months = t / MONTH_SECS;
1806       t -= months * MONTH_SECS;
1807     }
1808   if (t > DAY_SECS)
1809     {
1810       days = t / DAY_SECS;
1811       t -= days * DAY_SECS;
1812     }
1813   if (t > HOUR_SECS)
1814     {
1815       hours = t / HOUR_SECS;
1816       t -= hours * HOUR_SECS;
1817     }
1818   if (t > MIN_SECS)
1819     {
1820       minutes = t / MIN_SECS;
1821       t -= minutes * MIN_SECS;
1822     }
1823   seconds = t;
1824
1825 #undef MIN_SECS
1826 #undef HOUR_SECS
1827 #undef DAY_SECS
1828 #undef MONTH_SECS
1829 #undef YEAR_SECS
1830
1831   fp = es_fopenmem (0, "rw,samethread");
1832   if (! fp)
1833     log_fatal ("error creating memory stream: %s\n",
1834                gpg_strerror (gpg_error_from_syserror()));
1835
1836   if (years)
1837     {
1838       /* TRANSLATORS: The tilde ('~') is used here to indicate a
1839        * non-breakable space  */
1840       es_fprintf (fp, ngettext("%d~year", "%d~years", years), years);
1841       count ++;
1842       first = i;
1843     }
1844   i ++;
1845   if ((first == -1 || i - first <= 3) && months)
1846     {
1847       if (count)
1848         es_fprintf (fp, ", ");
1849       es_fprintf (fp, ngettext("%d~month", "%d~months", months), months);
1850       count ++;
1851       first = i;
1852     }
1853   i ++;
1854   if ((first == -1 || i - first <= 3) && count < 2 && days)
1855     {
1856       if (count)
1857         es_fprintf (fp, ", ");
1858       es_fprintf (fp, ngettext("%d~day", "%d~days", days), days);
1859       count ++;
1860       first = i;
1861     }
1862   i ++;
1863   if ((first == -1 || i - first <= 3) && count < 2 && hours)
1864     {
1865       if (count)
1866         es_fprintf (fp, ", ");
1867       es_fprintf (fp, ngettext("%d~hour", "%d~hours", hours), hours);
1868       count ++;
1869       first = i;
1870     }
1871   i ++;
1872   if ((first == -1 || i - first <= 3) && count < 2 && minutes)
1873     {
1874       if (count)
1875         es_fprintf (fp, ", ");
1876       es_fprintf (fp, ngettext("%d~minute", "%d~minutes", minutes), minutes);
1877       count ++;
1878       first = i;
1879     }
1880   i ++;
1881   if ((first == -1 || i - first <= 3) && count < 2)
1882     {
1883       if (count)
1884         es_fprintf (fp, ", ");
1885       es_fprintf (fp, ngettext("%d~second", "%d~seconds", seconds), seconds);
1886     }
1887
1888   es_fputc (0, fp);
1889   if (es_fclose_snatch (fp, (void **) &str, NULL))
1890     log_fatal ("error snatching memory stream\n");
1891
1892   return str;
1893 }
1894
1895
1896 /* If FP is NULL, write TOFU_STATS status line.  If FP is not NULL
1897  * write a "tfs" record to that stream. */
1898 static void
1899 write_stats_status (estream_t fp, long messages, enum tofu_policy policy,
1900                     unsigned long first_seen,
1901                     unsigned long most_recent_seen)
1902 {
1903   const char *validity;
1904
1905   if (messages < 1)
1906     validity = "1"; /* Key without history.  */
1907   else if (messages < BASIC_TRUST_THRESHOLD)
1908     validity = "2"; /* Key with too little history.  */
1909   else if (messages < FULL_TRUST_THRESHOLD)
1910     validity = "3"; /* Key with enough history for basic trust.  */
1911   else
1912     validity = "4"; /* Key with a lot of history.  */
1913
1914   if (fp)
1915     {
1916       es_fprintf (fp, "tfs:1:%s:%ld:0:%s:%lu:%lu:\n",
1917                   validity, messages,
1918                   tofu_policy_str (policy),
1919                   first_seen, most_recent_seen);
1920     }
1921   else
1922     {
1923       char numbuf1[35];
1924       char numbuf2[35];
1925       char numbuf3[35];
1926
1927       snprintf (numbuf1, sizeof numbuf1, " %ld", messages);
1928       *numbuf2 = *numbuf3 = 0;
1929       if (first_seen && most_recent_seen)
1930         {
1931           snprintf (numbuf2, sizeof numbuf2, " %lu", first_seen);
1932           snprintf (numbuf3, sizeof numbuf3, " %lu", most_recent_seen);
1933         }
1934
1935       write_status_strings (STATUS_TOFU_STATS,
1936                             validity, numbuf1, " 0",
1937                             " ", tofu_policy_str (policy),
1938                             numbuf2, numbuf3,
1939                             NULL);
1940     }
1941 }
1942
1943
1944 /* Note: If OUTFP is not NULL, this function merely prints a "tfs" record
1945  * to OUTFP.  In this case USER_ID is not required.  */
1946 static void
1947 show_statistics (tofu_dbs_t dbs, const char *fingerprint,
1948                  const char *email, const char *user_id,
1949                  const char *sig_exclude, estream_t outfp)
1950 {
1951   char *fingerprint_pp;
1952   int rc;
1953   strlist_t strlist = NULL;
1954   char *err = NULL;
1955
1956   fingerprint_pp = format_hexfingerprint (fingerprint, NULL, 0);
1957
1958   rc = gpgsql_exec_printf
1959     (dbs->db, strings_collect_cb, &strlist, &err,
1960      "select count (*), min (signatures.time), max (signatures.time)\n"
1961      " from signatures\n"
1962      " left join bindings on signatures.binding = bindings.oid\n"
1963      " where fingerprint = %Q and email = %Q and sig_digest %s%s%s;",
1964      fingerprint, email,
1965      /* We want either: sig_digest != 'SIG_EXCLUDE' or sig_digest is
1966         not NULL.  */
1967      sig_exclude ? "!= '" : "is not NULL",
1968      sig_exclude ? sig_exclude : "",
1969      sig_exclude ? "'" : "");
1970   if (rc)
1971     {
1972       log_error (_("error reading TOFU database: %s\n"), err);
1973       print_further_info ("getting statistics");
1974       sqlite3_free (err);
1975       goto out;
1976     }
1977
1978   if (!outfp)
1979     write_status_text_and_buffer (STATUS_TOFU_USER, fingerprint,
1980                                   email, strlen (email), 0);
1981
1982   if (! strlist)
1983     {
1984       if (!outfp)
1985         log_info (_("Have never verified a message signed by key %s!\n"),
1986                   fingerprint_pp);
1987       write_stats_status (outfp, 0, TOFU_POLICY_NONE, 0, 0);
1988     }
1989   else
1990     {
1991       unsigned long now = gnupg_get_time ();
1992       signed long messages;
1993       unsigned long first_seen;
1994       unsigned long most_recent_seen;
1995
1996       log_assert (strlist_length (strlist) == 3);
1997
1998       string_to_long (&messages, strlist->d, -1, __LINE__);
1999
2000       if (messages == 0 && *strlist->next->d == '\0')
2001         { /* min(NULL) => NULL => "".  */
2002           first_seen = 0;
2003           most_recent_seen = 0;
2004         }
2005       else
2006         {
2007           string_to_ulong (&first_seen, strlist->next->d, -1, __LINE__);
2008           if (first_seen > now)
2009             {
2010               log_debug ("time-warp - tofu DB has a future value (%lu, %lu)\n",
2011                          first_seen, now);
2012               first_seen = now;
2013             }
2014           string_to_ulong (&most_recent_seen, strlist->next->next->d, -1,
2015                            __LINE__);
2016           if (most_recent_seen > now)
2017             {
2018               log_debug ("time-warp - tofu DB has a future value (%lu, %lu)\n",
2019                          most_recent_seen, now);
2020               most_recent_seen = now;
2021             }
2022
2023         }
2024
2025       if (messages == -1 || !first_seen)
2026         {
2027           write_stats_status (outfp, 0, TOFU_POLICY_NONE, 0, 0);
2028           if (!outfp)
2029             log_info (_("Failed to collect signature statistics for \"%s\"\n"
2030                         "(key %s)\n"),
2031                       user_id, fingerprint_pp);
2032         }
2033       else if (outfp)
2034         {
2035           write_stats_status (outfp, messages,
2036                               get_policy (dbs, fingerprint, email, NULL),
2037                               first_seen, most_recent_seen);
2038         }
2039       else
2040         {
2041           enum tofu_policy policy = get_policy (dbs, fingerprint, email, NULL);
2042           estream_t fp;
2043           char *msg;
2044
2045           write_stats_status (NULL, messages,
2046                               policy,
2047                               first_seen, most_recent_seen);
2048
2049           fp = es_fopenmem (0, "rw,samethread");
2050           if (! fp)
2051             log_fatal ("error creating memory stream: %s\n",
2052                        gpg_strerror (gpg_error_from_syserror()));
2053
2054           if (messages == 0)
2055             {
2056               es_fprintf (fp, _("Verified %ld messages signed by \"%s\"."),
2057                           0L, user_id);
2058               es_fputc ('\n', fp);
2059             }
2060           else
2061             {
2062               char *first_seen_ago_str = time_ago_str (now - first_seen);
2063
2064               /* TRANSLATORS: The final %s is replaced by a string like
2065                  "7 months, 1 day, 5 minutes, 0 seconds". */
2066               es_fprintf (fp,
2067                           ngettext("Verified %ld message signed by \"%s\"\n"
2068                                    "in the past %s.",
2069                                    "Verified %ld messages signed by \"%s\"\n"
2070                                    "in the past %s.",
2071                                    messages),
2072                           messages, user_id, first_seen_ago_str);
2073
2074               if (messages > 1)
2075                 {
2076                   char *tmpstr = time_ago_str (now - most_recent_seen);
2077                   es_fputs ("  ", fp);
2078                   es_fprintf (fp, _("The most recent message was"
2079                                     " verified %s ago."), tmpstr);
2080                   xfree (tmpstr);
2081                 }
2082               xfree (first_seen_ago_str);
2083
2084               if (opt.verbose)
2085                 {
2086                   es_fputs ("  ", fp);
2087                   es_fputc ('(', fp);
2088                   es_fprintf (fp, _("policy: %s"), tofu_policy_str (policy));
2089                   es_fputs (")\n", fp);
2090                 }
2091               else
2092                 es_fputs ("\n", fp);
2093             }
2094
2095           {
2096             char *tmpmsg, *p;
2097             es_fputc (0, fp);
2098             if (es_fclose_snatch (fp, (void **) &tmpmsg, NULL))
2099               log_fatal ("error snatching memory stream\n");
2100             msg = format_text (tmpmsg, 0, 72, 80);
2101             es_free (tmpmsg);
2102
2103             /* Print a status line but suppress the trailing LF.
2104              * Spaces are not percent escaped. */
2105             if (*msg)
2106               write_status_buffer (STATUS_TOFU_STATS_LONG,
2107                                    msg, strlen (msg)-1, -1);
2108
2109             /* Remove the non-breaking space markers.  */
2110             for (p=msg; *p; p++)
2111               if (*p == '~')
2112                 *p = ' ';
2113
2114           }
2115
2116           log_string (GPGRT_LOG_INFO, msg);
2117           xfree (msg);
2118
2119           if (policy == TOFU_POLICY_AUTO && messages < BASIC_TRUST_THRESHOLD)
2120             {
2121               char *set_policy_command;
2122               char *text;
2123               char *tmpmsg;
2124
2125               if (messages == 0)
2126                 log_info (_("Warning: we've have yet to see"
2127                             " a message signed by this key!\n"));
2128               else if (messages == 1)
2129                 log_info (_("Warning: we've only seen a"
2130                             " single message signed by this key!\n"));
2131
2132               set_policy_command =
2133                 xasprintf ("gpg --tofu-policy bad %s", fingerprint);
2134
2135               tmpmsg = xasprintf
2136                 (ngettext
2137                  ("Warning: if you think you've seen more than %ld message "
2138                   "signed by this key, then this key might be a forgery!  "
2139                   "Carefully examine the email address for small "
2140                   "variations.  If the key is suspect, then use\n"
2141                   "  %s\n"
2142                   "to mark it as being bad.\n",
2143                   "Warning: if you think you've seen more than %ld messages "
2144                   "signed by this key, then this key might be a forgery!  "
2145                       "Carefully examine the email address for small "
2146                   "variations.  If the key is suspect, then use\n"
2147                   "  %s\n"
2148                   "to mark it as being bad.\n",
2149                   messages),
2150                   messages, set_policy_command);
2151               text = format_text (tmpmsg, 0, 72, 80);
2152               xfree (tmpmsg);
2153               log_string (GPGRT_LOG_INFO, text);
2154               xfree (text);
2155
2156               es_free (set_policy_command);
2157             }
2158         }
2159     }
2160
2161  out:
2162   free_strlist (strlist);
2163   xfree (fingerprint_pp);
2164
2165   return;
2166 }
2167
2168 /* Extract the email address from a user id and normalize it.  If the
2169    user id doesn't contain an email address, then we use the whole
2170    user_id and normalize that.  The returned string must be freed.  */
2171 static char *
2172 email_from_user_id (const char *user_id)
2173 {
2174   char *email = mailbox_from_userid (user_id);
2175   if (! email)
2176     {
2177       /* Hmm, no email address was provided or we are out of core.  Just
2178          take the lower-case version of the whole user id.  It could be
2179          a hostname, for instance.  */
2180       email = ascii_strlwr (xstrdup (user_id));
2181     }
2182
2183   return email;
2184 }
2185
2186 /* Register the signature with the bindings <fingerprint, USER_ID>,
2187    for each USER_ID in USER_ID_LIST.  The fingerprint is taken from
2188    the primary key packet PK.
2189
2190    SIG_DIGEST_BIN is the binary representation of the message's
2191    digest.  SIG_DIGEST_BIN_LEN is its length.
2192
2193    SIG_TIME is the time that the signature was generated.
2194
2195    ORIGIN is a free-formed string describing the origin of the
2196    signature.  If this was from an email and the Claws MUA was used,
2197    then this should be something like: "email:claws".  If this is
2198    NULL, the default is simply "unknown".
2199
2200    If MAY_ASK is 1, then this function may interact with the user.
2201    This is necessary if there is a conflict or the binding's policy is
2202    TOFU_POLICY_ASK.
2203
2204    This function returns 0 on success and an error code if an error
2205    occured.  */
2206 gpg_error_t
2207 tofu_register (ctrl_t ctrl, PKT_public_key *pk, strlist_t user_id_list,
2208                const byte *sig_digest_bin, int sig_digest_bin_len,
2209                time_t sig_time, const char *origin)
2210 {
2211   gpg_error_t rc;
2212   tofu_dbs_t dbs;
2213   char *fingerprint = NULL;
2214   strlist_t user_id;
2215   char *email = NULL;
2216   char *err = NULL;
2217   char *sig_digest;
2218   unsigned long c;
2219
2220   dbs = opendbs (ctrl);
2221   if (! dbs)
2222     {
2223       rc = gpg_error (GPG_ERR_GENERAL);
2224       log_error (_("error opening TOFU database: %s\n"),
2225                  gpg_strerror (rc));
2226       return rc;
2227     }
2228
2229   /* We do a query and then an insert.  Make sure they are atomic
2230      by wrapping them in a transaction.  */
2231   rc = begin_transaction (ctrl);
2232   if (rc)
2233     return rc;
2234
2235   sig_digest = make_radix64_string (sig_digest_bin, sig_digest_bin_len);
2236   fingerprint = hexfingerprint (pk, NULL, 0);
2237
2238   if (! origin)
2239     /* The default origin is simply "unknown".  */
2240     origin = "unknown";
2241
2242   for (user_id = user_id_list; user_id; user_id = user_id->next)
2243     {
2244       email = email_from_user_id (user_id->d);
2245
2246       if (DBG_TRUST)
2247         log_debug ("TOFU: Registering signature %s with binding"
2248                    " <key: %s, user id: %s>\n",
2249                    sig_digest, fingerprint, email);
2250
2251       /* Make sure the binding exists and record any TOFU
2252          conflicts.  */
2253       if (get_trust (dbs, pk, fingerprint, email, user_id->d, 0)
2254           == _tofu_GET_TRUST_ERROR)
2255         {
2256           rc = gpg_error (GPG_ERR_GENERAL);
2257           xfree (email);
2258           break;
2259         }
2260
2261       /* If we've already seen this signature before, then don't add
2262          it again.  */
2263       rc = gpgsql_stepx
2264         (dbs->db, &dbs->s.register_already_seen,
2265          get_single_unsigned_long_cb2, &c, &err,
2266          "select count (*)\n"
2267          " from signatures left join bindings\n"
2268          "  on signatures.binding = bindings.oid\n"
2269          " where fingerprint = ? and email = ? and sig_time = ?\n"
2270          "  and sig_digest = ?",
2271          GPGSQL_ARG_STRING, fingerprint, GPGSQL_ARG_STRING, email,
2272          GPGSQL_ARG_LONG_LONG, (long long) sig_time,
2273          GPGSQL_ARG_STRING, sig_digest,
2274          GPGSQL_ARG_END);
2275       if (rc)
2276         {
2277           log_error (_("error reading TOFU database: %s\n"), err);
2278           print_further_info ("checking existence");
2279           sqlite3_free (err);
2280         }
2281       else if (c > 1)
2282         /* Duplicates!  This should not happen.  In particular,
2283            because <fingerprint, email, sig_time, sig_digest> is the
2284            primary key!  */
2285         log_debug ("SIGNATURES DB contains duplicate records"
2286                    " <key: %s, fingerprint: %s, time: 0x%lx, sig: %s,"
2287                    " origin: %s>."
2288                    "  Please report.\n",
2289                    fingerprint, email, (unsigned long) sig_time,
2290                    sig_digest, origin);
2291       else if (c == 1)
2292         {
2293           if (DBG_TRUST)
2294             log_debug ("Already observed the signature and binding"
2295                        " <key: %s, user id: %s, time: 0x%lx, sig: %s,"
2296                        " origin: %s>\n",
2297                        fingerprint, email, (unsigned long) sig_time,
2298                        sig_digest, origin);
2299         }
2300       else if (opt.dry_run)
2301         {
2302           log_info ("TOFU database update skipped due to --dry-run\n");
2303         }
2304       else
2305         /* This is the first time that we've seen this signature and
2306            binding.  Record it.  */
2307         {
2308           if (DBG_TRUST)
2309             log_debug ("TOFU: Saving signature"
2310                        " <key: %s, user id: %s, sig: %s>\n",
2311                        fingerprint, email, sig_digest);
2312
2313           log_assert (c == 0);
2314
2315           rc = gpgsql_stepx
2316             (dbs->db, &dbs->s.register_insert, NULL, NULL, &err,
2317              "insert into signatures\n"
2318              " (binding, sig_digest, origin, sig_time, time)\n"
2319              " values\n"
2320              " ((select oid from bindings\n"
2321              "    where fingerprint = ? and email = ?),\n"
2322              "  ?, ?, ?, strftime('%s', 'now'));",
2323              GPGSQL_ARG_STRING, fingerprint, GPGSQL_ARG_STRING, email,
2324              GPGSQL_ARG_STRING, sig_digest, GPGSQL_ARG_STRING, origin,
2325              GPGSQL_ARG_LONG_LONG, (long long) sig_time,
2326              GPGSQL_ARG_END);
2327           if (rc)
2328             {
2329               log_error (_("error updating TOFU database: %s\n"), err);
2330               print_further_info ("insert signatures");
2331               sqlite3_free (err);
2332             }
2333         }
2334
2335       xfree (email);
2336
2337       if (rc)
2338         break;
2339     }
2340
2341   if (rc)
2342     rollback_transaction (ctrl);
2343   else
2344     rc = end_transaction (ctrl, 0);
2345
2346   xfree (fingerprint);
2347   xfree (sig_digest);
2348
2349   return rc;
2350 }
2351
2352 /* Combine a trust level returned from the TOFU trust model with a
2353    trust level returned by the PGP trust model.  This is primarily of
2354    interest when the trust model is tofu+pgp (TM_TOFU_PGP).
2355
2356    This function ors together the upper bits (the values not covered
2357    by TRUST_MASK, i.e., TRUST_FLAG_REVOKED, etc.).  */
2358 int
2359 tofu_wot_trust_combine (int tofu_base, int wot_base)
2360 {
2361   int tofu = tofu_base & TRUST_MASK;
2362   int wot = wot_base & TRUST_MASK;
2363   int upper = (tofu_base & ~TRUST_MASK) | (wot_base & ~TRUST_MASK);
2364
2365   log_assert (tofu == TRUST_UNKNOWN
2366               || tofu == TRUST_EXPIRED
2367               || tofu == TRUST_UNDEFINED
2368               || tofu == TRUST_NEVER
2369               || tofu == TRUST_MARGINAL
2370               || tofu == TRUST_FULLY
2371               || tofu == TRUST_ULTIMATE);
2372   log_assert (wot == TRUST_UNKNOWN
2373               || wot == TRUST_EXPIRED
2374               || wot == TRUST_UNDEFINED
2375               || wot == TRUST_NEVER
2376               || wot == TRUST_MARGINAL
2377               || wot == TRUST_FULLY
2378               || wot == TRUST_ULTIMATE);
2379
2380   /* We first consider negative trust policys.  These trump positive
2381      trust policies.  */
2382   if (tofu == TRUST_NEVER || wot == TRUST_NEVER)
2383     /* TRUST_NEVER trumps everything else.  */
2384     return upper | TRUST_NEVER;
2385   if (tofu == TRUST_EXPIRED || wot == TRUST_EXPIRED)
2386     /* TRUST_EXPIRED trumps everything but TRUST_NEVER.  */
2387     return upper | TRUST_EXPIRED;
2388
2389   /* Now we only have positive or neutral trust policies.  We take
2390      the max.  */
2391   if (tofu == TRUST_ULTIMATE)
2392     return upper | TRUST_ULTIMATE | TRUST_FLAG_TOFU_BASED;
2393   if (wot == TRUST_ULTIMATE)
2394     return upper | TRUST_ULTIMATE;
2395
2396   if (tofu == TRUST_FULLY)
2397     return upper | TRUST_FULLY | TRUST_FLAG_TOFU_BASED;
2398   if (wot == TRUST_FULLY)
2399     return upper | TRUST_FULLY;
2400
2401   if (tofu == TRUST_MARGINAL)
2402     return upper | TRUST_MARGINAL | TRUST_FLAG_TOFU_BASED;
2403   if (wot == TRUST_MARGINAL)
2404     return upper | TRUST_MARGINAL;
2405
2406   if (tofu == TRUST_UNDEFINED)
2407     return upper | TRUST_UNDEFINED | TRUST_FLAG_TOFU_BASED;
2408   if (wot == TRUST_UNDEFINED)
2409     return upper | TRUST_UNDEFINED;
2410
2411   return upper | TRUST_UNKNOWN;
2412 }
2413
2414
2415 /* Write a "tfs" record for a --with-colons listing.  */
2416 gpg_error_t
2417 tofu_write_tfs_record (ctrl_t ctrl, estream_t fp,
2418                        PKT_public_key *pk, const char *user_id)
2419 {
2420   gpg_error_t err;
2421   tofu_dbs_t dbs;
2422   char *fingerprint;
2423   char *email;
2424
2425   if (!*user_id)
2426     return 0;  /* No TOFU stats possible for an empty ID.  */
2427
2428   dbs = opendbs (ctrl);
2429   if (!dbs)
2430     {
2431       err = gpg_error (GPG_ERR_GENERAL);
2432       log_error (_("error opening TOFU database: %s\n"), gpg_strerror (err));
2433       return err;
2434     }
2435
2436   fingerprint = hexfingerprint (pk, NULL, 0);
2437   email = email_from_user_id (user_id);
2438
2439   show_statistics (dbs, fingerprint, email, user_id, NULL, fp);
2440
2441   xfree (email);
2442   xfree (fingerprint);
2443   return 0;
2444 }
2445
2446
2447 /* Return the validity (TRUST_NEVER, etc.) of the bindings
2448    <FINGERPRINT, USER_ID>, for each USER_ID in USER_ID_LIST.  If
2449    USER_ID_LIST->FLAG is set, then the id is considered to be expired.
2450
2451    PK is the primary key packet.
2452
2453    If MAY_ASK is 1 and the policy is TOFU_POLICY_ASK, then the user
2454    will be prompted to choose a different policy.  If MAY_ASK is 0 and
2455    the policy is TOFU_POLICY_ASK, then TRUST_UNKNOWN is returned.
2456
2457    Returns TRUST_UNDEFINED if an error occurs.  */
2458 int
2459 tofu_get_validity (ctrl_t ctrl, PKT_public_key *pk, strlist_t user_id_list,
2460                    int may_ask)
2461 {
2462   tofu_dbs_t dbs;
2463   char *fingerprint = NULL;
2464   strlist_t user_id;
2465   int trust_level = TRUST_UNKNOWN;
2466   int bindings = 0;
2467   int bindings_valid = 0;
2468
2469   dbs = opendbs (ctrl);
2470   if (! dbs)
2471     {
2472       log_error (_("error opening TOFU database: %s\n"),
2473                  gpg_strerror (GPG_ERR_GENERAL));
2474       return TRUST_UNDEFINED;
2475     }
2476
2477   fingerprint = hexfingerprint (pk, NULL, 0);
2478
2479   begin_transaction (ctrl);
2480
2481   for (user_id = user_id_list; user_id; user_id = user_id->next, bindings ++)
2482     {
2483       char *email = email_from_user_id (user_id->d);
2484
2485       /* Always call get_trust to make sure the binding is
2486          registered.  */
2487       int tl = get_trust (dbs, pk, fingerprint, email, user_id->d, may_ask);
2488       if (tl == _tofu_GET_TRUST_ERROR)
2489         {
2490           /* An error.  */
2491           trust_level = TRUST_UNDEFINED;
2492           xfree (email);
2493           goto die;
2494         }
2495
2496       if (DBG_TRUST)
2497         log_debug ("TOFU: validity for <key: %s, user id: %s>: %s%s.\n",
2498                    fingerprint, email,
2499                    trust_value_to_string (tl),
2500                    user_id->flags ? " (but expired)" : "");
2501
2502       if (user_id->flags)
2503         tl = TRUST_EXPIRED;
2504
2505       if (tl != TRUST_EXPIRED)
2506         bindings_valid ++;
2507
2508       if (may_ask && tl != TRUST_ULTIMATE && tl != TRUST_EXPIRED)
2509         show_statistics (dbs, fingerprint, email, user_id->d, NULL, NULL);
2510
2511       if (tl == TRUST_NEVER)
2512         trust_level = TRUST_NEVER;
2513       else if (tl == TRUST_EXPIRED)
2514         /* Ignore expired bindings in the trust calculation.  */
2515         ;
2516       else if (tl > trust_level)
2517         {
2518           /* The expected values: */
2519           log_assert (tl == TRUST_UNKNOWN || tl == TRUST_UNDEFINED
2520                       || tl == TRUST_MARGINAL || tl == TRUST_FULLY
2521                       || tl == TRUST_ULTIMATE);
2522
2523           /* We assume the following ordering:  */
2524           log_assert (TRUST_UNKNOWN < TRUST_UNDEFINED);
2525           log_assert (TRUST_UNDEFINED < TRUST_MARGINAL);
2526           log_assert (TRUST_MARGINAL < TRUST_FULLY);
2527           log_assert (TRUST_FULLY < TRUST_ULTIMATE);
2528
2529           trust_level = tl;
2530         }
2531
2532       xfree (email);
2533     }
2534
2535  die:
2536   end_transaction (ctrl, 0);
2537
2538   xfree (fingerprint);
2539
2540   if (bindings_valid == 0)
2541     {
2542       if (DBG_TRUST)
2543         log_debug ("no (of %d) valid bindings."
2544                    "  Can't get TOFU validity for this set of user ids.\n",
2545                    bindings);
2546       return TRUST_NEVER;
2547     }
2548
2549   return trust_level;
2550 }
2551
2552 /* Set the policy for all non-revoked user ids in the keyblock KB to
2553    POLICY.
2554
2555    If no key is available with the specified key id, then this
2556    function returns GPG_ERR_NO_PUBKEY.
2557
2558    Returns 0 on success and an error code otherwise.  */
2559 gpg_error_t
2560 tofu_set_policy (ctrl_t ctrl, kbnode_t kb, enum tofu_policy policy)
2561 {
2562   tofu_dbs_t dbs;
2563   PKT_public_key *pk;
2564   char *fingerprint = NULL;
2565
2566   log_assert (kb->pkt->pkttype == PKT_PUBLIC_KEY);
2567   pk = kb->pkt->pkt.public_key;
2568
2569   dbs = opendbs (ctrl);
2570   if (! dbs)
2571     {
2572       log_error (_("error opening TOFU database: %s\n"),
2573                  gpg_strerror (GPG_ERR_GENERAL));
2574       return gpg_error (GPG_ERR_GENERAL);
2575     }
2576
2577   if (DBG_TRUST)
2578     log_debug ("Setting TOFU policy for %s to %s\n",
2579                keystr (pk->keyid), tofu_policy_str (policy));
2580   if (! (pk->main_keyid[0] == pk->keyid[0]
2581          && pk->main_keyid[1] == pk->keyid[1]))
2582     log_bug ("%s: Passed a subkey, but expecting a primary key.\n", __func__);
2583
2584   fingerprint = hexfingerprint (pk, NULL, 0);
2585
2586   for (; kb; kb = kb->next)
2587     {
2588       PKT_user_id *user_id;
2589       char *email;
2590
2591       if (kb->pkt->pkttype != PKT_USER_ID)
2592         continue;
2593
2594       user_id = kb->pkt->pkt.user_id;
2595       if (user_id->is_revoked)
2596         /* Skip revoked user ids.  (Don't skip expired user ids, the
2597            expiry can be changed.)  */
2598         continue;
2599
2600       email = email_from_user_id (user_id->name);
2601
2602       record_binding (dbs, fingerprint, email, user_id->name, policy, 1);
2603
2604       xfree (email);
2605     }
2606
2607   xfree (fingerprint);
2608   return 0;
2609 }
2610
2611 /* Set the TOFU policy for all non-revoked user ids in the KEY with
2612    the key id KEYID to POLICY.
2613
2614    If no key is available with the specified key id, then this
2615    function returns GPG_ERR_NO_PUBKEY.
2616
2617    Returns 0 on success and an error code otherwise.  */
2618 gpg_error_t
2619 tofu_set_policy_by_keyid (ctrl_t ctrl, u32 *keyid, enum tofu_policy policy)
2620 {
2621   kbnode_t keyblock = get_pubkeyblock (keyid);
2622   if (! keyblock)
2623     return gpg_error (GPG_ERR_NO_PUBKEY);
2624
2625   return tofu_set_policy (ctrl, keyblock, policy);
2626 }
2627
2628 /* Return the TOFU policy for the specified binding in *POLICY.  If no
2629    policy has been set for the binding, sets *POLICY to
2630    TOFU_POLICY_NONE.
2631
2632    PK is a primary public key and USER_ID is a user id.
2633
2634    Returns 0 on success and an error code otherwise.  */
2635 gpg_error_t
2636 tofu_get_policy (ctrl_t ctrl, PKT_public_key *pk, PKT_user_id *user_id,
2637                  enum tofu_policy *policy)
2638 {
2639   tofu_dbs_t dbs;
2640   char *fingerprint;
2641   char *email;
2642
2643   /* Make sure PK is a primary key.  */
2644   log_assert (pk->main_keyid[0] == pk->keyid[0]
2645               && pk->main_keyid[1] == pk->keyid[1]);
2646
2647   dbs = opendbs (ctrl);
2648   if (! dbs)
2649     {
2650       log_error (_("error opening TOFU database: %s\n"),
2651                  gpg_strerror (GPG_ERR_GENERAL));
2652       return gpg_error (GPG_ERR_GENERAL);
2653     }
2654
2655   fingerprint = hexfingerprint (pk, NULL, 0);
2656
2657   email = email_from_user_id (user_id->name);
2658
2659   *policy = get_policy (dbs, fingerprint, email, NULL);
2660
2661   xfree (email);
2662   xfree (fingerprint);
2663   if (*policy == _tofu_GET_POLICY_ERROR)
2664     return gpg_error (GPG_ERR_GENERAL);
2665   return 0;
2666 }