* mainproc.c (symkey_decrypt_seskey): There is no need to have an
[gnupg.git] / g10 / sig-check.c
index c9c19aa..81d0d60 100644 (file)
@@ -1,5 +1,6 @@
 /* sig-check.c -  Check a signature
- * Copyright (C) 1998, 1999, 2000, 2001, 2002 Free Software Foundation, Inc.
+ * Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003,
+ *               2004 Free Software Foundation, Inc.
  *
  * This file is part of GnuPG.
  *
@@ -39,8 +40,8 @@ struct cmp_help_context_s {
     MD_HANDLE md;
 };
 
-static int do_check( PKT_public_key *pk, PKT_signature *sig,
-                                        MD_HANDLE digest, int *r_expired );
+static int do_check( PKT_public_key *pk, PKT_signature *sig, MD_HANDLE digest,
+                    int *r_expired, int *r_revoked, PKT_public_key *ret_pk);
 
 /****************
  * Check the signature which is contained in SIG.
@@ -50,25 +51,58 @@ static int do_check( PKT_public_key *pk, PKT_signature *sig,
 int
 signature_check( PKT_signature *sig, MD_HANDLE digest )
 {
-    u32 dummy;
-    int dum2;
-    return signature_check2( sig, digest, &dummy, &dum2 );
+    return signature_check2( sig, digest, NULL, NULL, NULL, NULL );
 }
 
 int
-signature_check2( PKT_signature *sig, MD_HANDLE digest,
-                 u32 *r_expiredate, int *r_expired )
+signature_check2( PKT_signature *sig, MD_HANDLE digest, u32 *r_expiredate, 
+                 int *r_expired, int *r_revoked, PKT_public_key *ret_pk )
 {
     PKT_public_key *pk = m_alloc_clear( sizeof *pk );
     int rc=0;
 
-    *r_expiredate = 0;
-    if( get_pubkey( pk, sig->keyid ) )
+    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))
+      {
+       /* 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
+          not match the actual sig, and also if the clearsign "Hash:"
+          header is missing or does not match the actual sig. */
+
+        log_info(_("WARNING: signature digest conflict in message\n"));
+       rc=G10ERR_GENERAL;
+      }
+    else if( get_pubkey( pk, sig->keyid ) )
        rc = G10ERR_NO_PUBKEY;
-    else {
-       *r_expiredate = pk->expiredate;
-       rc = do_check( pk, sig, digest, r_expired );
-    }
+    else if(!pk->is_valid && !pk->is_primary)
+        rc=G10ERR_BAD_PUBKEY; /* you cannot have a good sig from an
+                                invalid subkey */
+    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->is_primary && pk->backsig<2)
+         {
+           if(pk->backsig==0)
+             log_info(_("WARNING: signing subkey %s is not"
+                        " cross-certified\n"),keystr_from_pk(pk));
+           else
+             log_info(_("WARNING: signing subkey %s has an invalid"
+                        " cross-certification\n"),keystr_from_pk(pk));
+         }
+      }
 
     free_public_key( pk );
 
@@ -116,139 +150,72 @@ signature_check2( PKT_signature *sig, MD_HANDLE digest,
 }
 
 
-/****************
- * This function gets called by pubkey_verify() if the algorithm needs it.
- */
 static int
