Change capitalization of TOR to Tor.
[gnupg.git] / g10 / trustdb.c
index f0b5501..32061e4 100644 (file)
@@ -40,6 +40,7 @@
 #include "i18n.h"
 #include "tdbio.h"
 #include "trustdb.h"
+#include "tofu.h"
 
 
 typedef struct key_item **KeyHashTable; /* see new_key_hash_table() */
@@ -99,20 +100,22 @@ release_key_items (struct key_item *k)
     }
 }
 
+#define KEY_HASH_TABLE_SIZE 1024
+
 /*
- * For fast keylook up we need a hash table.  Each byte of a KeyIDs
+ * For fast keylook up we need a hash table.  Each byte of a KeyID
  * should be distributed equally over the 256 possible values (except
  * for v3 keyIDs but we consider them as not important here). So we
- * can just use 10 bits to index a table of 1024 key items.
- * Possible optimization: Don not use key_items but other hash_table when the
- * duplicates lists gets too large.
+ * can just use 10 bits to index a table of KEY_HASH_TABLE_SIZE key items.
+ * Possible optimization: Do not use key_items but other hash_table when the
+ * duplicates lists get too large.
  */
 static KeyHashTable
 new_key_hash_table (void)
 {
   struct key_item **tbl;
 
-  tbl = xmalloc_clear (1024 * sizeof *tbl);
+  tbl = xmalloc_clear (KEY_HASH_TABLE_SIZE * sizeof *tbl);
   return tbl;
 }
 
@@ -123,7 +126,7 @@ release_key_hash_table (KeyHashTable tbl)
 
   if (!tbl)
     return;
-  for (i=0; i < 1024; i++)
+  for (i=0; i < KEY_HASH_TABLE_SIZE; i++)
     release_key_items (tbl[i]);
   xfree (tbl);
 }
@@ -136,7 +139,7 @@ test_key_hash_table (KeyHashTable tbl, u32 *kid)
 {
   struct key_item *k;
 
-  for (k = tbl[(kid[1] & 0x03ff)]; k; k = k->next)
+  for (k = tbl[(kid[1] % KEY_HASH_TABLE_SIZE)]; k; k = k->next)
     if (k->kid[0] == kid[0] && k->kid[1] == kid[1])
       return 1;
   return 0;
@@ -148,17 +151,18 @@ test_key_hash_table (KeyHashTable tbl, u32 *kid)
 static void
 add_key_hash_table (KeyHashTable tbl, u32 *kid)
 {
+  int i = kid[1] % KEY_HASH_TABLE_SIZE;
   struct key_item *k, *kk;
 
-  for (k = tbl[(kid[1] & 0x03ff)]; k; k = k->next)
+  for (k = tbl[i]; k; k = k->next)
     if (k->kid[0] == kid[0] && k->kid[1] == kid[1])
       return; /* already in table */
 
   kk = new_key_item ();
   kk->kid[0] = kid[0];
   kk->kid[1] = kid[1];
-  kk->next = tbl[(kid[1] & 0x03ff)];
-  tbl[(kid[1] & 0x03ff)] = kk;
+  kk->next = tbl[i];
+  tbl[i] = kk;
 }
 
 /*
@@ -225,13 +229,8 @@ add_utk (u32 *kid)
 {
   struct key_item *k;
 
-  for (k = utk_list; k; k = k->next)
-    {
-      if (k->kid[0] == kid[0] && k->kid[1] == kid[1])
-        {
-          return 0;
-        }
-    }
+  if (tdb_keyid_is_utk (kid))
+    return 0;
 
   k = new_key_item ();
   k->kid[0] = kid[0];
@@ -313,6 +312,18 @@ verify_own_keys(void)
   return;
 }
 
+/* Returns whether KID is on the list of ultimately trusted keys.  */
+int
+tdb_keyid_is_utk (u32 *kid)
+{
+  struct key_item *k;
+
+  for (k = utk_list; k; k = k->next)
+    if (k->kid[0] == kid[0] && k->kid[1] == kid[1])
+      return 1;
+
+  return 0;
+}
 \f
 /*********************************************
  *********** TrustDB stuff *******************
@@ -376,6 +387,8 @@ trust_model_string(void)
     case TM_CLASSIC:  return "classic";
     case TM_PGP:      return "PGP";
     case TM_EXTERNAL: return "external";
+    case TM_TOFU:     return "TOFU";
+    case TM_TOFU_PGP: return "TOFU+PGP";
     case TM_ALWAYS:   return "always";
     case TM_DIRECT:   return "direct";
     default:          return "unknown";
@@ -446,20 +459,23 @@ init_trustdb ()
       opt.trust_model=tdbio_read_model();
 
       /* Sanity check this ;) */
-      if(opt.trust_model!=TM_CLASSIC
-        && opt.trust_model!=TM_PGP
-        && opt.trust_model!=TM_EXTERNAL)
+      if(opt.trust_model != TM_CLASSIC
+        && opt.trust_model != TM_PGP
+        && opt.trust_model != TM_TOFU_PGP
+        && opt.trust_model != TM_TOFU
+        && opt.trust_model != TM_EXTERNAL)
        {
          log_info(_("unable to use unknown trust model (%d) - "
-                    "assuming %s trust model\n"),opt.trust_model,"PGP");
-         opt.trust_model=TM_PGP;
+                    "assuming %s trust model\n"),opt.trust_model,"tofu+pgp");
+         opt.trust_model = TM_TOFU_PGP;
        }
 
       if(opt.verbose)
        log_info(_("using %s trust model\n"),trust_model_string());
     }
 
