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