-cmp_help( void *opaque, MPI result )
+do_check_messages( PKT_public_key *pk, PKT_signature *sig,
+                  int *r_expired, int *r_revoked )
 {
-  #if 0 /* we do not use this anymore */
-    int rc=0, i, j, c, old_enc;
-    byte *dp;
-    const byte *asn;
-    size_t mdlen, asnlen;
-    struct cmp_help_context_s *ctx = opaque;
-    PKT_signature *sig = ctx->sig;
-    MD_HANDLE digest = ctx->md;
-
-    old_enc = 0;
-    for(i=j=0; (c=mpi_getbyte(result, i)) != -1; i++ ) {
-       if( !j ) {
-           if( !i && c != 1 )
-               break;
-           else if( i && c == 0xff )
-               ; /* skip the padding */
-           else if( i && !c )
-               j++;
-           else
-               break;
-       }
-       else if( ++j == 18 && c != 1 )
-           break;
-       else if( j == 19 && c == 0 ) {
-           old_enc++;
-           break;
-       }
-    }
-    if( old_enc ) {
-       log_error("old encoding scheme is not supported\n");
-       return G10ERR_GENERAL;
-    }
-
-    if( (rc=check_digest_algo(sig->digest_algo)) )
-       return rc; /* unsupported algo */
-    asn = md_asn_oid( sig->digest_algo, &asnlen, &mdlen );
-
-    for(i=mdlen,j=asnlen-1; (c=mpi_getbyte(result, i)) != -1 && j >= 0;
-                                                          i++, j-- )
-       if( asn[j] != c )
-           break;
-    if( j != -1 || mpi_getbyte(result, i) )
-       return G10ERR_BAD_PUBKEY;  /* ASN is wrong */
-    for(i++; (c=mpi_getbyte(result, i)) != -1; i++ )
-       if( c != 0xff  )
-           break;
-    i++;
-    if( c != sig->digest_algo || mpi_getbyte(result, i) ) {
-       /* Padding or leading bytes in signature is wrong */
-       return G10ERR_BAD_PUBKEY;
-    }
-    if( mpi_getbyte(result, mdlen-1) != sig->digest_start[0]
-       || mpi_getbyte(result, mdlen-2) != sig->digest_start[1] ) {
-       /* Wrong key used to check the signature */
-       return G10ERR_BAD_PUBKEY;
-    }
-
-    dp = md_read( digest, sig->digest_algo );
-    for(i=mdlen-1; i >= 0; i--, dp++ ) {
-       if( mpi_getbyte( result, i ) != *dp )
-           return G10ERR_BAD_SIGN;
-    }
-    return 0;
-  #else
-    return -1;
-  #endif
-}
-
-
-static int
-do_check( PKT_public_key *pk, PKT_signature *sig, MD_HANDLE digest,
-                                                   int *r_expired )
-{
-    MPI result = NULL;
-    int rc=0;
-    struct cmp_help_context_s ctx;
     u32 cur_time;
 
-    *r_expired = 0;
-    if( pk->version == 4 && pk->pubkey_algo == PUBKEY_ALGO_ELGAMAL_E ) {
-       log_info(_("this is a PGP generated "
-                 "ElGamal key which is NOT secure for signatures!\n"));
-       return G10ERR_PUBKEY_ALGO;
-    }
+    if(r_expired)
+      *r_expired = 0;
+    if(r_revoked)
+      *r_revoked = 0;
 
-    if( pk->timestamp > sig->timestamp ) {
+    if( pk->timestamp > sig->timestamp )
+      {
        ulong d = pk->timestamp - sig->timestamp;
-       log_info( d==1
-                 ? _("public key is %lu second newer than the signature\n")
-                 : _("public key is %lu seconds newer than the signature\n"),
-                      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 has been created %lu second "
-                          "in future (time warp or clock problem)\n")
-                      : _("key has been created %lu seconds "
-                          "in future (time warp or clock problem)\n"), 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 ) {
         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);
        write_status(STATUS_SIGEXPIRED);
-       *r_expired = 1;
+       if(r_expired)
+         *r_expired = 1;
     }
 
+    if(pk->is_revoked && r_revoked)
+      *r_revoked=1;
+
+    return 0;
+}
 
-    if( (rc=check_digest_algo(sig->digest_algo)) )
-       return rc;
-    if( (rc=check_pubkey_algo(sig->pubkey_algo)) )
-       return rc;
+
+static int
+do_check( PKT_public_key *pk, PKT_signature *sig, MD_HANDLE digest,
+         int *r_expired, int *r_revoked, PKT_public_key *ret_pk )
+{
+    MPI 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 );
@@ -276,8 +243,13 @@ do_check( PKT_public_key *pk, PKT_signature *sig, MD_HANDLE digest,
            md_write (digest, sig->hashed->data, n);
            n += 6;
        }
-       else
-           n = 6;
+       else {
+         /* Two octets for the (empty) length of the hashed
+             section. */
+          md_putc (digest, 0);
+         md_putc (digest, 0);
+         n = 6;
+       }
        /* add some magic */
        buf[0] = sig->version;
        buf[1] = 0xff;
