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