g10: Correctly determine whether a binding has a conflict.
[gnupg.git] / g10 / sig-check.c
index fe6aba9..4d39e09 100644 (file)
@@ -1,7 +1,7 @@
 /* sig-check.c -  Check a signature
  * Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003,
  *               2004, 2006 Free Software Foundation, Inc.
- * Copyright (C) 2015 g10 Code GmbH
+ * Copyright (C) 2015, 2016 g10 Code GmbH
  *
  * This file is part of GnuPG.
  *
@@ -23,7 +23,6 @@
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
-#include <assert.h>
 
 #include "gpg.h"
 #include "util.h"
@@ -40,32 +39,74 @@ static int check_signature_end (PKT_public_key *pk, PKT_signature *sig,
                                int *r_expired, int *r_revoked,
                                PKT_public_key *ret_pk);
 
+static int check_signature_end_simple (PKT_public_key *pk, PKT_signature *sig,
+                                       gcry_md_hd_t digest);
 
-/****************
- * Check the signature which is contained in SIG.
- * The MD_HANDLE should be currently open, so that this function
- * is able to append some data, before finalizing the digest.
- */
+/* Check a signature.  This is shorthand for check_signature2 with
+   the unnamed arguments passed as NULL.  */
 int
 check_signature (PKT_signature *sig, gcry_md_hd_t digest)
 {
     return check_signature2 (sig, digest, NULL, NULL, NULL, NULL);
 }
 