@@ -290,34 +262,23 @@ do_check( PKT_public_key *pk, PKT_signature *sig, MD_HANDLE digest,
     md_final( digest );
 
     result = encode_md_value( pk->pubkey_algo, digest, sig->digest_algo,
-                             mpi_get_nbits(pk->pkey[0]), 0 );
+                             mpi_get_nbits(pk->pkey[0]) );
     if (!result)
         return G10ERR_GENERAL;
     ctx.sig = sig;
     ctx.md = digest;
-    rc = pubkey_verify( pk->pubkey_algo, result, sig->data, pk->pkey,
-                       cmp_help, &ctx );
+    rc = pubkey_verify( pk->pubkey_algo, result, sig->data, pk->pkey );
     mpi_free( result );
-    if( (opt.emulate_bugs & EMUBUG_MDENCODE)
-       && rc == G10ERR_BAD_SIGN && is_ELGAMAL(pk->pubkey_algo) ) {
-       /* In this case we try again because old GnuPG versions didn't encode
-        * the hash right. There is no problem with DSA however  */
-       result = encode_md_value( pk->pubkey_algo, digest, sig->digest_algo,
-                             mpi_get_nbits(pk->pkey[0]), (sig->version < 5) );
-        if (!result)
-            rc = G10ERR_GENERAL;
-        else {
-            ctx.sig = sig;
-            ctx.md = digest;
-            rc = pubkey_verify( pk->pubkey_algo, result, sig->data, pk->pkey,
-                                cmp_help, &ctx );
-        }
-    }
 
-    if( !rc && sig->flags.unknown_critical ) {
-       log_info(_("assuming bad signature due to an unknown critical bit\n"));
+    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);
 
     return rc;
 }
@@ -372,6 +333,105 @@ 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 G10ERR_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. */
+int
+check_revocation_keys(PKT_public_key *pk,PKT_signature *sig)
+{
+  static int busy=0;
+  int i,rc=G10ERR_GENERAL;
+
+  assert(IS_KEY_REV(sig));
+  assert((sig->keyid[0]!=pk->keyid[0]) || (sig->keyid[0]!=pk->keyid[1]));
+
+  if(busy)
+    {
+      /* 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;
+      return rc;
+    }
+
+  busy=1;
+
+  /*  printf("looking at %08lX with a sig from %08lX\n",(ulong)pk->keyid[1],
+      (ulong)sig->keyid[1]); */
+
+  /* is the issuer of the sig one of our revokers? */
+  if( !pk->revkey && pk->numrevkeys )
+     BUG();
+  else
+      for(i=0;i<pk->numrevkeys;i++)
+       {
+          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])
+           {
+              MD_HANDLE md;
+    
+              md=md_open(sig->digest_algo,0);
+              hash_public_key(md,pk);
+              rc=signature_check(sig,md);
+             cache_sig_result(sig,rc);
+             break;
+           }
+       }
+
+  busy=0;
+
+  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)
+{
+  MD_HANDLE md;
+  int rc;
+
+  if(!opt.no_sig_cache && backsig->flags.checked)
+    {
+      if((rc=check_digest_algo(backsig->digest_algo)))
+       return rc;
+
+      return backsig->flags.valid? 0 : G10ERR_BAD_SIGN;
+    }
+
+  md=md_open(backsig->digest_algo,0);
+  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);
+  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
@@ -380,14 +440,19 @@ cache_sig_result ( PKT_signature *sig, int result )
 int
 check_key_signature( KBNODE root, KBNODE node, int *is_selfsig )
 {
-    u32 dummy;
-    int dum2;
-    return check_key_signature2(root, node, is_selfsig, &dummy, &dum2 );
+  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, int *is_selfsig,
-                                      u32 *r_expiredate, int *r_expired )
+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;
     PKT_public_key *pk;
@@ -397,8 +462,10 @@ check_key_signature2( KBNODE root, KBNODE node, int *is_selfsig,
 
     if( is_selfsig )
        *is_selfsig = 0;
-    *r_expiredate = 0;
-    *r_expired = 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 );
 
