Keyserver search and get basically works again.
[gnupg.git] / g10 / sig-check.c
index eb36641..9dee55d 100644 (file)
@@ -1,12 +1,12 @@
 /* sig-check.c -  Check a signature
- * Copyright (C) 1998, 1999, 2000, 2001, 2002,
- *               2003 Free Software Foundation, Inc.
+ * Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003,
+ *               2004, 2006 Free Software Foundation, Inc.
  *
  * This file is part of GnuPG.
  *
  * GnuPG is free software; you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation; either version 2 of the License, or
+ * the Free Software Foundation; either version 3 of the License, or
  * (at your option) any later version.
  *
  * GnuPG is distributed in the hope that it will be useful,
@@ -15,8 +15,7 @@
  * GNU General Public License for more details.
  *
  * You should have received a copy of the GNU General Public License
- * along with this program; if not, write to the Free Software
- * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
+ * along with this program; if not, see <http://www.gnu.org/licenses/>.
  */
 
 #include <config.h>
 #include <stdlib.h>
 #include <string.h>
 #include <assert.h>
+
+#include "gpg.h"
 #include "util.h"
 #include "packet.h"
-#include "memory.h"
-#include "mpi.h"
 #include "keydb.h"
 #include "cipher.h"
 #include "main.h"
 #include "status.h"
 #include "i18n.h"
 #include "options.h"
+#include "pkglue.h"
 
