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