* plaintext.c (handle_plaintext): Accept 'u' as a plaintext mode that
[gnupg.git] / g10 / trustdb.c
index 457d83b..5cb69cc 100644 (file)
@@ -1,6 +1,6 @@
 /* trustdb.c
- * Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003
- *                                             Free Software Foundation, Inc.
+ * Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003,
+ *               2004 Free Software Foundation, Inc.
  *
  * This file is part of GnuPG.
  *
@@ -205,23 +205,31 @@ release_key_array ( struct key_array *keys )
  * FIXME: Should be replaced by a function to add those keys to the trustdb.
  */
 void
-register_trusted_key( const char *string )
+register_trusted_keyid(u32 *keyid)
 {
-  KEYDB_SEARCH_DESC desc;
   struct key_item *k;
 
-  if (classify_user_id (string, &desc) != KEYDB_SEARCH_MODE_LONG_KID ) {
-    log_error(_("`%s' is not a valid long keyID\n"), string );
-    return;
-  }
-
   k = new_key_item ();
-  k->kid[0] = desc.u.kid[0];
-  k->kid[1] = desc.u.kid[1];
+  k->kid[0] = keyid[0];
+  k->kid[1] = keyid[1];
   k->next = user_utk_list;
   user_utk_list = k;
 }
 
+void
+register_trusted_key( const char *string )
+{
+  KEYDB_SEARCH_DESC desc;
+
+  if (classify_user_id (string, &desc) != KEYDB_SEARCH_MODE_LONG_KID )
+    {
+      log_error(_("`%s' is not a valid long keyID\n"), string );
+      return;
+    }
+
+  register_trusted_keyid(desc.u.kid);
+}
+
 /*
  * Helper to add a key to the global list of ultimately trusted keys.
  * Retruns: true = inserted, false = already in in list.
@@ -246,7 +254,7 @@ add_utk (u32 *kid)
   k->next = utk_list;
   utk_list = k;
   if( opt.verbose > 1 )
-    log_info(_("key %08lX: accepted as trusted key\n"), (ulong)kid[1]);
+    log_info(_("key %s: accepted as trusted key\n"), keystr(kid));
   return 1;
 }
 
@@ -284,8 +292,8 @@ verify_own_keys(void)
             fprlen = (!fpr[16] && !fpr[17] && !fpr[18] && !fpr[19])? 16:20;
             keyid_from_fingerprint (fpr, fprlen, kid);
             if (!add_utk (kid))
-                log_info(_("key %08lX occurs more than once in the trustdb\n"),
-                            (ulong)kid[1]);
+             log_info(_("key %s occurs more than once in the trustdb\n"),
+                      keystr(kid));
         }
     }
 
@@ -298,22 +306,21 @@ verify_own_keys(void)
 
           memset (&pk, 0, sizeof pk);
           rc = get_pubkey (&pk, k->kid);
-          if (rc) {
-            log_info(_("key %08lX: no public key for trusted key - skipped\n"),
-                     (ulong)k->kid[1] );
-          }
-          else {
-            update_ownertrust (&pk,
-                               ((get_ownertrust (&pk) & ~TRUST_MASK)
-                                | TRUST_ULTIMATE ));
-            release_public_key_parts (&pk);
-          }
-          log_info (_("key %08lX marked as ultimately trusted\n"),
-                    (ulong)k->kid[1]);
+          if (rc)
+           log_info(_("key %s: no public key for trusted key - skipped\n"),
+                    keystr(k->kid));
+          else
+           {
+             update_ownertrust (&pk,
+                                ((get_ownertrust (&pk) & ~TRUST_MASK)
+                                 | TRUST_ULTIMATE ));
+             release_public_key_parts (&pk);
+           }
+
+          log_info (_("key %s marked as ultimately trusted\n"),keystr(k->kid));
         }
     }
 
-
   /* release the helper table table */
   release_key_items (user_utk_list);
   user_utk_list = NULL;
@@ -380,10 +387,11 @@ trust_model_string(void)
 {
   switch(opt.trust_model)
     {
-    case TM_PGP:     return "PGP";
-    case TM_CLASSIC: return "classic";
-    case TM_ALWAYS:  return "always";
-    default:         return "unknown";
+    case TM_CLASSIC:  return "classic";
+    case TM_PGP:      return "PGP";
+    case TM_EXTERNAL: return "external";
+    case TM_ALWAYS:   return "always";
+    default:          return "unknown";
     }
 }
 
