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