-struct cmp_help_context_s {
-    PKT_signature *sig;
-    MD_HANDLE md;
+/* Context used by the compare function. */
+struct cmp_help_context_s
+{
+  PKT_signature *sig;
+  gcry_md_hd_t md;
 };
 
-static int do_check( PKT_public_key *pk, PKT_signature *sig, MD_HANDLE digest,
+
+
+static int do_check( PKT_public_key *pk, PKT_signature *sig,
+                     gcry_md_hd_t digest,
                     int *r_expired, int *r_revoked, PKT_public_key *ret_pk);
 
 /****************
@@ -49,23 +54,23 @@ static int do_check( PKT_public_key *pk, PKT_signature *sig, MD_HANDLE digest,
  * is able to append some data, before finalizing the digest.
  */
 int
-signature_check( PKT_signature *sig, MD_HANDLE digest )
+signature_check (PKT_signature *sig, gcry_md_hd_t digest)
 {
     return signature_check2( sig, digest, NULL, NULL, NULL, NULL );
 }
 
 int
-signature_check2( PKT_signature *sig, MD_HANDLE digest, u32 *r_expiredate, 
+signature_check2 (PKT_signature *sig, gcry_md_hd_t digest, u32 *r_expiredate, 
                  int *r_expired, int *r_revoked, PKT_public_key *ret_pk )
 {
-    PKT_public_key *pk = m_alloc_clear( sizeof *pk );
+    PKT_public_key *pk = xmalloc_clear( sizeof *pk );
     int rc=0;
 
-    if( (rc=check_digest_algo(sig->digest_algo)) )
-      ; /* we don't have this digest */
-    else if((rc=check_pubkey_algo(sig->pubkey_algo)))
-      ; /* we don't have this pubkey algo */
-    else if(!md_algo_present(digest,sig->digest_algo))
+    if ( (rc=openpgp_md_test_algo(sig->digest_algo)) )
+      ; /* We don't have this digest. */
+    else if ((rc=openpgp_pk_test_algo(sig->pubkey_algo)))
+      ; /* We don't have this pubkey algo. */
+    else if (!gcry_md_is_enabled (digest,sig->digest_algo))
       {
        /* Sanity check that the md has a context for the hash that the
           sig is expecting.  This can happen if a onepass sig header does
@@ -77,14 +82,44 @@ signature_check2( PKT_signature *sig, MD_HANDLE digest, u32 *r_expiredate,
       }
     else if( get_pubkey( pk, sig->keyid ) )
        rc = G10ERR_NO_PUBKEY;
-    else if(!pk->is_valid && !pk->is_primary)
+    else if(!pk->flags.valid && !pk->flags.primary)
         rc=G10ERR_BAD_PUBKEY; /* you cannot have a good sig from an
                                 invalid subkey */
-    else {
+    else
+      {
         if(r_expiredate)
          *r_expiredate = pk->expiredate;
+
        rc = do_check( pk, sig, digest, r_expired, r_revoked, ret_pk );
-    }
+
+       /* Check the backsig.  This is a 0x19 signature from the
+          subkey on the primary key.  The idea here is that it should
+          not be possible for someone to "steal" subkeys and claim
+          them as their own.  The attacker couldn't actually use the
+          subkey, but they could try and claim ownership of any
+          signaures issued by it. */
+       if(rc==0 && !pk->flags.primary && pk->flags.backsig < 2)
+         {
+           if (!pk->flags.backsig)
+             {
+               log_info(_("WARNING: signing subkey %s is not"
+                          " cross-certified\n"),keystr_from_pk(pk));
+               log_info(_("please see %s for more information\n"),
+                        "http://www.gnupg.org/faq/subkey-cross-certify.html");
+               /* --require-cross-certification makes this warning an
+                     error.  TODO: change the default to require this
+                     after more keys have backsigs. */
+               if(opt.flags.require_cross_cert)
+                 rc=G10ERR_GENERAL;
+             }
+           else if(pk->flags.backsig == 1)
+             {
+               log_info(_("WARNING: signing subkey %s has an invalid"
+                          " cross-certification\n"),keystr_from_pk(pk));
+               rc=G10ERR_GENERAL;
+             }
+         }
+      }
 
     free_public_key( pk );
 
@@ -95,37 +130,63 @@ signature_check2( PKT_signature *sig, MD_HANDLE digest, u32 *r_expiredate,
         * and the timestamp, but the drawback of this is, that it is
         * not possible to sign more than one identical document within
         * one second.  Some remote batch processing applications might
-        * like this feature here */
-       MD_HANDLE md;
+        * 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
+         * 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
+         * work with RSA), we take the freedom and switch to SHA-1
+         * with 2.0.10 to take advantage of hardware supported SHA-1
+         * implementations.  We also include the missing information
+         * in the hash.  Note also the SIG_ID as computed by gpg 1.x
+         * and gpg 2.x didn't matched either because 2.x used to print
+         * MPIs not in PGP format.  */
        u32 a = sig->timestamp;
-       int i, nsig = pubkey_get_nsig( sig->pubkey_algo );
-       byte *p, *buffer;
-
-       md = md_open( DIGEST_ALGO_RMD160, 0);
-       md_putc( digest, sig->pubkey_algo );
-       md_putc( digest, sig->digest_algo );
-       md_putc( digest, (a >> 24) & 0xff );
-       md_putc( digest, (a >> 16) & 0xff );
-       md_putc( digest, (a >>  8) & 0xff );
-       md_putc( digest,  a        & 0xff );
-       for(i=0; i < nsig; i++ ) {
-           unsigned n = mpi_get_nbits( sig->data[i]);
-
-           md_putc( md, n>>8);
-           md_putc( md, n );
-           p = mpi_get_buffer( sig->data[i], &n, NULL );
-           md_write( md, p, n );
-           m_free(p);
-       }
-       md_final( md );
-       p = make_radix64_string( md_read( md, 0 ), 20 );
-       buffer = m_alloc( strlen(p) + 60 );
-       sprintf( buffer, "%s %s %lu",
-                p, strtimestamp( sig->timestamp ), (ulong)sig->timestamp );
-       write_status_text( STATUS_SIG_ID, buffer );
-       m_free(buffer);
-       m_free(p);
-       md_close(md);
+       int nsig = pubkey_get_nsig( sig->pubkey_algo );
+       unsigned char *p, *buffer;
+        size_t n, nbytes;
+        int i;
+        char hashbuf[20];
+
+        nbytes = 6;
+       for (i=0; i < nsig; i++ )
+          {
+           if (gcry_mpi_print (GCRYMPI_FMT_USG, NULL, 0, &n, sig->data[i]))
+              BUG();
+            nbytes += n;
+          }
+
+        /* Make buffer large enough to be later used as output buffer.  */
+        if (nbytes < 100)
+          nbytes = 100;
+        nbytes += 10;  /* Safety margin.  */
+
+        /* Fill and hash buffer.  */
+        buffer = p = xmalloc (nbytes);
+       *p++ = sig->pubkey_algo;
+       *p++ = sig->digest_algo;
+       *p++ = (a >> 24) & 0xff;
+       *p++ = (a >> 16) & 0xff;
+       *p++ = (a >>  8) & 0xff;
+       *p++ =  a & 0xff;
+        nbytes -= 6;
+       for (i=0; i < nsig; i++ )
+          {
+           if (gcry_mpi_print (GCRYMPI_FMT_PGP, p, nbytes, &n, sig->data[i]))
+              BUG();
+            p += n;
+            nbytes -= n;
+          }
+        gcry_md_hash_buffer (GCRY_MD_SHA1, hashbuf, buffer, p-buffer);
+
+       p = make_radix64_string (hashbuf, 20);
+       sprintf (buffer, "%s %s %lu",
+                p, strtimestamp (sig->timestamp), (ulong)sig->timestamp);
+       xfree (p);
+       write_status_text (STATUS_SIG_ID, buffer);
+       xfree (buffer);
     }
 
     return rc;
@@ -142,44 +203,41 @@ do_check_messages( PKT_public_key *pk, PKT_signature *sig,
       *r_expired = 0;
     if(r_revoked)
       *r_revoked = 0;
-    if( pk->version == 4 && pk->pubkey_algo == PUBKEY_ALGO_ELGAMAL_E ) {
-       log_info(_("key %08lX: this is a PGP generated "
-                  "Elgamal key which is NOT secure for signatures!\n"),
-                 (ulong)keyid_from_pk(pk,NULL));
-       return G10ERR_PUBKEY_ALGO;
-    }
 
-    if( pk->timestamp > sig->timestamp ) {
+    if( pk->timestamp > sig->timestamp )
+      {
        ulong d = pk->timestamp - sig->timestamp;
-       log_info( d==1
-            ? _("public key %08lX is %lu second newer than the signature\n")
-            : _("public key %08lX is %lu seconds newer than the signature\n"),
-               (ulong)keyid_from_pk(pk,NULL),d );
+       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 )
-           return G10ERR_TIME_CONFLICT; /* pubkey newer than signature */
-    }
+         return G10ERR_TIME_CONFLICT; /* pubkey newer than signature */
+      }
 
     cur_time = make_timestamp();
-    if( pk->timestamp > cur_time ) {
+    if( pk->timestamp > cur_time )
+      {
        ulong d = pk->timestamp - cur_time;
-       log_info( d==1 ? _("key %08lX has been created %lu second "
-                          "in future (time warp or clock problem)\n")
-                      : _("key %08lX has been created %lu seconds "
-                          "in future (time warp or clock problem)\n"),
-                      (ulong)keyid_from_pk(pk,NULL),d );
+       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 )
-           return G10ERR_TIME_CONFLICT;
-    }
+         return G10ERR_TIME_CONFLICT;
+      }
 
-    if( pk->expiredate && pk->expiredate < cur_time ) {
+    /* Check whether the key has expired.  We check the has_expired
+       flag which is set after a full evaluation of the key (getkey.c)
+       as well as a simple compare to the current time in case the
+       merge has for whatever reasons not been done.  */
+    if( pk->has_expired || (pk->expiredate && pk->expiredate < cur_time)) {
         char buf[11];
-        if (opt.verbose) {
-           u32 tmp_kid[2];
-
-           keyid_from_pk( pk, tmp_kid );
-            log_info(_("NOTE: signature key %08lX expired %s\n"),
-                     (ulong)tmp_kid[1], asctimestamp( pk->expiredate ) );
-        }
+        if (opt.verbose)
+         log_info(_("NOTE: signature key %s expired %s\n"),
+                  keystr_from_pk(pk), asctimestamp( pk->expiredate ) );
        /* SIGEXPIRED is deprecated.  Use KEYEXPIRED. */
        sprintf(buf,"%lu",(ulong)pk->expiredate);
        write_status_text(STATUS_KEYEXPIRED,buf);
@@ -188,55 +246,62 @@ do_check_messages( PKT_public_key *pk, PKT_signature *sig,
          *r_expired = 1;
     }
 
-    if(pk->is_revoked && r_revoked)
-      *r_revoked=1;
+    if (pk->flags.revoked)
+      {
+        if (opt.verbose)
+         log_info (_("NOTE: signature key %s has been revoked\n"),
+                    keystr_from_pk(pk));
+        if (r_revoked)
+          *r_revoked=1;
+      }
 
     return 0;
 }
 
 
 static int
-do_check( PKT_public_key *pk, PKT_signature *sig, MD_HANDLE digest,
+do_check( PKT_public_key *pk, PKT_signature *sig, gcry_md_hd_t digest,
          int *r_expired, int *r_revoked, PKT_public_key *ret_pk )
 {
-    MPI result = NULL;
-    int rc=0;
+    gcry_mpi_t result = NULL;
+    int rc = 0;
     struct cmp_help_context_s ctx;
 
     if( (rc=do_check_messages(pk,sig,r_expired,r_revoked)) )
         return rc;
 
-    /* make sure the digest algo is enabled (in case of a detached signature)*/
-    md_enable( digest, sig->digest_algo );
+    /* Make sure the digest algo is enabled (in case of a detached
+       signature).  */
+    gcry_md_enable (digest, sig->digest_algo);
 
-    /* complete the digest */
+    /* Complete the digest. */
     if( sig->version >= 4 )
-       md_putc( digest, sig->version );
-    md_putc( digest, sig->sig_class );
+       gcry_md_putc( digest, sig->version );
+    gcry_md_putc( digest, sig->sig_class );
     if( sig->version < 4 ) {
        u32 a = sig->timestamp;
-       md_putc( digest, (a >> 24) & 0xff );
-       md_putc( digest, (a >> 16) & 0xff );
-       md_putc( digest, (a >>  8) & 0xff );
-       md_putc( digest,  a        & 0xff );
+       gcry_md_putc( digest, (a >> 24) & 0xff );
+       gcry_md_putc( digest, (a >> 16) & 0xff );
+       gcry_md_putc( digest, (a >>     8) & 0xff );
+       gcry_md_putc( digest,  a           & 0xff );
     }
     else {
        byte buf[6];
        size_t n;
-       md_putc( digest, sig->pubkey_algo );
-       md_putc( digest, sig->digest_algo );
+       gcry_md_putc( digest, sig->pubkey_algo );
+       gcry_md_putc( digest, sig->digest_algo );
        if( sig->hashed ) {
            n = sig->hashed->len;
-            md_putc (digest, (n >> 8) );
-            md_putc (digest,  n       );
-           md_write (digest, sig->hashed->data, n);
+            gcry_md_putc (digest, (n >> 8) );
+            gcry_md_putc (digest,  n       );
+           gcry_md_write (digest, sig->hashed->data, n);
            n += 6;
        }
        else {
          /* Two octets for the (empty) length of the hashed
              section. */
-          md_putc (digest, 0);
-         md_putc (digest, 0);
+          gcry_md_putc (digest, 0);
+         gcry_md_putc (digest, 0);
          n = 6;
        }
        /* add some magic */
@@ -246,23 +311,24 @@ do_check( PKT_public_key *pk, PKT_signature *sig, MD_HANDLE digest,
        buf[3] = n >> 16;
        buf[4] = n >>  8;
        buf[5] = n;
-       md_write( digest, buf, 6 );
+       gcry_md_write( digest, buf, 6 );
     }
-    md_final( digest );
+    gcry_md_final( digest );
 
-    result = encode_md_value( pk->pubkey_algo, digest, sig->digest_algo,
-                             mpi_get_nbits(pk->pkey[0]) );
+    result = encode_md_value (pk, digest, sig->digest_algo );
     if (!result)
         return G10ERR_GENERAL;
     ctx.sig = sig;
     ctx.md = digest;
-    rc = pubkey_verify( pk->pubkey_algo, result, sig->data, pk->pkey );
-    mpi_free( result );
+    rc = pk_verify( pk->pubkey_algo, result, sig->data, pk->pkey );
+    gcry_mpi_release (result);
 
-    if( !rc && sig->flags.unknown_critical ) {
-      log_info(_("assuming bad signature from key %08lX due to an unknown critical bit\n"),(ulong)keyid_from_pk(pk,NULL));
+    if( !rc && sig->flags.unknown_critical )
+      {
+       log_info(_("assuming bad signature from key %s"
+                  " due to an unknown critical bit\n"),keystr_from_pk(pk));
        rc = G10ERR_BAD_SIGN;
-    }
+      }
 
     if(!rc && ret_pk)
       copy_public_key(ret_pk,pk);
@@ -271,8 +337,9 @@ do_check( PKT_public_key *pk, PKT_signature *sig, MD_HANDLE digest,
 }
 
 
+
 static void
-hash_uid_node( KBNODE unode, MD_HANDLE md, PKT_signature *sig )
+hash_uid_node( KBNODE unode, gcry_md_hd_t md, PKT_signature *sig )
 {
     PKT_user_id *uid = unode->pkt->pkt.user_id;
 
@@ -285,9 +352,9 @@ hash_uid_node( KBNODE unode, MD_HANDLE md, PKT_signature *sig )
            buf[2] = uid->attrib_len >> 16;
            buf[3] = uid->attrib_len >>  8;
            buf[4] = uid->attrib_len;
-           md_write( md, buf, 5 );
+           gcry_md_write( md, buf, 5 );
        }
-       md_write( md, uid->attrib_data, uid->attrib_len );
+       gcry_md_write( md, uid->attrib_data, uid->attrib_len );
     }
     else {
        if( sig->version >=4 ) {
@@ -297,9 +364,9 @@ hash_uid_node( KBNODE unode, MD_HANDLE md, PKT_signature *sig )
            buf[2] = uid->len >> 16;
            buf[3] = uid->len >>  8;
            buf[4] = uid->len;
-           md_write( md, buf, 5 );
+           gcry_md_write( md, buf, 5 );
        }
-       md_write( md, uid->name, uid->len );
+       gcry_md_write( md, uid->name, uid->len );
     }
 }
 
@@ -310,7 +377,7 @@ cache_sig_result ( PKT_signature *sig, int result )
         sig->flags.checked = 1;
         sig->flags.valid = 1;
     }
-    else if ( result == G10ERR_BAD_SIGN ) {
+    else if ( gpg_err_code (result) == GPG_ERR_BAD_SIGNATURE ) {
         sig->flags.checked = 1;
         sig->flags.valid = 0;
     }
@@ -345,13 +412,12 @@ check_revocation_keys(PKT_public_key *pk,PKT_signature *sig)
   assert(IS_KEY_REV(sig));
   assert((sig->keyid[0]!=pk->keyid[0]) || (sig->keyid[0]!=pk->keyid[1]));
 
-  if(busy)
+  if (busy)
     {
-      /* return an error (i.e. not revoked), but mark the pk as
+      /* Return an error (i.e. not revoked), but mark the pk as
          uncacheable as we don't really know its revocation status
-         until it is checked directly. */
-
-      pk->dont_cache=1;
+         until it is checked directly.  */
+      pk->flags.dont_cache = 1;
       return rc;
     }
 
@@ -372,12 +438,14 @@ check_revocation_keys(PKT_public_key *pk,PKT_signature *sig)
     
           if(keyid[0]==sig->keyid[0] && keyid[1]==sig->keyid[1])
            {
-              MD_HANDLE md;
+              gcry_md_hd_t md;
     
-              md=md_open(sig->digest_algo,0);
+              if (gcry_md_open (&md, sig->digest_algo, 0))
+                BUG ();
               hash_public_key(md,pk);
               rc=signature_check(sig,md);
              cache_sig_result(sig,rc);
+              gcry_md_close (md);
              break;
            }
        }
@@ -387,6 +455,42 @@ check_revocation_keys(PKT_public_key *pk,PKT_signature *sig)
   return rc;
 } 
 
+/* 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)
+{
+  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
+     print a debug message in that case too. */
+  if ((rc=openpgp_md_test_algo (backsig->digest_algo)))
+    return rc;
+
+  if(!opt.no_sig_cache && backsig->flags.checked)
+    return backsig->flags.valid? 0 : gpg_error (GPG_ERR_BAD_SIGNATURE);
+
+  rc = gcry_md_open (&md, backsig->digest_algo,0);
+  if (!rc)
+    {
+      hash_public_key(md,main_pk);
+      hash_public_key(md,sub_pk);
+      rc=do_check(sub_pk,backsig,md,NULL,NULL,NULL);
+      cache_sig_result(backsig,rc);
+      gcry_md_close(md);
+    }
+
+  return rc;
+}
+
+
 /****************
  * check the signature pointed to by NODE. This is a key signature.
  * If the function detects a self-signature, it uses the PK from
@@ -409,7 +513,7 @@ 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 )
 {
-    MD_HANDLE md;
+    gcry_md_hd_t md;
     PKT_public_key *pk;
     PKT_signature *sig;
     int algo;
@@ -445,13 +549,13 @@ check_key_signature2( KBNODE root, KBNODE node, PKT_public_key *check_pk,
               actual pk */
            if((rc=do_check_messages(pk,sig,r_expired,NULL)))
              return rc;
-            return sig->flags.valid? 0 : G10ERR_BAD_SIGN;
+            return sig->flags.valid? 0 : gpg_error (GPG_ERR_BAD_SIGNATURE);
         }
     }
 