@@ -406,7 +414,6 @@ setup_trustdb( int level, const char *dbname )
 void
 init_trustdb()
 {
-  int rc=0;
   int level = trustdb_args.level;
   const char* dbname = trustdb_args.dbname;
 
@@ -415,26 +422,14 @@ init_trustdb()
 
   trustdb_args.init = 1;
 
-  if ( !level || level==1)
+  if(level==0 || level==1)
     {
-      rc = tdbio_set_dbname( dbname, !!level );
-      if( !rc )
-        {
-          if( !level )
-            return;
-          
-          /* verify that our own keys are in the trustDB
-           * or move them to the trustdb. */
-          verify_own_keys();
-          
-          /* should we check whether there is no other ultimately trusted
-           * key in the database? */
-        }
+      int rc = tdbio_set_dbname( dbname, !!level );
+      if( rc )
+       log_fatal("can't init trustdb: %s\n", g10_errstr(rc) );
     }
   else
     BUG();
-  if( rc )
-    log_fatal("can't init trustdb: %s\n", g10_errstr(rc) );
 
   if(opt.trust_model==TM_AUTO)
     {
@@ -443,7 +438,9 @@ init_trustdb()
       opt.trust_model=tdbio_read_model();
 
       /* Sanity check this ;) */
-      if(opt.trust_model!=TM_PGP && opt.trust_model!=TM_CLASSIC)
+      if(opt.trust_model!=TM_CLASSIC
+        && opt.trust_model!=TM_PGP
+        && opt.trust_model!=TM_EXTERNAL)
        {
          log_info(_("unable to use unknown trust model (%d) - "
                     "assuming %s trust model\n"),opt.trust_model,"PGP");
@@ -454,14 +451,19 @@ init_trustdb()
        log_info(_("using %s trust model\n"),trust_model_string());
     }
 
-  if((opt.trust_model==TM_PGP || opt.trust_model==TM_CLASSIC)
-     && !tdbio_db_matches_options())
-    pending_check_trustdb=1;
-}
+  if(opt.trust_model==TM_PGP || opt.trust_model==TM_CLASSIC)
+    {
+      /* Verify the list of ultimately trusted keys and move the
+        --trusted-keys list there as well. */
+      if(level==1)
+       verify_own_keys();
 
+      if(!tdbio_db_matches_options())
+       pending_check_trustdb=1;
+    }
+}
 
 
-\f
 /***********************************************
  ************* Print helpers   ****************
  ***********************************************/
@@ -590,7 +592,30 @@ trustdb_pending_check(void)
   return pending_check_trustdb;
 }
 
-\f
+void
+read_trust_options(byte *trust_model,ulong *created,ulong *nextcheck,
+                  byte *marginals,byte *completes,byte *cert_depth)
+{
+  TRUSTREC opts;
+
+  init_trustdb();
+
+  read_record(0,&opts,RECTYPE_VER);
+
+  if(trust_model)
+    *trust_model=opts.r.ver.trust_model;
+  if(created)
+    *created=opts.r.ver.created;
+  if(nextcheck)
+    *nextcheck=opts.r.ver.nextcheck;
+  if(marginals)
+    *marginals=opts.r.ver.marginals;
+  if(completes)
+    *completes=opts.r.ver.completes;
+  if(cert_depth)
+    *cert_depth=opts.r.ver.cert_depth;
+}
+
 /***********************************************
  ***********  Ownertrust et al. ****************
  ***********************************************/
@@ -764,8 +789,7 @@ update_min_ownertrust (u32 *kid, unsigned int new_trust )
   rc = get_pubkey (pk, kid);
   if (rc)
     {
-      log_error (_("public key %08lX not found: %s\n"),
-                 (ulong)kid[1], g10_errstr(rc) );
+      log_error(_("public key %s not found: %s\n"),keystr(kid),g10_errstr(rc));
       return;
     }
 