-int
+
+/* Check a signature.
+ *
+ * Looks up the public key that created the signature (SIG->KEYID)
+ * from the key db.  Makes sure that the signature is valid (it was
+ * not created prior to the key, the public key was created in the
+ * past, and the signature does not include any unsupported critical
+ * features), finishes computing the hash of the signature data, and
+ * checks that the signature verifies the digest.  If the key that
+ * generated the signature is a subkey, this function also verifies
+ * that there is a valid backsig from the subkey to the primary key.
+ * Finally, if status fd is enabled and the signature class is 0x00 or
+ * 0x01, then a STATUS_SIG_ID is emitted on the status fd.
+ *
+ * SIG is the signature to check.
+ *
+ * DIGEST contains a valid hash context that already includes the
+ * signed data.  This function adds the relevant meta-data from the
+ * signature packet to compute the final hash.  (See Section 5.2 of
+ * RFC 4880: "The concatenation of the data being signed and the
+ * signature data from the version number through the hashed subpacket
+ * data (inclusive) is hashed.")
+ *
+ * If R_EXPIREDATE is not NULL, R_EXPIREDATE is set to the key's
+ * expiry.
+ *
+ * If R_EXPIRED is not NULL, *R_EXPIRED is set to 1 if PK has expired
+ * (0 otherwise).  Note: PK being expired does not cause this function
+ * to fail.
+ *
+ * If R_REVOKED is not NULL, *R_REVOKED is set to 1 if PK has been
+ * revoked (0 otherwise).  Note: PK being revoked does not cause this
+ * function to fail.
+ *
+ * If R_PK is not NULL, the public key is stored at that address if it
+ * was found; other wise NULL is stored.
+ *
+ * Returns 0 on success.  An error code otherwise.  */
+gpg_error_t
 check_signature2 (PKT_signature *sig, gcry_md_hd_t digest, u32 *r_expiredate,
-                 int *r_expired, int *r_revoked, PKT_public_key *pk )
+                 int *r_expired, int *r_revoked, PKT_public_key **r_pk)
 {
     int rc=0;
-    int pk_internal;
+    PKT_public_key *pk;
 
-    if (pk)
-      pk_internal = 0;
-    else
-      {
-       pk_internal = 1;
-       pk = xmalloc_clear( sizeof *pk );
-      }
+    if (r_expiredate)
+      *r_expiredate = 0;
+    if (r_expired)
+      *r_expired = 0;
+    if (r_revoked)
+      *r_revoked = 0;
+    if (r_pk)
+      *r_pk = NULL;
+
+    pk = xtrycalloc (1, sizeof *pk);
+    if (!pk)
+      return gpg_error_from_syserror ();
 
     if ( (rc=openpgp_md_test_algo(sig->digest_algo)) )
       ; /* We don't have this digest. */
@@ -79,14 +120,14 @@ check_signature2 (PKT_signature *sig, gcry_md_hd_t digest, u32 *r_expiredate,
           header is missing or does not match the actual sig. */
 
         log_info(_("WARNING: signature digest conflict in message\n"));
-       rc = GPG_ERR_GENERAL;
+       rc = gpg_error (GPG_ERR_GENERAL);
       }
     else if( get_pubkey( pk, sig->keyid ) )
-       rc = GPG_ERR_NO_PUBKEY;
-    else if(!pk->flags.valid && !pk->flags.primary)
+      rc = gpg_error (GPG_ERR_NO_PUBKEY);
+    else if(!pk->flags.valid)
       {
-        /* You cannot have a good sig from an invalid subkey.  */
-        rc = GPG_ERR_BAD_PUBKEY;
+        /* You cannot have a good sig from an invalid key.  */
+        rc = gpg_error (GPG_ERR_BAD_PUBKEY);
       }
     else
       {
@@ -101,7 +142,7 @@ check_signature2 (PKT_signature *sig, gcry_md_hd_t digest, u32 *r_expiredate,
           them as their own.  The attacker couldn't actually use the
           subkey, but they could try and claim ownership of any
           signatures issued by it. */
-       if(rc==0 && !pk->flags.primary && pk->flags.backsig < 2)
+       if (!rc && !pk->flags.primary && pk->flags.backsig < 2)
          {
            if (!pk->flags.backsig)
              {
@@ -113,27 +154,17 @@ check_signature2 (PKT_signature *sig, gcry_md_hd_t digest, u32 *r_expiredate,
                      error.  TODO: change the default to require this
                      after more keys have backsigs. */
                if(opt.flags.require_cross_cert)
-                 rc = GPG_ERR_GENERAL;
+                 rc = gpg_error (GPG_ERR_GENERAL);
              }
            else if(pk->flags.backsig == 1)
              {
                log_info(_("WARNING: signing subkey %s has an invalid"
                           " cross-certification\n"),keystr_from_pk(pk));
-               rc = GPG_ERR_GENERAL;
+               rc = gpg_error (GPG_ERR_GENERAL);
              }
          }
       }
 
-    if (pk_internal || rc)
-      {
-       release_public_key_parts (pk);
-       if (pk_internal)
-         xfree (pk);
-       else
-         /* Be very sure that the caller doesn't try to use *PK.  */
-         memset (pk, 0, sizeof (*pk));
-      }
-
     if( !rc && sig->sig_class < 2 && is_status_enabled() ) {
        /* This signature id works best with DLP algorithms because
         * they use a random parameter for every signature.  Instead of
@@ -144,7 +175,7 @@ check_signature2 (PKT_signature *sig, gcry_md_hd_t digest, u32 *r_expiredate,
         * like this feature here.
          *
          * Note that before 2.0.10, we used RIPE-MD160 for the hash
-         * and accidently didn't include the timestamp and algorithm
+         * and accidentally didn't include the timestamp and algorithm
          * information in the hash.  Given that this feature is not
          * commonly used and that a replay attacks detection should
          * not solely be based on this feature (because it does not
@@ -200,10 +231,35 @@ check_signature2 (PKT_signature *sig, gcry_md_hd_t digest, u32 *r_expiredate,
        xfree (buffer);
     }
 
+    if (r_pk)
+      *r_pk = pk;
+    else
+      {
+       release_public_key_parts (pk);
+        xfree (pk);
+      }
+
     return rc;
 }
 
 
+/* The signature SIG was generated with the public key PK.  Check
+ * whether the signature is valid in the following sense:
+ *
+ *   - Make sure the public key was created before the signature was
+ *     generated.
+ *
+ *   - Make sure the public key was created in the past
+ *
+ *   - Check whether PK has expired (set *R_EXPIRED to 1 if so and 0
+ *     otherwise)
+ *
+ *   - Check whether PK has been revoked (set *R_REVOKED to 1 if so
+ *     and 0 otherwise).
+ *
+ * If either of the first two tests fail, returns an error code.
+ * Otherwise returns 0.  (Thus, this function doesn't fail if the
+ * public key is expired or revoked.)  */
 static int
 check_signature_metadata_validity (PKT_public_key *pk, PKT_signature *sig,
                                   int *r_expired, int *r_revoked)
@@ -218,11 +274,24 @@ check_signature_metadata_validity (PKT_public_key *pk, PKT_signature *sig,
     if( pk->timestamp > sig->timestamp )
       {
        ulong d = pk->timestamp - sig->timestamp;
-       log_info(d==1
-                ?_("public key %s is %lu second newer than the signature\n")
-                :_("public key %s is %lu seconds newer than the signature\n"),
-                keystr_from_pk(pk),d );
-       if( !opt.ignore_time_conflict )
+        if ( d < 86400 )
+          {
+            log_info
+              (ngettext
+               ("public key %s is %lu second newer than the signature\n",
+                "public key %s is %lu seconds newer than the signature\n",
+                d), keystr_from_pk (pk), d);
+          }
+        else
+          {
+            d /= 86400;
+            log_info
+              (ngettext
+               ("public key %s is %lu day newer than the signature\n",
+                "public key %s is %lu days newer than the signature\n",
+                d), keystr_from_pk (pk), d);
+          }
+       if (!opt.ignore_time_conflict)
          return GPG_ERR_TIME_CONFLICT; /* pubkey newer than signature.  */
       }
 
@@ -230,13 +299,24 @@ check_signature_metadata_validity (PKT_public_key *pk, PKT_signature *sig,
     if( pk->timestamp > cur_time )
       {
        ulong d = pk->timestamp - cur_time;
-       log_info( d==1
-                 ? _("key %s was created %lu second"
-                     " in the future (time warp or clock problem)\n")
-                 : _("key %s was created %lu seconds"
-                     " in the future (time warp or clock problem)\n"),
-                 keystr_from_pk(pk),d );
-       if( !opt.ignore_time_conflict )
+        if (d < 86400)
+          {
+            log_info (ngettext("key %s was created %lu second"
+                               " in the future (time warp or clock problem)\n",
+                               "key %s was created %lu seconds"
+                               " in the future (time warp or clock problem)\n",
+                               d), keystr_from_pk (pk), d);
+          }
+        else
+          {
+            d /= 86400;
+            log_info (ngettext("key %s was created %lu day"
+                               " in the future (time warp or clock problem)\n",
+                               "key %s was created %lu days"
+                               " in the future (time warp or clock problem)\n",
+                               d), keystr_from_pk (pk), d);
+          }
+       if (!opt.ignore_time_conflict)
          return GPG_ERR_TIME_CONFLICT;
       }
 
@@ -268,33 +348,73 @@ check_signature_metadata_validity (PKT_public_key *pk, PKT_signature *sig,
 }
 
 
+/* Finish generating a signature and check it.  Concretely: make sure
+ * that the signature is valid (it was not created prior to the key,
+ * the public key was created in the past, and the signature does not
+ * include any unsupported critical features), finish computing the
+ * digest by adding the relevant data from the signature packet, and
+ * check that the signature verifies the digest.
+ *
+ * DIGEST contains a hash context, which has already hashed the signed
+ * data.  This function adds the relevant meta-data from the signature
+ * packet to compute the final hash.  (See Section 5.2 of RFC 4880:
+ * "The concatenation of the data being signed and the signature data
+ * from the version number through the hashed subpacket data
+ * (inclusive) is hashed.")
+ *
+ * SIG is the signature to check.
+ *
+ * PK is the public key used to generate the signature.
+ *
+ * If R_EXPIRED is not NULL, *R_EXPIRED is set to 1 if PK has expired
+ * (0 otherwise).  Note: PK being expired does not cause this function
+ * to fail.
+ *
+ * If R_REVOKED is not NULL, *R_REVOKED is set to 1 if PK has been
+ * revoked (0 otherwise).  Note: PK being revoked does not cause this
+ * function to fail.
+ *
+ * If RET_PK is not NULL, PK is copied into RET_PK on success.
+ *
+ * Returns 0 on success.  An error code other.  */
 static int
 check_signature_end (PKT_public_key *pk, PKT_signature *sig,
                     gcry_md_hd_t digest,
                     int *r_expired, int *r_revoked, PKT_public_key *ret_pk)
 {
-    gcry_mpi_t result = NULL;
     int rc = 0;
-    const struct weakhash *weak;
 
     if ((rc = check_signature_metadata_validity (pk, sig,
                                                 r_expired, r_revoked)))
         return rc;
 
+    if ((rc = check_signature_end_simple (pk, sig, digest)))
+      return rc;
+
+    if(!rc && ret_pk)
+      copy_public_key(ret_pk,pk);
+
+    return rc;
+}
+
+/* This function is similar to check_signature_end, but it only checks
+   whether the signature was generated by PK.  It does not check
+   expiration, revocation, etc.  */
+static int
+check_signature_end_simple (PKT_public_key *pk, PKT_signature *sig,
+                            gcry_md_hd_t digest)
+{
+    gcry_mpi_t result = NULL;
+    int rc = 0;
+    const struct weakhash *weak;
+
     if (!opt.flags.allow_weak_digest_algos)
-      {
-        if (sig->digest_algo == GCRY_MD_MD5)
+      for (weak = opt.weak_digests; weak; weak = weak->next)
+        if (sig->digest_algo == weak->algo)
           {
             print_digest_rejected_note(sig->digest_algo);
             return GPG_ERR_DIGEST_ALGO;
           }
-        for (weak = opt.additional_weak_digests; weak; weak = weak->next)
-          if (sig->digest_algo == weak->algo)
-            {
-              print_digest_rejected_note(sig->digest_algo);
-              return GPG_ERR_DIGEST_ALGO;
-            }
-      }
 
     /* Make sure the digest algo is enabled (in case of a detached
        signature).  */
@@ -330,7 +450,7 @@ check_signature_end (PKT_public_key *pk, PKT_signature *sig,
          gcry_md_putc (digest, 0);
          n = 6;
        }
-       /* add some magic */
+       /* add some magic per Section 5.2.4 of RFC 4880.  */
        buf[0] = sig->version;
        buf[1] = 0xff;
        buf[2] = n >> 24;
@@ -341,9 +461,12 @@ check_signature_end (PKT_public_key *pk, PKT_signature *sig,
     }
     gcry_md_final( digest );
 
+    /* Convert the digest to an MPI.  */
     result = encode_md_value (pk, digest, sig->digest_algo );
     if (!result)
         return GPG_ERR_GENERAL;
+
+    /* Verify the signature.  */
     rc = pk_verify( pk->pubkey_algo, result, sig->data, pk->pkey );
     gcry_mpi_release (result);
 
@@ -354,20 +477,15 @@ check_signature_end (PKT_public_key *pk, PKT_signature *sig,
        rc = GPG_ERR_BAD_SIGNATURE;
       }
 
-    if(!rc && ret_pk)
-      copy_public_key(ret_pk,pk);
-
     return rc;
 }
 
 
-
+/* Add a uid node to a hash context.  See section 5.2.4, paragraph 4
+   of RFC 4880.  */
 static void
-hash_uid_node( KBNODE unode, gcry_md_hd_t md, PKT_signature *sig )
+hash_uid_packet (PKT_user_id *uid, gcry_md_hd_t md, PKT_signature *sig )
 {
-    PKT_user_id *uid = unode->pkt->pkt.user_id;
-
-    assert( unode->pkt->pkttype == PKT_USER_ID );
     if( uid->attrib_data ) {
        if( sig->version >=4 ) {
            byte buf[5];
@@ -411,32 +529,70 @@ cache_sig_result ( PKT_signature *sig, int result )
     }
 }
 
-/* Check the revocation keys to see if any of them have revoked our
-   pk.  sig is the revocation sig.  pk is the key it is on.  This code
-   will need to be modified if gpg ever becomes multi-threaded.  Note
-   that this guarantees that a designated revocation sig will never be
-   considered valid unless it is actually valid, as well as being
-   issued by a revocation key in a valid direct signature.  Note also
-   that this is written so that a revoked revoker can still issue
-   revocations: i.e. If A revokes B, but A is revoked, B is still
-   revoked.  I'm not completely convinced this is the proper behavior,
-   but it matches how PGP does it. -dms */
-
-/* Returns 0 if sig is valid (i.e. pk is revoked), non-0 if not
-   revoked.  It is important that GPG_ERR_NO_PUBKEY is only returned
-   when a revocation signature is from a valid revocation key
-   designated in a revkey subpacket, but the revocation key itself
-   isn't present. */
+
+/* SIG is a key revocation signature.  Check if this signature was
+ * generated by any of the public key PK's designated revokers.
+ *
+ *   PK is the public key that SIG allegedly revokes.
+ *
+ *   SIG is the revocation signature to check.
+ *
+ * This function avoids infinite recursion, which can happen if two
+ * keys are designed revokers for each other and they revoke each
+ * other.  This is done by observing that if a key A is revoked by key
+ * B we still consider the revocation to be valid even if B is
+ * revoked.  Thus, we don't need to determine whether B is revoked to
+ * determine whether A has been revoked by B, we just need to check
+ * the signature.
+ *
+ * Returns 0 if sig is valid (i.e. pk is revoked), non-0 if not
+ * revoked.  We are careful to make sure that GPG_ERR_NO_PUBKEY is
+ * only returned when a revocation signature is from a valid
+ * revocation key designated in a revkey subpacket, but the revocation
+ * key itself isn't present.
+ *
+ * XXX: This code will need to be modified if gpg ever becomes
+ * multi-threaded.  Note that this guarantees that a designated
+ * revocation sig will never be considered valid unless it is actually
+ * valid, as well as being issued by a revocation key in a valid
+ * direct signature.  Note also that this is written so that a revoked
+ * revoker can still issue revocations: i.e. If A revokes B, but A is
+ * revoked, B is still revoked.  I'm not completely convinced this is
+ * the proper behavior, but it matches how PGP does it. -dms */
 int
-check_revocation_keys(PKT_public_key *pk,PKT_signature *sig)
+check_revocation_keys (PKT_public_key *pk, PKT_signature *sig)
 {
   static int busy=0;
   int i;
   int rc = GPG_ERR_GENERAL;
 
-  assert(IS_KEY_REV(sig));
-  assert((sig->keyid[0]!=pk->keyid[0]) || (sig->keyid[0]!=pk->keyid[1]));
-
+  log_assert (IS_KEY_REV(sig));
+  log_assert ((sig->keyid[0]!=pk->keyid[0]) || (sig->keyid[0]!=pk->keyid[1]));
+
+  /* Avoid infinite recursion.  Consider the following:
+   *
+   *   - We want to check if A is revoked.
+   *
+   *   - C is a designated revoker for B and has revoked B.
+   *
+   *   - B is a designated revoker for A and has revoked A.
+   *
+   * When checking if A is revoked (in merge_selfsigs_main), we
+   * observe that A has a designed revoker.  As such, we call this
+   * function.  This function sees that there is a valid revocation
+   * signature, which is signed by B.  It then calls check_signature()
+   * to verify that the signature is good.  To check the sig, we need
+   * to lookup B.  Looking up B means calling merge_selfsigs_main,
+   * which checks whether B is revoked, which calls this function to
+   * see if B was revoked by some key.
+   *
+   * In this case, the added level of indirection doesn't hurt.  It
+   * just means a bit more work.  However, if C == A, then we'd end up
+   * in a loop.  But, it doesn't make sense to look up C anyways: even
+   * if B is revoked, we conservatively consider a valid revocation
+   * signed by B to revoke A.  Since this is the only place where this
+   * type of recursion can occur, we simply cause this function to
+   * fail if it is entered recursively.  */
   if (busy)
     {
       /* Return an error (i.e. not revoked), but mark the pk as
@@ -457,17 +613,22 @@ check_revocation_keys(PKT_public_key *pk,PKT_signature *sig)
   else
       for(i=0;i<pk->numrevkeys;i++)
        {
+         /* The revoker's keyid.  */
           u32 keyid[2];
 
           keyid_from_fingerprint(pk->revkey[i].fpr,MAX_FINGERPRINT_LEN,keyid);
 
           if(keyid[0]==sig->keyid[0] && keyid[1]==sig->keyid[1])
+           /* The signature was generated by a designated revoker.
+              Verify the signature.  */
            {
               gcry_md_hd_t md;
 
               if (gcry_md_open (&md, sig->digest_algo, 0))
                 BUG ();
               hash_public_key(md,pk);
+             /* Note: check_signature only checks that the signature
+                is good.  It does not fail if the key is revoked.  */
               rc=check_signature(sig,md);
              cache_sig_result(sig,rc);
               gcry_md_close (md);
@@ -480,21 +641,24 @@ check_revocation_keys(PKT_public_key *pk,PKT_signature *sig)
   return rc;
 }
 
-/* Backsigs (0x19) have the same format as binding sigs (0x18), but
+/* Check that the backsig BACKSIG from the subkey SUB_PK to its
+   primary key MAIN_PK is valid.
+
+   Backsigs (0x19) have the same format as binding sigs (0x18), but
    this function is simpler than check_key_signature in a few ways.
    For example, there is no support for expiring backsigs since it is
    questionable what such a thing actually means.  Note also that the
    sig cache check here, unlike other sig caches in GnuPG, is not
    persistent. */
 int
-check_backsig(PKT_public_key *main_pk,PKT_public_key *sub_pk,
-             PKT_signature *backsig)
+check_backsig (PKT_public_key *main_pk,PKT_public_key *sub_pk,
+              PKT_signature *backsig)
 {
   gcry_md_hd_t md;
   int rc;
 
   /* Always check whether the algorithm is available.  Although
-     gcry_md_open woyuld throw an error, some libgcrypt versions will
+     gcry_md_open would throw an error, some libgcrypt versions will
      print a debug message in that case too. */
   if ((rc=openpgp_md_test_algo (backsig->digest_algo)))
     return rc;
@@ -516,176 +680,411 @@ check_backsig(PKT_public_key *main_pk,PKT_public_key *sub_pk,
 }
 
 
-/****************
- * check the signature pointed to by NODE. This is a key signature.
- * If the function detects a self-signature, it uses the PK from
- * ROOT and does not read any public key.
- */
+/* Check that a signature over a key is valid.  This is a
+ * specialization of check_key_signature2 with the unnamed parameters
+ * passed as NULL.  See the documentation for that function for more
+ * details.  */
 int
-check_key_signature( KBNODE root, KBNODE node, int *is_selfsig )
+check_key_signature (KBNODE root, KBNODE node, int *is_selfsig)
 {
-  return check_key_signature2(root, node, NULL, NULL, is_selfsig, NULL, NULL );
+  return check_key_signature2 (root, node, NULL, NULL, is_selfsig, NULL, NULL);
 }
 
-/* If check_pk is set, then use it to check the signature in node
-   rather than getting it from root or the keydb.  If ret_pk is set,
-   fill in the public key that was used to verify the signature.
-   ret_pk is only meaningful when the verification was successful. */
-/* TODO: add r_revoked here as well.  It has the same problems as
-   r_expiredate and r_expired and the cache. */
-int
-check_key_signature2( KBNODE root, KBNODE node, PKT_public_key *check_pk,
-                     PKT_public_key *ret_pk, int *is_selfsig,
-                     u32 *r_expiredate, int *r_expired )
+
+/* Returns whether SIGNER generated the signature SIG over the packet
+   PACKET, which is a key, subkey or uid, and comes from the key block
+   KB.  (KB is PACKET's corresponding keyblock; we don't assume that
+   SIG has been added to the keyblock.)
+
+   If SIGNER is set, then checks whether SIGNER generated the
+   signature.  Otherwise, uses SIG->KEYID to find the alleged signer.
+   This parameter can be used to effectively override the alleged
+   signer that is stored in SIG.
+
+   KB may be NULL if SIGNER is set.
+
+   Unlike check_key_signature, this function ignores any cached
+   results!  That is, it does not consider SIG->FLAGS.CHECKED and
+   SIG->FLAGS.VALID nor does it set them.
+
+   This doesn't check the signature's semantic mean.  Concretely, it
+   doesn't check whether a non-self signed revocation signature was
+   created by a designated revoker.  In fact, it doesn't return an
+   error for a binding generated by a completely different key!
+
+   Returns 0 if the signature is valid.  Returns GPG_ERR_SIG_CLASS if
+   this signature can't be over PACKET.  Returns GPG_ERR_NOT_FOUND if
+   the key that generated the signature (according to SIG) could not
+   be found.  Returns GPG_ERR_BAD_SIGNATURE if the signature is bad.
+   Other errors codes may be returned if something else goes wrong.
+
+   IF IS_SELFSIG is not NULL, sets *IS_SELFSIG to 1 if this is a
+   self-signature (by the key's primary key) or 0 if not.
+
+   If RET_PK is not NULL, returns a copy of the public key that
+   generated the signature (i.e., the signer) on success.  This must
+   be released by the caller using release_public_key_parts ().  */
+gpg_error_t
+check_signature_over_key_or_uid (PKT_public_key *signer,
+                                 PKT_signature *sig, KBNODE kb, PACKET *packet,
+                                 int *is_selfsig, PKT_public_key *ret_pk)
 {
-    gcry_md_hd_t md;
-    PKT_public_key *pk;
-    PKT_signature *sig;
-    int algo;
-    int rc;
-
-    if( is_selfsig )
-       *is_selfsig = 0;
-    if( r_expiredate )
-        *r_expiredate = 0;
-    if( r_expired )
-        *r_expired = 0;
-    assert( node->pkt->pkttype == PKT_SIGNATURE );
-    assert( root->pkt->pkttype == PKT_PUBLIC_KEY );
-
-    pk = root->pkt->pkt.public_key;
-    sig = node->pkt->pkt.signature;
-    algo = sig->digest_algo;
-
-    /* Check whether we have cached the result of a previous signature
-       check.  Note that we may no longer have the pubkey or hash
-       needed to verify a sig, but can still use the cached value.  A
-       cache refresh detects and clears these cases. */
-    if ( !opt.no_sig_cache ) {
-        if (sig->flags.checked) { /*cached status available*/
-           if( is_selfsig ) {
-               u32 keyid[2];
-
-               keyid_from_pk( pk, keyid );
-               if( keyid[0] == sig->keyid[0] && keyid[1] == sig->keyid[1] )
-                   *is_selfsig = 1;
-           }
-           /* BUG: This is wrong for non-self-sigs.. needs to be the
-              actual pk */
-           if((rc = check_signature_metadata_validity (pk, sig,
-                                                       r_expired, NULL)))
-             return rc;
-            return sig->flags.valid? 0 : gpg_error (GPG_ERR_BAD_SIGNATURE);
+  int rc;
+  PKT_public_key *pripk = kb->pkt->pkt.public_key;
+  gcry_md_hd_t md;
+  int signer_alloced = 0;
+
+  rc = openpgp_pk_test_algo (sig->pubkey_algo);
+  if (rc)
+    return rc;
+  rc = openpgp_md_test_algo (sig->digest_algo);
+  if (rc)
+    return rc;
+
+  /* A signature's class indicates the type of packet that it
+     signs.  */
+  if (/* Primary key binding (made by a subkey).  */
+      sig->sig_class == 0x19
+      /* Direct key signature.  */
+      || sig->sig_class == 0x1f
+      /* Primary key revocation.  */
+      || sig->sig_class == 0x20)
+    {
+      if (packet->pkttype != PKT_PUBLIC_KEY)
+        /* Key revocations can only be over primary keys.  */
+        return gpg_error (GPG_ERR_SIG_CLASS);
+    }
+  else if (/* Subkey binding.  */
+           sig->sig_class == 0x18
+           /* Subkey revocation.  */
+           || sig->sig_class == 0x28)
+    {
+      if (packet->pkttype != PKT_PUBLIC_SUBKEY)
+        return gpg_error (GPG_ERR_SIG_CLASS);
+    }
+  else if (/* Certification.  */
+           sig->sig_class == 0x10
+           || sig->sig_class == 0x11
+           || sig->sig_class == 0x12
+           || sig->sig_class == 0x13
+           /* Certification revocation.  */
+           || sig->sig_class == 0x30)
+    {
+      if (packet->pkttype != PKT_USER_ID)
+        return gpg_error (GPG_ERR_SIG_CLASS);
+    }
+  else
+    return gpg_error (GPG_ERR_SIG_CLASS);
+
+  /* PACKET is the right type for SIG.  */
+
+  if (signer)
+    {
+      if (is_selfsig)
+        {
+          if (signer->keyid[0] == pripk->keyid[0]
+              && signer->keyid[1] == pripk->keyid[1])
+            *is_selfsig = 1;
+          else
+            *is_selfsig = 0;
         }
     }
+  else
+    {
+      /* Get the signer.  If possible, avoid a look up.  */
+      if (sig->keyid[0] == pripk->keyid[0]
+          && sig->keyid[1] == pripk->keyid[1])
+        /* Issued by the primary key.  */
+        {
+          signer = pripk;
+          if (is_selfsig)
+            *is_selfsig = 1;
+        }
+      else
+        {
+          kbnode_t ctx = NULL;
+          kbnode_t n;
+
+          /* See if one of the subkeys was the signer (although this
+             is extremely unlikely).  */
+          while ((n = walk_kbnode (kb, &ctx, 0)))
+            {
+              PKT_public_key *subk;
+
+              if (n->pkt->pkttype != PKT_PUBLIC_SUBKEY)
+                continue;
+
+              subk = n->pkt->pkt.public_key;
+              if (sig->keyid[0] == subk->keyid[0]
+                  && sig->keyid[1] == subk->keyid[1])
+                /* Issued by a subkey.  */
+                {
+                  signer = subk;
+                  break;
+                }
+            }
 
-    if( (rc=openpgp_pk_test_algo(sig->pubkey_algo)) )
-       return rc;
-    if( (rc=openpgp_md_test_algo(algo)) )
-       return rc;
+          if (! signer)
+            /* Signer by some other key.  */
+            {
+              if (is_selfsig)
+                *is_selfsig = 0;
+              if (ret_pk)
+                {
+                  signer = ret_pk;
+                  memset (signer, 0, sizeof (*signer));
+                  signer_alloced = 1;
+                }
+              else
+                {
+                  signer = xmalloc_clear (sizeof (*signer));
+                  signer_alloced = 2;
+                }
+
+              rc = get_pubkey (signer, sig->keyid);
+              if (rc)
+                {
+                  xfree (signer);
+                  signer = NULL;
+                  signer_alloced = 0;
+                  goto out;
+                }
+            }
+        }
+    }
 
-    if( sig->sig_class == 0x20 ) { /* key revocation */
-        u32 keyid[2];
-       keyid_from_pk( pk, keyid );
+  /* We checked above that we supported this algo, so an error here is
+     a bug.  */
+  if (gcry_md_open (&md, sig->digest_algo, 0))
+    BUG ();
 
-       /* is it a designated revoker? */
-        if(keyid[0]!=sig->keyid[0] || keyid[1]!=sig->keyid[1])
-         rc=check_revocation_keys(pk,sig);
-       else
-         {
-           if (gcry_md_open (&md, algo, 0 ))
-              BUG ();
-           hash_public_key( md, pk );
-           rc = check_signature_end (pk, sig, md, r_expired, NULL, ret_pk);
-           cache_sig_result ( sig, rc );
-           gcry_md_close(md);
-         }
+  /* Hash the relevant data.  */
+
+  if (/* Direct key signature.  */
+      sig->sig_class == 0x1f
+      /* Primary key revocation.  */
+      || sig->sig_class == 0x20)
+    {
+      log_assert (packet->pkttype == PKT_PUBLIC_KEY);
+      hash_public_key (md, packet->pkt.public_key);
+      rc = check_signature_end_simple (signer, sig, md);
     }
-    else if( sig->sig_class == 0x28 ) { /* subkey revocation */
-       KBNODE snode = find_prev_kbnode( root, node, PKT_PUBLIC_SUBKEY );
-
-       if( snode ) {
-            if (gcry_md_open (&md, algo, 0))
-              BUG ();
-           hash_public_key( md, pk );
-           hash_public_key( md, snode->pkt->pkt.public_key );
-           rc = check_signature_end (pk, sig, md, r_expired, NULL, ret_pk);
-            cache_sig_result ( sig, rc );
-           gcry_md_close(md);
-       }
-       else
-         {
-            if (opt.verbose)
-             log_info (_("key %s: no subkey for subkey"
-                         " revocation signature\n"),keystr_from_pk(pk));
-           rc = GPG_ERR_SIG_CLASS;
-         }
+  else if (/* Primary key binding (made by a subkey).  */
+      sig->sig_class == 0x19)
+    {
+      log_assert (packet->pkttype == PKT_PUBLIC_KEY);
+      hash_public_key (md, packet->pkt.public_key);
+      hash_public_key (md, signer);
+      rc = check_signature_end_simple (signer, sig, md);
     }
-    else if( sig->sig_class == 0x18 ) { /* key binding */
-       KBNODE snode = find_prev_kbnode( root, node, PKT_PUBLIC_SUBKEY );
+  else if (/* Subkey binding.  */
+           sig->sig_class == 0x18
+           /* Subkey revocation.  */
+           || sig->sig_class == 0x28)
+    {
+      log_assert (packet->pkttype == PKT_PUBLIC_SUBKEY);
+      hash_public_key (md, pripk);
+      hash_public_key (md, packet->pkt.public_key);
+      rc = check_signature_end_simple (signer, sig, md);
+    }
+  else if (/* Certification.  */
+           sig->sig_class == 0x10
+           || sig->sig_class == 0x11
+           || sig->sig_class == 0x12
+           || sig->sig_class == 0x13
+           /* Certification revocation.  */
+           || sig->sig_class == 0x30)
+    {
+      log_assert (packet->pkttype == PKT_USER_ID);
+      hash_public_key (md, pripk);
+      hash_uid_packet (packet->pkt.user_id, md, sig);
+      rc = check_signature_end_simple (signer, sig, md);
+    }
+  else
+    /* We should never get here.  (The first if above should have
+       already caught this error.)  */
+    BUG ();
+
+  gcry_md_close (md);
+
+ out:
+  if (! rc && ret_pk && (signer_alloced == -1 || ret_pk != signer))
+    copy_public_key (ret_pk, signer);
+  if (signer_alloced == 1)
+    /* We looked up SIGNER; it is not a pointer into KB.  */
+    {
+      release_public_key_parts (signer);
+      if (signer_alloced == 2)
+        /* We also allocated the memory.  */
+        xfree (signer);
+    }
+
+  return rc;
+}
 
-       if( snode ) {
-           if( is_selfsig ) {  /* does this make sense????? */
-               u32 keyid[2];   /* it should always be a selfsig */
+/* Check that a signature over a key (e.g., a key revocation, key
+ * binding, user id certification, etc.) is valid.  If the function
+ * detects a self-signature, it uses the public key from the specified
+ * key block and does not bother looking up the key specified in the
+ * signature packet.
+ *
+ * ROOT is a keyblock.
+ *
+ * NODE references a signature packet that appears in the keyblock
+ * that should be verified.
+ *
+ * If CHECK_PK is set, the specified key is sometimes preferred for
+ * verifying signatures.  See the implementation for details.
+ *
+ * If RET_PK is not NULL, the public key that successfully verified
+ * the signature is copied into *RET_PK.
+ *
+ * If IS_SELFSIG is not NULL, *IS_SELFSIG is set to 1 if NODE is a
+ * self-signature.
+ *
+ * If R_EXPIREDATE is not NULL, *R_EXPIREDATE is set to the expiry
+ * date.
+ *
+ * If R_EXPIRED is not NULL, *R_EXPIRED is set to 1 if PK has been
+ * expired (0 otherwise).  Note: PK being revoked does not cause this
+ * function to fail.
+ *
+ *
+ * If OPT.NO_SIG_CACHE is not set, this function will first check if
+ * the result of a previous verification is already cached in the
+ * signature packet's data structure.
+ *
+ * TODO: add r_revoked here as well.  It has the same problems as
+ * r_expiredate and r_expired and the cache.  */
+int
+check_key_signature2 (kbnode_t root, kbnode_t node, PKT_public_key *check_pk,
+                      PKT_public_key *ret_pk, int *is_selfsig,
+                      u32 *r_expiredate, int *r_expired )
+{
+  PKT_public_key *pk;
+  PKT_signature *sig;
+  int algo;
+  int rc;
+
+  if (is_selfsig)
+    *is_selfsig = 0;
+  if (r_expiredate)
+    *r_expiredate = 0;
+  if (r_expired)
+    *r_expired = 0;
+  log_assert (node->pkt->pkttype == PKT_SIGNATURE);
+  log_assert (root->pkt->pkttype == PKT_PUBLIC_KEY);
+
+  pk = root->pkt->pkt.public_key;
+  sig = node->pkt->pkt.signature;
+  algo = sig->digest_algo;
+
+  /* Check whether we have cached the result of a previous signature
+     check.  Note that we may no longer have the pubkey or hash
+     needed to verify a sig, but can still use the cached value.  A
+     cache refresh detects and clears these cases. */
+  if ( !opt.no_sig_cache )
+    {
+      if (sig->flags.checked) /* Cached status available.  */
+        {
+          if (is_selfsig)
+            {
+              u32 keyid[2];
 
-               keyid_from_pk( pk, keyid );
-               if( keyid[0] == sig->keyid[0] && keyid[1] == sig->keyid[1] )
-                   *is_selfsig = 1;
+              keyid_from_pk (pk, keyid);
+              if (keyid[0] == sig->keyid[0] && keyid[1] == sig->keyid[1])
+                *is_selfsig = 1;
            }
-           if (gcry_md_open (&md, algo, 0))
-              BUG ();
-           hash_public_key( md, pk );
-           hash_public_key( md, snode->pkt->pkt.public_key );
-           rc = check_signature_end (pk, sig, md, r_expired, NULL, ret_pk);
-            cache_sig_result ( sig, rc );
-           gcry_md_close(md);
-       }
-       else
-         {
-            if (opt.verbose)
-             log_info(_("key %s: no subkey for subkey"
-                        " binding signature\n"),keystr_from_pk(pk));
-           rc = GPG_ERR_SIG_CLASS;
-         }
+          /* BUG: This is wrong for non-self-sigs... needs to be the
+             actual pk.  */
+          rc = check_signature_metadata_validity (pk, sig, r_expired, NULL);
+          if (rc)
+            return rc;
+          return sig->flags.valid? 0 : gpg_error (GPG_ERR_BAD_SIGNATURE);
+        }
     }
-    else if( sig->sig_class == 0x1f ) { /* direct key signature */
-        if (gcry_md_open (&md, algo, 0 ))
-          BUG ();
-       hash_public_key( md, pk );
-       rc = check_signature_end (pk, sig, md, r_expired, NULL, ret_pk);
-        cache_sig_result ( sig, rc );
-       gcry_md_close(md);
+
+  rc = openpgp_pk_test_algo(sig->pubkey_algo);
+  if (rc)
+    return rc;
+  rc = openpgp_md_test_algo(algo);
+  if (rc)
+    return rc;
+
+  if (sig->sig_class == 0x20) /* key revocation */
+    {
+      u32 keyid[2];
+      keyid_from_pk( pk, keyid );
+
+      /* Is it a designated revoker? */
+      if (keyid[0] != sig->keyid[0] || keyid[1] != sig->keyid[1])
+        rc = check_revocation_keys (pk, sig);
+      else
+        {
+          rc = check_signature_metadata_validity (pk, sig,
+                                                  r_expired, NULL);
+          if (! rc)
+            rc = check_signature_over_key_or_uid (pk, sig, root, root->pkt,
+                                                  is_selfsig, ret_pk);
+        }
     }
-    else { /* all other classes */
-       KBNODE unode = find_prev_kbnode( root, node, PKT_USER_ID );
-
-       if( unode ) {
-           u32 keyid[2];
-
-           keyid_from_pk( pk, keyid );
-           if (gcry_md_open (&md, algo, 0 ))
-              BUG ();
-           hash_public_key( md, pk );
-           hash_uid_node( unode, md, sig );
-           if( keyid[0] == sig->keyid[0] && keyid[1] == sig->keyid[1] )
-             {
-               if( is_selfsig )
-                 *is_selfsig = 1;
-               rc = check_signature_end (pk, sig, md, r_expired, NULL, ret_pk);
-             }
-           else if (check_pk)
-             /* The caller specified a key.  Try that.  */
-             rc = check_signature_end (check_pk, sig, md,
-                                       r_expired, NULL, ret_pk);
-           else
-             /* Look up the key.  XXX: Could it be that the key is
-                not is not in this keyblock?  */
-             rc = check_signature2 (sig, md, r_expiredate, r_expired,
-                                    NULL, ret_pk);
-
-            cache_sig_result ( sig, rc );
-           gcry_md_close(md);
+  else if (sig->sig_class == 0x28  /* subkey revocation */
+           || sig->sig_class == 0x18) /* key binding */
+    {
+      kbnode_t snode = find_prev_kbnode (root, node, PKT_PUBLIC_SUBKEY);
+
+      if (snode)
+        {
+          rc = check_signature_metadata_validity (pk, sig,
+                                                  r_expired, NULL);
+          if (! rc)
+            /* 0x28 must be a self-sig, but 0x18 needn't be.  */
+            rc = check_signature_over_key_or_uid (sig->sig_class == 0x18
+                                                  ? NULL : pk,
+                                                  sig, root, snode->pkt,
+                                                  is_selfsig, ret_pk);
        }
+      else
+        {
+          if (opt.verbose)
+            {
+              if (sig->sig_class == 0x28)
+                log_info (_("key %s: no subkey for subkey"
+                            " revocation signature\n"), keystr_from_pk(pk));
+              else if (sig->sig_class == 0x18)
+                log_info(_("key %s: no subkey for subkey"
+                           " binding signature\n"), keystr_from_pk(pk));
+            }
+          rc = GPG_ERR_SIG_CLASS;
+        }
+    }
+    else if (sig->sig_class == 0x1f) /* direct key signature */
+      {
+        rc = check_signature_metadata_validity (pk, sig,
+                                                r_expired, NULL);
+        if (! rc)
+          rc = check_signature_over_key_or_uid (pk, sig, root, root->pkt,
+                                                is_selfsig, ret_pk);
+      }
+    else if (/* Certification.  */
+             sig->sig_class == 0x10
+             || sig->sig_class == 0x11
+             || sig->sig_class == 0x12
+             || sig->sig_class == 0x13
+             /* Certification revocation.  */
+             || sig->sig_class == 0x30)
+      {
+       kbnode_t unode = find_prev_kbnode (root, node, PKT_USER_ID);
+
+       if (unode)
+          {
+            rc = check_signature_metadata_validity (pk, sig, r_expired, NULL);
+            if (! rc)
+              /* If this is a self-sig, ignore check_pk.  */
+              rc = check_signature_over_key_or_uid
+                (keyid_cmp (pk_keyid (pk), sig->keyid) == 0 ? pk : check_pk,
+                 sig, root, unode->pkt, NULL, ret_pk);
+          }
        else
          {
             if (!opt.quiet)
@@ -693,7 +1092,17 @@ check_key_signature2( KBNODE root, KBNODE node, PKT_public_key *check_pk,
                        " of class %02x\n",keystr_from_pk(pk),sig->sig_class);
            rc = GPG_ERR_SIG_CLASS;
          }
+      }
+  else
+    {
+      log_info ("sig issued by %s with class %d (digest: %02x %02x)"
+                " is not valid over a user id or a key id, ignoring.\n",
+                keystr (sig->keyid), sig->sig_class,
+                sig->digest_start[0], sig->digest_start[1]);
+      rc = gpg_error (GPG_ERR_BAD_SIGNATURE);
     }
 
-    return rc;
+  cache_sig_result  (sig, rc);
+
+  return rc;
 }