-  if(opt.trust_model==TM_PGP || opt.trust_model==TM_CLASSIC)
+  if (opt.trust_model==TM_PGP || opt.trust_model==TM_CLASSIC
+      || opt.trust_model == TM_TOFU || opt.trust_model == TM_TOFU_PGP)
     {
       /* Verify the list of ultimately trusted keys and move the
         --trusted-keys list there as well. */
@@ -481,7 +497,8 @@ void
 check_trustdb ()
 {
   init_trustdb();
-  if(opt.trust_model==TM_PGP || opt.trust_model==TM_CLASSIC)
+  if (opt.trust_model == TM_PGP || opt.trust_model == TM_CLASSIC
+      || opt.trust_model == TM_TOFU_PGP || opt.trust_model == TM_TOFU)
     {
       if (opt.batch && !opt.answer_yes)
        {
@@ -517,7 +534,8 @@ void
 update_trustdb()
 {
   init_trustdb();
-  if(opt.trust_model==TM_PGP || opt.trust_model==TM_CLASSIC)
+  if (opt.trust_model == TM_PGP || opt.trust_model == TM_CLASSIC
+      || opt.trust_model == TM_TOFU_PGP || opt.trust_model == TM_TOFU)
     validate_keys (1);
   else
     log_info (_("no need for a trustdb update with '%s' trust model\n"),
@@ -598,12 +616,11 @@ read_trust_record (PKT_public_key *pk, TRUSTREC *rec)
 
   init_trustdb();
   rc = tdbio_search_trust_bypk (pk, rec);
-  if (rc == -1)
-    return -1; /* no record yet */
   if (rc)
     {
-      log_error ("trustdb: searching trust record failed: %s\n",
-                 gpg_strerror (rc));
+      if (gpg_err_code (rc) != GPG_ERR_NOT_FOUND)
+        log_error ("trustdb: searching trust record failed: %s\n",
+                   gpg_strerror (rc));
       return rc;
     }
 
@@ -625,18 +642,18 @@ unsigned int
 tdb_get_ownertrust ( PKT_public_key *pk)
 {
   TRUSTREC rec;
-  int rc;
+  gpg_error_t err;
 
   if (trustdb_args.no_trustdb && opt.trust_model == TM_ALWAYS)
     return TRUST_UNKNOWN;
 
-  rc = read_trust_record (pk, &rec);
-  if (rc == -1)
+  err = read_trust_record (pk, &rec);
+  if (gpg_err_code (err) == GPG_ERR_NOT_FOUND)
     return TRUST_UNKNOWN; /* no record yet */
-  if (rc)
+  if (err)
     {
       tdbio_invalid ();
-      return rc; /* actually never reached */
+      return TRUST_UNKNOWN; /* actually never reached */
     }
 
   return rec.r.trust.ownertrust;
@@ -647,18 +664,18 @@ unsigned int
 tdb_get_min_ownertrust (PKT_public_key *pk)
 {
   TRUSTREC rec;
-  int rc;
+  gpg_error_t err;
 
   if (trustdb_args.no_trustdb && opt.trust_model == TM_ALWAYS)
     return TRUST_UNKNOWN;
 
-  rc = read_trust_record (pk, &rec);
-  if (rc == -1)
+  err = read_trust_record (pk, &rec);
+  if (gpg_err_code (err) == GPG_ERR_NOT_FOUND)
     return TRUST_UNKNOWN; /* no record yet */
-  if (rc)
+  if (err)
     {
       tdbio_invalid ();
-      return rc; /* actually never reached */
+      return TRUST_UNKNOWN; /* actually never reached */
     }
 
   return rec.r.trust.min_ownertrust;
@@ -673,13 +690,13 @@ void
 tdb_update_ownertrust (PKT_public_key *pk, unsigned int new_trust )
 {
   TRUSTREC rec;
-  int rc;
+  gpg_error_t err;
 
   if (trustdb_args.no_trustdb && opt.trust_model == TM_ALWAYS)
     return;
 
-  rc = read_trust_record (pk, &rec);
-  if (!rc)
+  err = read_trust_record (pk, &rec);
+  if (!err)
     {
       if (DBG_TRUST)
         log_debug ("update ownertrust from %u to %u\n",
@@ -692,7 +709,7 @@ tdb_update_ownertrust (PKT_public_key *pk, unsigned int new_trust )
           do_sync ();
         }
     }
-  else if (rc == -1)
+  else if (gpg_err_code (err) == GPG_ERR_NOT_FOUND)
     { /* no record yet - create a new one */
       size_t dummy;
 
@@ -707,7 +724,7 @@ tdb_update_ownertrust (PKT_public_key *pk, unsigned int new_trust )
       write_record (&rec);
       tdb_revalidation_mark ();
       do_sync ();
-      rc = 0;
+      err = 0;
     }
   else
     {
@@ -720,21 +737,22 @@ update_min_ownertrust (u32 *kid, unsigned int new_trust )
 {
   PKT_public_key *pk;
   TRUSTREC rec;
-  int rc;
+  gpg_error_t err;
 
   if (trustdb_args.no_trustdb && opt.trust_model == TM_ALWAYS)
     return;
 
   pk = xmalloc_clear (sizeof *pk);
-  rc = get_pubkey (pk, kid);
-  if (rc)
+  err = get_pubkey (pk, kid);
+  if (err)
     {
-      log_error(_("public key %s not found: %s\n"),keystr(kid),gpg_strerror (rc));
+      log_error (_("public key %s not found: %s\n"),
+                 keystr (kid), gpg_strerror (err));
       return;
     }
 
-  rc = read_trust_record (pk, &rec);
-  if (!rc)
+  err = read_trust_record (pk, &rec);
+  if (!err)
     {
       if (DBG_TRUST)
         log_debug ("key %08lX%08lX: update min_ownertrust from %u to %u\n",
@@ -749,7 +767,7 @@ update_min_ownertrust (u32 *kid, unsigned int new_trust )
           do_sync ();
         }
     }
-  else if (rc == -1)
+  else if (gpg_err_code (err) == GPG_ERR_NOT_FOUND)
     { /* no record yet - create a new one */
       size_t dummy;
 
@@ -764,7 +782,7 @@ update_min_ownertrust (u32 *kid, unsigned int new_trust )
       write_record (&rec);
       tdb_revalidation_mark ();
       do_sync ();
-      rc = 0;
+      err = 0;
     }
   else
     {
@@ -773,21 +791,24 @@ update_min_ownertrust (u32 *kid, unsigned int new_trust )
 }
 
 
-/* Clear the ownertrust and min_ownertrust values.  Return true if a
-   change actually happened. */
+/*
+ * Clear the ownertrust and min_ownertrust values.
+ *
+ * Return: True if a change actually happened.
+ */
 int
 tdb_clear_ownertrusts (PKT_public_key *pk)
 {
   TRUSTREC rec;
-  int rc;
+  gpg_error_t err;
 
   init_trustdb ();
 
   if (trustdb_args.no_trustdb && opt.trust_model == TM_ALWAYS)
     return 0;
 
-  rc = read_trust_record (pk, &rec);
-  if (!rc)
+  err = read_trust_record (pk, &rec);
+  if (!err)
     {
       if (DBG_TRUST)
        {
@@ -806,7 +827,7 @@ tdb_clear_ownertrusts (PKT_public_key *pk)
           return 1;
         }
     }
-  else if (rc != -1)
+  else if (gpg_err_code (err) != GPG_ERR_NOT_FOUND)
     {
       tdbio_invalid ();
     }
@@ -821,22 +842,23 @@ update_validity (PKT_public_key *pk, PKT_user_id *uid,
                  int depth, int validity)
 {
   TRUSTREC trec, vrec;
-  int rc;
+  gpg_error_t err;
   ulong recno;
 
   namehash_from_uid(uid);
 
-  rc = read_trust_record (pk, &trec);
-  if (rc && rc != -1)
+  err = read_trust_record (pk, &trec);
+  if (err && gpg_err_code (err) != GPG_ERR_NOT_FOUND)
     {
       tdbio_invalid ();
       return;
     }
-  if (rc == -1) /* no record yet - create a new one */
+  if (gpg_err_code (err) == GPG_ERR_NOT_FOUND)
     {
+      /* No record yet - create a new one. */
       size_t dummy;
 
-      rc = 0;
+      err = 0;
       memset (&trec, 0, sizeof trec);
       trec.recnum = tdbio_new_recnum ();
       trec.rectype = RECTYPE_TRUST;
@@ -881,7 +903,7 @@ update_validity (PKT_public_key *pk, PKT_user_id *uid,
 int
 tdb_cache_disabled_value (PKT_public_key *pk)
 {
-  int rc;
+  gpg_error_t err;
   TRUSTREC trec;
   int disabled = 0;
 
@@ -893,16 +915,19 @@ tdb_cache_disabled_value (PKT_public_key *pk)
   if (trustdb_args.no_trustdb)
     return 0;  /* No trustdb => not disabled.  */
 
-  rc = read_trust_record (pk, &trec);
-  if (rc && rc != -1)
+  err = read_trust_record (pk, &trec);
+  if (err && gpg_err_code (err) != GPG_ERR_NOT_FOUND)
     {
       tdbio_invalid ();
       goto leave;
     }
-  if (rc == -1) /* no record found, so assume not disabled */
-    goto leave;
+  if (gpg_err_code (err) == GPG_ERR_NOT_FOUND)
+    {
+      /* No record found, so assume not disabled.  */
+      goto leave;
+    }
 
-  if (trec.r.trust.ownertrust & TRUST_FLAG_DISABLED)
+  if ((trec.r.trust.ownertrust & TRUST_FLAG_DISABLED))
     disabled = 1;
 
   /* Cache it for later so we don't need to look at the trustdb every
@@ -911,7 +936,7 @@ tdb_cache_disabled_value (PKT_public_key *pk)
   pk->flags.disabled_valid = 1;
 
  leave:
-   return disabled;
+  return disabled;
 }
 
 
@@ -926,7 +951,8 @@ tdb_check_trustdb_stale (void)
     return;  /* No trustdb => can't be stale.  */
 
   if (!did_nextcheck
-      && (opt.trust_model==TM_PGP || opt.trust_model==TM_CLASSIC))
+      && (opt.trust_model == TM_PGP || opt.trust_model == TM_CLASSIC
+          || opt.trust_model == TM_TOFU_PGP || opt.trust_model == TM_TOFU))
     {
       ulong scheduled;
 
@@ -938,11 +964,13 @@ tdb_check_trustdb_stale (void)
           if (opt.no_auto_check_trustdb)
             {
               pending_check_trustdb = 1;
-              log_info (_("please do a --check-trustdb\n"));
+              if (!opt.quiet)
+                log_info (_("please do a --check-trustdb\n"));
             }
           else
             {
-              log_info (_("checking the trustdb\n"));
+              if (!opt.quiet)
+                log_info (_("checking the trustdb\n"));
               validate_keys (0);
             }
         }
@@ -951,16 +979,21 @@ tdb_check_trustdb_stale (void)
 
 /*
  * Return the validity information for PK.  This is the core of
- * get_validity.
+ * get_validity.  If SIG is not NULL, then the trust is being
+ * evaluated in the context of the provided signature.  This is used
+ * by the TOFU code to record statistics.
  */
 unsigned int
 tdb_get_validity_core (PKT_public_key *pk, PKT_user_id *uid,
-                       PKT_public_key *main_pk)
+                       PKT_public_key *main_pk,
+                      PKT_signature *sig,
+                      int may_ask)
 {
   TRUSTREC trec, vrec;
-  int rc;
+  gpg_error_t err;
   ulong recno;
-  unsigned int validity;
+  unsigned int tofu_validity = TRUST_UNKNOWN;
+  unsigned int validity = TRUST_UNKNOWN;
 
   init_trustdb ();
 
@@ -981,59 +1014,159 @@ tdb_get_validity_core (PKT_public_key *pk, PKT_user_id *uid,
       goto leave;
     }
 
-  rc = read_trust_record (main_pk, &trec);
-  if (rc && rc != -1)
+#ifdef USE_TOFU
+  if (opt.trust_model == TM_TOFU || opt.trust_model == TM_TOFU_PGP)
     {
-      tdbio_invalid ();
-      return 0;
-    }
-  if (rc == -1) /* no record found */
-    {
-      validity = TRUST_UNKNOWN;
-      goto leave;
-    }
+      kbnode_t user_id_node = NULL; /* Silence -Wmaybe-uninitialized.  */
+      int user_ids = 0;
+      int user_ids_expired = 0;
 
-  /* loop over all user IDs */
-  recno = trec.r.trust.validlist;
-  validity = 0;
-  while (recno)
-    {
-      read_record (recno, &vrec, RECTYPE_VALID);
+      char fingerprint[MAX_FINGERPRINT_LEN];
+      size_t fingerprint_len = sizeof (fingerprint);
+
+      fingerprint_from_pk (main_pk, fingerprint, &fingerprint_len);
+      assert (fingerprint_len == sizeof (fingerprint));
 
-      if(uid)
+      /* If the caller didn't supply a user id then iterate over all
+        uids.  */
+      if (! uid)
+       user_id_node = get_pubkeyblock (main_pk->keyid);
+
+      while (uid
+            || (user_id_node = find_next_kbnode (user_id_node, PKT_USER_ID)))
        {
-         /* If a user ID is given we return the validity for that
-            user ID ONLY.  If the namehash is not found, then there
-            is no validity at all (i.e. the user ID wasn't
-            signed). */
-         if(memcmp(vrec.r.valid.namehash,uid->namehash,20)==0)
+         unsigned int tl;
+         PKT_user_id *user_id;
+
+         if (uid)
+           user_id = uid;
+         else
+           user_id = user_id_node->pkt->pkt.user_id;
+
+         if (user_id->is_revoked || user_id->is_expired)
+           /* If the user id is revoked or expired, then skip it.  */
            {
-             validity=(vrec.r.valid.validity & TRUST_MASK);
-             break;
+             char *s;
+             if (user_id->is_revoked && user_id->is_expired)
+               s = "revoked and expired";
+             else if (user_id->is_revoked)
+               s = "revoked";
+             else
+               s = "expire";
+
+             log_info ("TOFU: Ignoring %s user id (%s)\n", s, user_id->name);
+
+             continue;
            }
+
+         user_ids ++;
+
+         if (sig)
+           tl = tofu_register (fingerprint, user_id->name,
+                               sig->digest, sig->digest_len,
+                               sig->timestamp, "unknown",
+                               may_ask);
+         else
+           tl = tofu_get_validity (fingerprint, user_id->name, may_ask);
+
+         if (tl == TRUST_EXPIRED)
+           user_ids_expired ++;
+         else if (tl == TRUST_UNDEFINED || tl == TRUST_UNKNOWN)
+           ;
+         else if (tl == TRUST_NEVER)
+           tofu_validity = TRUST_NEVER;
+         else
+           {
+             assert (tl == TRUST_MARGINAL
+                     || tl == TRUST_FULLY
+                     || tl == TRUST_ULTIMATE);
+
+             if (tl > tofu_validity)
+               /* XXX: We we really want the max?  */
+               tofu_validity = tl;
+           }
+
+         if (uid)
+           /* If the caller specified a user id, then we stop
+              now.  */
+           break;
        }
-      else
+    }
+#endif /*USE_TOFU*/
+
+  if (opt.trust_model == TM_TOFU_PGP
+      || opt.trust_model == TM_CLASSIC
+      || opt.trust_model == TM_PGP)
+    {
+      err = read_trust_record (main_pk, &trec);
+      if (err && gpg_err_code (err) != GPG_ERR_NOT_FOUND)
+       {
+         tdbio_invalid ();
+         return 0;
+       }
+      if (gpg_err_code (err) == GPG_ERR_NOT_FOUND)
        {
-         /* If no namehash is given, we take the maximum validity
-            over all user IDs */
-         if ( validity < (vrec.r.valid.validity & TRUST_MASK) )
-           validity = (vrec.r.valid.validity & TRUST_MASK);
+         /* No record found.  */
+         validity = TRUST_UNKNOWN;
+         goto leave;
        }
 
-      recno = vrec.r.valid.next;
-    }
+      /* Loop over all user IDs */
+      recno = trec.r.trust.validlist;
+      validity = 0;
+      while (recno)
+       {
+         read_record (recno, &vrec, RECTYPE_VALID);
 
-  if ( (trec.r.trust.ownertrust & TRUST_FLAG_DISABLED) )
-    {
-      validity |= TRUST_FLAG_DISABLED;
-      pk->flags.disabled = 1;
+         if(uid)
+           {
+             /* If a user ID is given we return the validity for that
+                user ID ONLY.  If the namehash is not found, then
+                there is no validity at all (i.e. the user ID wasn't
+                signed). */
+             if(memcmp(vrec.r.valid.namehash,uid->namehash,20)==0)
+               {
+                 validity=(vrec.r.valid.validity & TRUST_MASK);
+                 break;
+               }
+           }
+         else
+           {
+             /* If no user ID is given, we take the maximum validity
+                over all user IDs */
+             if (validity < (vrec.r.valid.validity & TRUST_MASK))
+               validity = (vrec.r.valid.validity & TRUST_MASK);
+           }
+
+         recno = vrec.r.valid.next;
+       }
+
+      if ((trec.r.trust.ownertrust & TRUST_FLAG_DISABLED))
+       {
+         validity |= TRUST_FLAG_DISABLED;
+         pk->flags.disabled = 1;
+       }
+      else
+       pk->flags.disabled = 0;
+      pk->flags.disabled_valid = 1;
     }
-  else
-    pk->flags.disabled = 0;
-  pk->flags.disabled_valid = 1;
 
  leave:
-  if (pending_check_trustdb)
+#ifdef USE_TOFU
+  validity = tofu_wot_trust_combine (tofu_validity, validity);
+#else /*!USE_TOFU*/
+  validity &= TRUST_MASK;
+
+  if (validity == TRUST_NEVER)
+    /* TRUST_NEVER trumps everything else.  */
+    validity |= TRUST_NEVER;
+  if (validity == TRUST_EXPIRED)
+    /* TRUST_EXPIRED trumps everything but TRUST_NEVER.  */
+    validity |= TRUST_EXPIRED;
+#endif /*!USE_TOFU*/
+
+  if (opt.trust_model != TM_TOFU
+      && pending_check_trustdb)
     validity |= TRUST_FLAG_PENDING_CHECK;
 
   return validity;
@@ -1055,7 +1188,7 @@ get_validity_counts (PKT_public_key *pk, PKT_user_id *uid)
 
   init_trustdb ();
 
-  if(read_trust_record (pk, &trec)!=0)
+  if(read_trust_record (pk, &trec))
     return;
 
   /* loop over all user IDs */
@@ -1446,7 +1579,8 @@ validate_one_keyblock (KBNODE kb, struct key_item *klist,
              since we don't accept a regexp on the sig unless it's a
              trust sig. */
           if (kr && (!kr->trust_regexp
-                     || opt.trust_model != TM_PGP
+                     || !(opt.trust_model == TM_PGP
+                          || opt.trust_model == TM_TOFU_PGP)
                      || (uidnode
                          && check_regexp(kr->trust_regexp,
                                          uidnode->pkt->pkt.user_id->name))))
@@ -1456,7 +1590,8 @@ validate_one_keyblock (KBNODE kb, struct key_item *klist,
                  lesser trust sig or value.  I could make a decent
                  argument for any of these cases, but this seems to be
                  what PGP does, and I'd like to be compatible. -dms */
-              if (opt.trust_model == TM_PGP
+              if ((opt.trust_model == TM_PGP
+                   || opt.trust_model == TM_TOFU_PGP)
                   && sig->trust_depth
                   && pk->trust_timestamp <= sig->timestamp)
                {
@@ -1546,9 +1681,9 @@ validate_one_keyblock (KBNODE kb, struct key_item *klist,
 
 
 static int
-search_skipfnc (void *opaque, u32 *kid, PKT_user_id *dummy)
+search_skipfnc (void *opaque, u32 *kid, int dummy_uid_no)
 {
-  (void)dummy;
+  (void)dummy_uid_no;
   return test_key_hash_table ((KeyHashTable)opaque, kid);
 }
 
@@ -1811,6 +1946,11 @@ validate_keys (int interactive)
       do_sync ();
     }
 
+  if (opt.trust_model == TM_TOFU)
+    /* In the TOFU trust model, we only need to save the ultimately
+       trusted keys.  */
+    goto leave;
+
   klist = utk_list;
 
   log_info(_("%d marginal(s) needed, %d complete(s) needed, %s trust model\n"),
@@ -1893,7 +2033,7 @@ validate_keys (int interactive)
         ;
 
       /* Store the calculated valididation status somewhere */
-      if (opt.verbose > 1)
+      if (opt.verbose > 1 && DBG_TRUST)
         dump_key_array (depth, keys);
 
       for (kar=keys; kar->keyblock; kar++)
@@ -1957,7 +2097,8 @@ validate_keys (int interactive)
  leave:
   keydb_release (kdb);
   release_key_array (keys);
-  release_key_items (klist);
+  if (klist != utk_list)
+    release_key_items (klist);
   release_key_hash_table (full_trust);
   release_key_hash_table (used);
   release_key_hash_table (stored);