@@ -773,8 +797,9 @@ update_min_ownertrust (u32 *kid, unsigned int new_trust )
   if (!rc)
     {
       if (DBG_TRUST)
-        log_debug ("key %08lX: update min_ownertrust from %u to %u\n",
-                   (ulong)kid[1],(unsigned int)rec.r.trust.min_ownertrust,
+        log_debug ("key %08lX%08lX: update min_ownertrust from %u to %u\n",
+                   (ulong)kid[0],(ulong)kid[1],
+                  (unsigned int)rec.r.trust.min_ownertrust,
                   new_trust );
       if (rec.r.trust.min_ownertrust != new_trust)
         {
@@ -901,49 +926,6 @@ update_validity (PKT_public_key *pk, PKT_user_id *uid,
 }
 
 
-/* reset validity for all user IDs.  Caller must sync. */
-static int
-clear_validity (PKT_public_key *pk)
-{
-  TRUSTREC trec, vrec;
-  int rc;
-  ulong recno;
-  int any = 0;
-  
-  rc = read_trust_record (pk, &trec);
-  if (rc && rc != -1)
-    {
-      tdbio_invalid ();
-      return 0;
-    }
-  if (rc == -1) /* no record yet - no need to clear it then ;-) */
-    return 0;
-
-  /* Clear minimum ownertrust, if any */
-  if(trec.r.trust.min_ownertrust)
-    {
-      trec.r.trust.min_ownertrust=0;
-      write_record(&trec);
-    }
-
-  recno = trec.r.trust.validlist;
-  while (recno)
-    {
-      read_record (recno, &vrec, RECTYPE_VALID);
-      if ((vrec.r.valid.validity & TRUST_MASK)
-         || vrec.r.valid.marginal_count || vrec.r.valid.full_count)
-        {
-          vrec.r.valid.validity &= ~TRUST_MASK;
-         vrec.r.valid.marginal_count = vrec.r.valid.full_count = 0;
-          write_record (&vrec);
-          any = 1;
-        }
-      recno = vrec.r.valid.next;
-    }
-
-  return any;
-}
-
 /***********************************************
  *********  Query trustdb values  **************
  ***********************************************/
@@ -984,24 +966,10 @@ cache_disabled_value(PKT_public_key *pk)
    return disabled;
 }
 
-/*
- * Return the validity information for PK.  If the namehash is not
- * NULL, the validity of the corresponsing user ID is returned,
- * otherwise, a reasonable value for the entire key is returned. 
- */
-unsigned int
-get_validity (PKT_public_key *pk, PKT_user_id *uid)
+void
+check_trustdb_stale(void)
 {
-  static int did_nextcheck;
-  TRUSTREC trec, vrec;
-  int rc;
-  ulong recno;
-  unsigned int validity;
-  u32 kid[2];
-  PKT_public_key *main_pk;
-
-  if(uid)
-    namehash_from_uid(uid);
+  static int did_nextcheck=0;
 
   init_trustdb ();
   if (!did_nextcheck
@@ -1025,6 +993,28 @@ get_validity (PKT_public_key *pk, PKT_user_id *uid)
             }
         }
     }
+}
+
+/*
+ * Return the validity information for PK.  If the namehash is not
+ * NULL, the validity of the corresponsing user ID is returned,
+ * otherwise, a reasonable value for the entire key is returned. 
+ */
+unsigned int
+get_validity (PKT_public_key *pk, PKT_user_id *uid)
+{
+  TRUSTREC trec, vrec;
+  int rc;
+  ulong recno;
+  unsigned int validity;
+  u32 kid[2];
+  PKT_public_key *main_pk;
+
+  if(uid)
+    namehash_from_uid(uid);
+
+  init_trustdb ();
+  check_trustdb_stale();
 
   keyid_from_pk (pk, kid);
   if (pk->main_keyid[0] != kid[0] || pk->main_keyid[1] != kid[1])
@@ -1033,8 +1023,10 @@ get_validity (PKT_public_key *pk, PKT_user_id *uid)
       rc = get_pubkey (main_pk, pk->main_keyid);
       if (rc)
         {
-          log_error ("error getting main key %08lX of subkey %08lX: %s\n",
-                     (ulong)pk->main_keyid[1], (ulong)kid[1], g10_errstr(rc));
+         char *tempkeystr=m_strdup(keystr(pk->main_keyid));
+          log_error ("error getting main key %s of subkey %s: %s\n",
+                     tempkeystr, keystr(kid), g10_errstr(rc));
+         m_free(tempkeystr);
           validity = TRUST_UNKNOWN; 
           goto leave;
        }
@@ -1227,16 +1219,15 @@ ask_ownertrust (u32 *kid,int minimum)
   rc = get_pubkey (pk, kid);
   if (rc)
     {
-      log_error (_("public key %08lX not found: %s\n"),
-                 (ulong)kid[1], g10_errstr(rc) );
+      log_error (_("public key %s not found: %s\n"),
+                 keystr(kid), g10_errstr(rc) );
       return TRUST_UNKNOWN;
     }
  
   if(opt.force_ownertrust)
     {
-      log_info("force trust for key %08lX%08lX to %s\n",
-              (ulong)kid[0],(ulong)kid[1],
-              trust_value_to_string(opt.force_ownertrust));
+      log_info("force trust for key %s to %s\n",
+              keystr(kid),trust_value_to_string(opt.force_ownertrust));
       update_ownertrust(pk,opt.force_ownertrust);
       ot=opt.force_ownertrust;
     }
@@ -1390,6 +1381,9 @@ mark_usable_uid_certs (KBNODE keyblock, KBNODE uidnode,
         continue; /* ignore self-signatures */
       if (!IS_UID_SIG(sig) && !IS_UID_REV(sig))
         continue; /* we only look at these signature classes */
+      if(sig->sig_class>=0x11 && sig->sig_class<=0x13 &&
+        sig->sig_class-0x10<opt.min_cert_level)
+       continue;
       if (!is_in_klist (klist, sig))
         continue;  /* no need to check it then */
       if (check_key_signature (keyblock, node, NULL))
@@ -1572,10 +1566,14 @@ validate_one_keyblock (KBNODE kb, struct key_item *klist,
         signed (but not self-signed) uid does carry trust, of a sort,
         even if it is a statement being made by people other than the
         key owner "through" the uids on the key owner's key.  I'm
-        going with the latter. -dshaw */
+        going with the latter.  However, if the user ID was
+        explicitly revoked, or passively allowed to expire, that
+        should stop validity through the user ID until it is
+        resigned.  -dshaw */
 
-      /* && node->pkt->pkt.user_id->created) */
-      if (node->pkt->pkttype == PKT_USER_ID)
+      if (node->pkt->pkttype == PKT_USER_ID
+         && !node->pkt->pkt.user_id->is_revoked
+         && !node->pkt->pkt.user_id->is_expired)
         {
           if (uidnode && issigned)
             {
@@ -1589,12 +1587,11 @@ validate_one_keyblock (KBNODE kb, struct key_item *klist,
             }
           uidnode = node;
          uid=uidnode->pkt->pkt.user_id;
-#if 0
-         /* If the selfsig is going to expire...  This is disabled as
-            we do count un-self-signed uids in the web of trust. */
+
+         /* If the selfsig is going to expire... */
          if(uid->expiredate && uid->expiredate<*next_expire)
            *next_expire = uid->expiredate;
-#endif
+
           issigned = 0;
          get_validity_counts(pk,uid);
           mark_usable_uid_certs (kb, uidnode, main_kid, klist, 
@@ -1688,7 +1685,7 @@ validate_one_keyblock (KBNODE kb, struct key_item *klist,
 
 
 static int
-search_skipfnc (void *opaque, u32 *kid)
+search_skipfnc (void *opaque, u32 *kid, PKT_user_id *dummy)
 {
   return test_key_hash_table ((KeyHashTable)opaque, kid);
 }
@@ -1815,56 +1812,40 @@ validate_key_list (KEYDB_HANDLE hd, KeyHashTable full_trust,
 
 /* Caller must sync */
 static void
-reset_trust_records (KEYDB_HANDLE hd, KeyHashTable exclude)
+reset_trust_records(void)
 {
-  int rc;
-  KBNODE keyblock = NULL;
-  KEYDB_SEARCH_DESC desc;
+  TRUSTREC rec;
+  ulong recnum;
   int count = 0, nreset = 0;
-  
-  rc = keydb_search_reset (hd);
-  if (rc)
-    {
-      log_error ("keydb_search_reset failed: %s\n", g10_errstr(rc));
-      return;
-    }
 
-  memset (&desc, 0, sizeof desc);
-  desc.mode = KEYDB_SEARCH_MODE_FIRST;
-  if(exclude)
-    {
-      desc.skipfnc = search_skipfnc;
-      desc.skipfncvalue = exclude;
-    }
-  rc = keydb_search (hd, &desc, 1);
-  if (rc && rc != -1 )
-    log_error ("keydb_search_first failed: %s\n", g10_errstr(rc));
-  else if (!rc)
+  for (recnum=1; !tdbio_read_record (recnum, &rec, 0); recnum++ ) 
     {
-      desc.mode = KEYDB_SEARCH_MODE_NEXT; /* change mode */
-      do
-        {
-          rc = keydb_get_keyblock (hd, &keyblock);
-          if (rc) 
-            {
-              log_error ("keydb_get_keyblock failed: %s\n", g10_errstr(rc));
-              break;
-            }
-          count++;
+      if(rec.rectype==RECTYPE_TRUST)
+       {
+         count++;
+         if(rec.r.trust.min_ownertrust)
+           {
+             rec.r.trust.min_ownertrust=0;
+             write_record(&rec);
+           }
+
+       }
+      else if(rec.rectype==RECTYPE_VALID
+             && ((rec.r.valid.validity&TRUST_MASK)
+                 || rec.r.valid.marginal_count
+                 || rec.r.valid.full_count))
+       {
+         rec.r.valid.validity &= ~TRUST_MASK;
+         rec.r.valid.marginal_count=rec.r.valid.full_count=0;
+         nreset++;
+         write_record(&rec);
+       }
 
-          if (keyblock->pkt->pkttype == PKT_PUBLIC_KEY) /* paranoid assertion*/
-            {
-              nreset += clear_validity (keyblock->pkt->pkt.public_key);
-              release_kbnode (keyblock);
-            } 
-        }
-      while ( !(rc = keydb_search (hd, &desc, 1)) );
-      if (rc && rc != -1) 
-        log_error ("keydb_search_next failed: %s\n", g10_errstr(rc));
     }
+
   if (opt.verbose)
     log_info (_("%d keys processed (%d validity counts cleared)\n"),
-              count, nreset);
+             count, nreset);
 }
 
 /*
@@ -1903,16 +1884,26 @@ validate_keys (int interactive)
   KEYDB_HANDLE kdb = NULL;
   KBNODE node;
   int depth;
-  int key_count;
   int ot_unknown, ot_undefined, ot_never, ot_marginal, ot_full, ot_ultimate;
   KeyHashTable stored,used,full_trust;
   u32 start_time, next_expire;
 
+  /* Make sure we have all sigs cached.  TODO: This is going to
+     require some architectual re-thinking, as it is agonizingly slow.
+     Perhaps combine this with reset_trust_records(), or only check
+     the caches on keys that are actually involved in the web of
+     trust. */
+  keydb_rebuild_caches(0);
+
   start_time = make_timestamp ();
   next_expire = 0xffffffff; /* set next expire to the year 2106 */
   stored = new_key_hash_table ();
   used = new_key_hash_table ();
   full_trust = new_key_hash_table ();
+
+  kdb = keydb_new (0);
+  reset_trust_records();
+
   /* Fixme: Instead of always building a UTK list, we could just build it
    * here when needed */
   if (!utk_list)
@@ -1921,10 +1912,6 @@ validate_keys (int interactive)
       goto leave;
     }
 
-  kdb = keydb_new (0);
-
-  reset_trust_records (kdb,NULL);
-
   /* mark all UTKs as used and fully_trusted and set validity to
      ultimate */
   for (k=utk_list; k; k = k->next)
@@ -1936,7 +1923,7 @@ validate_keys (int interactive)
       if (!keyblock)
         {
           log_error (_("public key of ultimately"
-                       " trusted key %08lX not found\n"), (ulong)k->kid[1]);
+                       " trusted key %s not found\n"), keystr(k->kid));
           continue;
         }
       mark_keyblock_seen (used, keyblock);
@@ -1963,8 +1950,9 @@ validate_keys (int interactive)
 
   for (depth=0; depth < opt.max_cert_depth; depth++)
     {
+      int valids=0,key_count;
       /* See whether we should assign ownertrust values to the keys in
-         utk_list.  */
+         klist.  */
       ot_unknown = ot_undefined = ot_never = 0;
       ot_marginal = ot_full = ot_ultimate = 0;
       for (k=klist; k; k = k->next)
@@ -1998,9 +1986,9 @@ validate_keys (int interactive)
          if(k->ownertrust<min)
            {
              if(DBG_TRUST)
-               log_debug("key %08lX"
-                         "overriding ownertrust \"%s\" with \"%s\"\n",
-                         (ulong)k->kid[1],
+               log_debug("key %08lX%08lX:"
+                         " overriding ownertrust \"%s\" with \"%s\"\n",
+                         (ulong)k->kid[0],(ulong)k->kid[1],
                          trust_value_to_string(k->ownertrust),
                          trust_value_to_string(min));
 
@@ -2019,6 +2007,8 @@ validate_keys (int interactive)
             ot_full++;
           else if (k->ownertrust == TRUST_ULTIMATE)
             ot_ultimate++;
+
+         valids++;
         }
 
       /* Find all keys which are signed by a key in kdlist */
@@ -2041,9 +2031,9 @@ validate_keys (int interactive)
       for (kar=keys; kar->keyblock; kar++)
           store_validation_status (depth, kar->keyblock, stored);
 
-      log_info (_("checking at depth %d valid=%d"
-                  " ot(-/q/n/m/f/u)=%d/%d/%d/%d/%d/%d\n"), 
-                depth, key_count, ot_unknown, ot_undefined,
+      log_info (_("depth: %d  valid: %3d  signed: %3d"
+                  "  trust: %d-, %dq, %dn, %dm, %df, %du\n"), 
+                depth, valids, key_count, ot_unknown, ot_undefined,
                 ot_never, ot_marginal, ot_full, ot_ultimate ); 
 
       /* Build a new kdlist from all fully valid keys in KEYS */