gpg: Replace remaining uses of stdio by estream.
[gnupg.git] / g10 / sig-check.c
index 55afde0..f8ba98b 100644 (file)
@@ -28,7 +28,6 @@
 #include "util.h"
 #include "packet.h"
 #include "keydb.h"
-#include "cipher.h"
 #include "main.h"
 #include "status.h"
 #include "i18n.h"
@@ -60,7 +59,7 @@ signature_check (PKT_signature *sig, gcry_md_hd_t digest)
 }
 
 int
-signature_check2 (PKT_signature *sig, gcry_md_hd_t 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 = xmalloc_clear( sizeof *pk );
@@ -78,13 +77,15 @@ signature_check2 (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=G10ERR_GENERAL;
+       rc = GPG_ERR_GENERAL;
       }
     else if( get_pubkey( pk, sig->keyid ) )
-       rc = G10ERR_NO_PUBKEY;
-    else if(!pk->is_valid && !pk->is_primary)
-        rc=G10ERR_BAD_PUBKEY; /* you cannot have a good sig from an
-                                invalid subkey */
+       rc = GPG_ERR_NO_PUBKEY;
+    else if(!pk->flags.valid && !pk->flags.primary)
+      {
+        /* You cannot have a good sig from an invalid subkey.  */
+        rc = GPG_ERR_BAD_PUBKEY;
+      }
     else
       {
         if(r_expiredate)
@@ -98,25 +99,25 @@ signature_check2 (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
           signaures issued by it. */
-       if(rc==0 && !pk->is_primary && pk->backsig<2)
+       if(rc==0 && !pk->flags.primary && pk->flags.backsig < 2)
          {
-           if(pk->backsig==0)
+           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");
+                        "https://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;
+                 rc = GPG_ERR_GENERAL;
              }
-           else if(pk->backsig==1)
+           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;
+               rc = GPG_ERR_GENERAL;
              }
          }
       }
@@ -130,41 +131,63 @@ signature_check2 (PKT_signature *sig, gcry_md_hd_t 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 */
-       gcry_md_hd_t 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;
-
-       if (gcry_md_open (&md, GCRY_MD_RMD160, 0))
-          BUG ();
-
-        /* FIXME:  Why the hell are we updating DIGEST here??? */
-       gcry_md_putc( digest, sig->pubkey_algo );
-       gcry_md_putc( digest, sig->digest_algo );
-       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 );
-       for(i=0; i < nsig; i++ ) {
-           size_t n;
-            unsigned char *tmp;
-
-           if (gcry_mpi_aprint (GCRYMPI_FMT_USG, &tmp, &n, sig->data[i]))
+       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();
-           gcry_md_write (md, tmp, n);
-           xfree (tmp);
-       }
-       gcry_md_final (md);
-       p = make_radix64_string ( gcry_md_read( md, 0 ), 20 );
-       buffer = xmalloc( strlen(p) + 60 );
-       sprintf( buffer, "%s %s %lu",
-                p, strtimestamp( sig->timestamp ), (ulong)sig->timestamp );
-       write_status_text( STATUS_SIG_ID, buffer );
-       xfree(buffer);
-       xfree(p);
-       gcry_md_close(md);
+            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;
@@ -190,7 +213,7 @@ do_check_messages( PKT_public_key *pk, PKT_signature *sig,
                 :_("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 GPG_ERR_TIME_CONFLICT; /* pubkey newer than signature.  */
       }
 
     cur_time = make_timestamp();
@@ -204,24 +227,32 @@ do_check_messages( PKT_public_key *pk, PKT_signature *sig,
                      " in the future (time warp or clock problem)\n"),
                  keystr_from_pk(pk),d );
        if( !opt.ignore_time_conflict )
-         return G10ERR_TIME_CONFLICT;
+         return GPG_ERR_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)
-         log_info(_("NOTE: signature key %s expired %s\n"),
+         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);
        if(r_expired)
          *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;
 }