@@ -406,7 +473,10 @@ check_key_signature2( KBNODE root, KBNODE node, int *is_selfsig,
     sig = node->pkt->pkt.signature;
     algo = sig->digest_algo;
 
-    /* check whether we have cached the result of a previous signature check.*/
+    /* 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 ) {  
@@ -416,19 +486,34 @@ check_key_signature2( KBNODE root, KBNODE node, int *is_selfsig,
                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=do_check_messages(pk,sig,r_expired,NULL)))
+             return rc;
             return sig->flags.valid? 0 : G10ERR_BAD_SIGN;
         }
     }
 
+    if( (rc=check_pubkey_algo(sig->pubkey_algo)) )
+       return rc;
     if( (rc=check_digest_algo(algo)) )
        return rc;
 
     if( sig->sig_class == 0x20 ) { /* key revocation */
-       md = md_open( algo, 0 );
-       hash_public_key( md, pk );
-       rc = do_check( pk, sig, md, r_expired );
-        cache_sig_result ( sig, rc );
-       md_close(md);
+        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
+         {
+           md = md_open( algo, 0 );
+           hash_public_key( md, pk );
+           rc = do_check( pk, sig, md, r_expired, NULL, ret_pk );
+           cache_sig_result ( sig, rc );
+           md_close(md);
+         }
     }
     else if( sig->sig_class == 0x28 ) { /* subkey revocation */
        KBNODE snode = find_prev_kbnode( root, node, PKT_PUBLIC_SUBKEY );
@@ -437,16 +522,17 @@ check_key_signature2( KBNODE root, KBNODE node, int *is_selfsig,
            md = md_open( algo, 0 );
            hash_public_key( md, pk );
            hash_public_key( md, snode->pkt->pkt.public_key );
-           rc = do_check( pk, sig, md, r_expired );
+           rc = do_check( pk, sig, md, r_expired, NULL, ret_pk );
             cache_sig_result ( sig, rc );
            md_close(md);
        }
-       else {
-            if (!opt.quiet)
-                log_info ("key %08lX: no subkey for subkey revocation packet\n",
-                          (ulong)keyid_from_pk (pk, NULL));
+       else
+         {
+            if (opt.verbose)
+             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 );
@@ -462,21 +548,22 @@ check_key_signature2( KBNODE root, KBNODE node, int *is_selfsig,
            md = md_open( algo, 0 );
            hash_public_key( md, pk );
            hash_public_key( md, snode->pkt->pkt.public_key );
-           rc = do_check( pk, sig, md, r_expired );
+           rc = do_check( pk, sig, md, r_expired, NULL, ret_pk );
             cache_sig_result ( sig, rc );
            md_close(md);
        }
-       else {
-            if (!opt.quiet)
-                log_info ("key %08lX: no subkey for subkey binding packet\n",
-                          (ulong)keyid_from_pk (pk, NULL));
+       else
+         {
+            if (opt.verbose)
+             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 );
        hash_public_key( md, pk );
-       rc = do_check( pk, sig, md, r_expired );
+       rc = do_check( pk, sig, md, r_expired, NULL, ret_pk );
         cache_sig_result ( sig, rc );
        md_close(md);
     }
@@ -490,27 +577,28 @@ check_key_signature2( KBNODE root, KBNODE node, int *is_selfsig,
            md = md_open( algo, 0 );
            hash_public_key( md, pk );
            hash_uid_node( unode, md, sig );
-           if( keyid[0] == sig->keyid[0] && keyid[1] == sig->keyid[1] ) {
+           if( keyid[0] == sig->keyid[0] && keyid[1] == sig->keyid[1] )
+             {
                if( is_selfsig )
-                   *is_selfsig = 1;
-               rc = do_check( pk, sig, md, r_expired );
-           }
-           else {
-               rc = signature_check2( sig, md, r_expiredate, r_expired );
-           }
+                 *is_selfsig = 1;
+               rc = do_check( pk, sig, md, r_expired, NULL, ret_pk );
+             }
+           else if (check_pk)
+             rc=do_check(check_pk,sig,md,r_expired,NULL,ret_pk);
+           else
+             rc=signature_check2(sig,md,r_expiredate,r_expired,NULL,ret_pk);
+
             cache_sig_result ( sig, rc );
            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;
 }
-
-