-    if( (rc=check_pubkey_algo(sig->pubkey_algo)) )
+    if( (rc=openpgp_pk_test_algo(sig->pubkey_algo)) )
        return rc;
-    if( (rc=check_digest_algo(algo)) )
+    if( (rc=openpgp_md_test_algo(algo)) )
        return rc;
 
     if( sig->sig_class == 0x20 ) { /* key revocation */
@@ -463,31 +567,33 @@ check_key_signature2( KBNODE root, KBNODE node, PKT_public_key *check_pk,
          rc=check_revocation_keys(pk,sig);
        else
          {
-           md = md_open( algo, 0 );
+           if (gcry_md_open (&md, algo, 0 ))
+              BUG ();
            hash_public_key( md, pk );
            rc = do_check( pk, sig, md, r_expired, NULL, ret_pk );
            cache_sig_result ( sig, rc );
-           md_close(md);
+           gcry_md_close(md);
          }
     }
     else if( sig->sig_class == 0x28 ) { /* subkey revocation */
        KBNODE snode = find_prev_kbnode( root, node, PKT_PUBLIC_SUBKEY );
 
        if( snode ) {
-           md = md_open( algo, 0 );
+            if (gcry_md_open (&md, algo, 0))
+              BUG ();
            hash_public_key( md, pk );
            hash_public_key( md, snode->pkt->pkt.public_key );
            rc = do_check( pk, sig, md, r_expired, NULL, ret_pk );
             cache_sig_result ( sig, rc );
-           md_close(md);
+           gcry_md_close(md);
        }
-       else {
+       else
+         {
             if (opt.verbose)
-                log_info (_("key %08lX: no subkey for subkey "
-                           "revocation signature\n"),
-                          (ulong)keyid_from_pk (pk, NULL));
+             log_info (_("key %s: no subkey for subkey"
+                         " revocation signature\n"),keystr_from_pk(pk));
            rc = G10ERR_SIG_CLASS;
-       }
+         }
     }
     else if( sig->sig_class == 0x18 ) { /* key binding */
        KBNODE snode = find_prev_kbnode( root, node, PKT_PUBLIC_SUBKEY );
@@ -500,27 +606,29 @@ check_key_signature2( KBNODE root, KBNODE node, PKT_public_key *check_pk,
                if( keyid[0] == sig->keyid[0] && keyid[1] == sig->keyid[1] )
                    *is_selfsig = 1;
            }
-           md = md_open( algo, 0 );
+           if (gcry_md_open (&md, algo, 0))
+              BUG ();
            hash_public_key( md, pk );
            hash_public_key( md, snode->pkt->pkt.public_key );
            rc = do_check( pk, sig, md, r_expired, NULL, ret_pk );
             cache_sig_result ( sig, rc );
-           md_close(md);
+           gcry_md_close(md);
        }
-       else {
+       else
+         {
             if (opt.verbose)
-                log_info(_("key %08lX: no subkey for subkey "
-                          "binding signature\n"),
-                        (ulong)keyid_from_pk (pk, NULL));
+             log_info(_("key %s: no subkey for subkey"
+                        " binding signature\n"),keystr_from_pk(pk));
            rc = G10ERR_SIG_CLASS;
-       }
+         }
     }
     else if( sig->sig_class == 0x1f ) { /* direct key signature */
-       md = md_open( algo, 0 );
+        if (gcry_md_open (&md, algo, 0 ))
+          BUG ();
        hash_public_key( md, pk );
        rc = do_check( pk, sig, md, r_expired, NULL, ret_pk );
         cache_sig_result ( sig, rc );
-       md_close(md);
+       gcry_md_close(md);
     }
     else { /* all other classes */
        KBNODE unode = find_prev_kbnode( root, node, PKT_USER_ID );
@@ -529,7 +637,8 @@ check_key_signature2( KBNODE root, KBNODE node, PKT_public_key *check_pk,
            u32 keyid[2];
 
            keyid_from_pk( pk, keyid );
-           md = md_open( algo, 0 );
+           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] )
@@ -544,15 +653,15 @@ check_key_signature2( KBNODE root, KBNODE node, PKT_public_key *check_pk,
              rc=signature_check2(sig,md,r_expiredate,r_expired,NULL,ret_pk);
 
             cache_sig_result ( sig, rc );
-           md_close(md);
+           gcry_md_close(md);
        }
-       else {
+       else
+         {
             if (!opt.quiet)
-                log_info ("key %08lX: no user ID for key signature packet "
-                          "of class %02x\n",
-                          (ulong)keyid_from_pk (pk, NULL), sig->sig_class );
+             log_info ("key %s: no user ID for key signature packet"
+                       " of class %02x\n",keystr_from_pk(pk),sig->sig_class);
            rc = G10ERR_SIG_CLASS;
-       }
+         }
     }
 
     return rc;