@@ -233,11 +264,17 @@ do_check( PKT_public_key *pk, PKT_signature *sig, gcry_md_hd_t digest,
 {
     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;
 
+    if (sig->digest_algo == GCRY_MD_MD5
+        && !opt.flags.allow_weak_digest_algos)
+      {
+        print_md5_rejected_note ();
+        return GPG_ERR_DIGEST_ALGO;
+      }
+
     /* Make sure the digest algo is enabled (in case of a detached
        signature).  */
     gcry_md_enable (digest, sig->digest_algo);
@@ -283,11 +320,9 @@ do_check( PKT_public_key *pk, PKT_signature *sig, gcry_md_hd_t digest,
     }
     gcry_md_final( digest );
 
-    result = encode_md_value( pk, NULL, digest, sig->digest_algo );
+    result = encode_md_value (pk, digest, sig->digest_algo );
     if (!result)
-        return G10ERR_GENERAL;
-    ctx.sig = sig;
-    ctx.md = digest;
+        return GPG_ERR_GENERAL;
     rc = pk_verify( pk->pubkey_algo, result, sig->data, pk->pkey );
     gcry_mpi_release (result);
 
@@ -295,7 +330,7 @@ do_check( PKT_public_key *pk, PKT_signature *sig, gcry_md_hd_t digest,
       {
        log_info(_("assuming bad signature from key %s"
                   " due to an unknown critical bit\n"),keystr_from_pk(pk));
-       rc = G10ERR_BAD_SIGN;
+       rc = GPG_ERR_BAD_SIGNATURE;
       }
 
     if(!rc && ret_pk)
@@ -367,7 +402,7 @@ cache_sig_result ( PKT_signature *sig, int result )
    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
+   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. */
@@ -375,24 +410,24 @@ int
 check_revocation_keys(PKT_public_key *pk,PKT_signature *sig)
 {
   static int busy=0;
-  int i,rc=G10ERR_GENERAL;
+  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]));
 
-  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;
     }
 
   busy=1;
 
-  /*  printf("looking at %08lX with a sig from %08lX\n",(ulong)pk->keyid[1],
+  /*  es_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? */
@@ -402,18 +437,19 @@ check_revocation_keys(PKT_public_key *pk,PKT_signature *sig)
       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])
            {
               gcry_md_hd_t md;
-    
+
               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;
            }
        }
@@ -421,7 +457,7 @@ check_revocation_keys(PKT_public_key *pk,PKT_signature *sig)
   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.
@@ -506,8 +542,8 @@ check_key_signature2( KBNODE root, KBNODE node, PKT_public_key *check_pk,
        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];   
+           if( is_selfsig ) {
+               u32 keyid[2];
 
                keyid_from_pk( pk, keyid );
                if( keyid[0] == sig->keyid[0] && keyid[1] == sig->keyid[1] )
@@ -527,7 +563,7 @@ check_key_signature2( KBNODE root, KBNODE node, PKT_public_key *check_pk,
        return rc;
 
     if( sig->sig_class == 0x20 ) { /* key revocation */
-        u32 keyid[2];  
+        u32 keyid[2];
        keyid_from_pk( pk, keyid );
 
        /* is it a designated revoker? */
@@ -560,7 +596,7 @@ check_key_signature2( KBNODE root, KBNODE node, PKT_public_key *check_pk,
             if (opt.verbose)
              log_info (_("key %s: no subkey for subkey"
                          " revocation signature\n"),keystr_from_pk(pk));
-           rc = G10ERR_SIG_CLASS;
+           rc = GPG_ERR_SIG_CLASS;
          }
     }
     else if( sig->sig_class == 0x18 ) { /* key binding */
@@ -587,7 +623,7 @@ check_key_signature2( KBNODE root, KBNODE node, PKT_public_key *check_pk,
             if (opt.verbose)
              log_info(_("key %s: no subkey for subkey"
                         " binding signature\n"),keystr_from_pk(pk));
-           rc = G10ERR_SIG_CLASS;
+           rc = GPG_ERR_SIG_CLASS;
          }
     }
     else if( sig->sig_class == 0x1f ) { /* direct key signature */
@@ -628,7 +664,7 @@ check_key_signature2( KBNODE root, KBNODE node, PKT_public_key *check_pk,
             if (!opt.quiet)
              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;
+           rc = GPG_ERR_SIG_CLASS;
          }
     }