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