Revert commit 4654384fe7a4dcee113dacf27c398b13dea5d0be.
[gnupg.git] / g10 / pubkey-enc.c
index d45b4a2..23a4473 100644 (file)
 #include "packet.h"
 #include "keydb.h"
 #include "trustdb.h"
-#include "cipher.h"
 #include "status.h"
 #include "options.h"
 #include "main.h"
 #include "i18n.h"
 #include "pkglue.h"
 #include "call-agent.h"
+#include "host2net.h"
 
 
 static gpg_error_t get_it (PKT_pubkey_enc *k,
@@ -72,11 +72,14 @@ is_algo_in_prefs (kbnode_t keyblock, preftype_t type, int algo)
  * which should have been allocated in secure memory by the caller.
  */
 gpg_error_t
-get_session_key (PKT_pubkey_enc * k, DEK * dek)
+get_session_key (ctrl_t ctrl, PKT_pubkey_enc * k, DEK * dek)
 {
   PKT_public_key *sk = NULL;
   int rc;
 
+  if (DBG_CLOCK)
+    log_clock ("get_session_key enter");
+
   rc = openpgp_pk_test_algo2 (k->pubkey_algo, PUBKEY_USAGE_ENC);
   if (rc)
     goto leave;
@@ -97,13 +100,12 @@ get_session_key (PKT_pubkey_enc * k, DEK * dek)
 
       for (;;)
         {
-          if (sk)
-            free_public_key (sk);
+          free_public_key (sk);
           sk = xmalloc_clear (sizeof *sk);
-          rc = enum_secret_keys (&enum_context, sk);
+          rc = enum_secret_keys (ctrl, &enum_context, sk);
           if (rc)
             {
-              rc = G10ERR_NO_SECKEY;
+              rc = GPG_ERR_NO_SECKEY;
               break;
             }
           if (sk->pubkey_algo != k->pubkey_algo)
@@ -111,24 +113,27 @@ get_session_key (PKT_pubkey_enc * k, DEK * dek)
           if (!(sk->pubkey_usage & PUBKEY_USAGE_ENC))
             continue;
           keyid_from_pk (sk, keyid);
-          log_info (_("anonymous recipient; trying secret key %s ...\n"),
-                    keystr (keyid));
+          if (!opt.quiet)
+            log_info (_("anonymous recipient; trying secret key %s ...\n"),
+                      keystr (keyid));
 
           rc = get_it (k, dek, sk, keyid);
           if (!rc)
             {
-              log_info (_("okay, we are the anonymous recipient.\n"));
+              if (!opt.quiet)
+                log_info (_("okay, we are the anonymous recipient.\n"));
               break;
             }
           else if (gpg_err_code (rc) == GPG_ERR_FULLY_CANCELED)
             break; /* Don't try any more secret keys.  */
         }
-      enum_secret_keys (&enum_context, NULL);  /* free context */
+      enum_secret_keys (ctrl, &enum_context, NULL);  /* free context */
     }
 
 leave:
-  if (sk)
-    free_public_key (sk);
+  free_public_key (sk);
+  if (DBG_CLOCK)
+    log_clock ("get_session_key leave");
   return rc;
 }
 
@@ -141,13 +146,15 @@ get_it (PKT_pubkey_enc *enc, DEK *dek, PKT_public_key *sk, u32 *keyid)
   unsigned int n;
   size_t nframe;
   u16 csum, csum2;
-  int card = 0;
+  int padding;
   gcry_sexp_t s_data;
   char *desc;
   char *keygrip;
   byte fp[MAX_FINGERPRINT_LEN];
   size_t fpn;
-  const int pkalgo = map_pk_openpgp_to_gcry (sk->pubkey_algo);
+
+  if (DBG_CLOCK)
+    log_clock ("decryption start");
 
   /* Get the keygrip.  */
   err = hexkeygrip_from_pk (sk, &keygrip);
@@ -155,15 +162,17 @@ get_it (PKT_pubkey_enc *enc, DEK *dek, PKT_public_key *sk, u32 *keyid)
     goto leave;
 
   /* Convert the data to an S-expression.  */
-  if (pkalgo == GCRY_PK_ELG || pkalgo == GCRY_PK_ELG_E)
+  if (sk->pubkey_algo == PUBKEY_ALGO_ELGAMAL
+      || sk->pubkey_algo == PUBKEY_ALGO_ELGAMAL_E)
     {
       if (!enc->data[0] || !enc->data[1])
         err = gpg_error (GPG_ERR_BAD_MPI);
       else
-        err = gcry_sexp_build (&s_data, NULL, "(enc-val(elg(a%m)(b%m)))", 
+        err = gcry_sexp_build (&s_data, NULL, "(enc-val(elg(a%m)(b%m)))",
                                enc->data[0], enc->data[1]);
     }
-  else if (pkalgo == GCRY_PK_RSA || pkalgo == GCRY_PK_RSA_E)
+  else if (sk->pubkey_algo == PUBKEY_ALGO_RSA
+           || sk->pubkey_algo == PUBKEY_ALGO_RSA_E)
     {
       if (!enc->data[0])
         err = gpg_error (GPG_ERR_BAD_MPI);
@@ -171,13 +180,13 @@ get_it (PKT_pubkey_enc *enc, DEK *dek, PKT_public_key *sk, u32 *keyid)
         err = gcry_sexp_build (&s_data, NULL, "(enc-val(rsa(a%m)))",
                                enc->data[0]);
     }
-  else if (pkalgo == GCRY_PK_ECDH)
+  else if (sk->pubkey_algo == PUBKEY_ALGO_ECDH)
     {
       if (!enc->data[0] || !enc->data[1])
         err = gpg_error (GPG_ERR_BAD_MPI);
       else
         err = gcry_sexp_build (&s_data, NULL, "(enc-val(ecdh(s%m)(e%m)))",
-                               enc->data[0], enc->data[1]);
+                               enc->data[1], enc->data[0]);
     }
   else
     err = gpg_error (GPG_ERR_BUG);
@@ -185,13 +194,17 @@ get_it (PKT_pubkey_enc *enc, DEK *dek, PKT_public_key *sk, u32 *keyid)
   if (err)
     goto leave;
 
-  /* fixme: only needed for ECDH.  Don't compute always. */
-  fingerprint_from_pk (sk, fp, &fpn);
-  assert (fpn == 20);
+  if (sk->pubkey_algo == PUBKEY_ALGO_ECDH)
+    {
+      fingerprint_from_pk (sk, fp, &fpn);
+      assert (fpn == 20);
+    }
 
   /* Decrypt. */
-  desc = gpg_format_keydesc (sk, 0, 1);
-  err = agent_pkdecrypt (NULL, keygrip, desc, s_data, &frame, &nframe);
+  desc = gpg_format_keydesc (sk, FORMAT_KEYDESC_NORMAL, 1);
+  err = agent_pkdecrypt (NULL, keygrip,
+                         desc, sk->keyid, sk->main_keyid, sk->pubkey_algo,
+                         s_data, &frame, &nframe, &padding);
   xfree (desc);
   gcry_sexp_release (s_data);
   if (err)
@@ -214,7 +227,7 @@ get_it (PKT_pubkey_enc *enc, DEK *dek, PKT_public_key *sk, u32 *keyid)
    * DEK is the encryption key (session key) with length k
    * CSUM
    */
-  if (DBG_CIPHER)
+  if (DBG_CRYPTO)
     log_printhex ("DEK frame:", frame, nframe);
   n = 0;
 
@@ -237,8 +250,8 @@ get_it (PKT_pubkey_enc *enc, DEK *dek, PKT_public_key *sk, u32 *keyid)
       if(err)
         goto leave;
 
-      /* Reuse NFRAME, which size is sufficient to include the session key.  */
-      err = gcry_mpi_print (GCRYMPI_FMT_USG, frame, nframe, &nframe, decoded);
+      xfree (frame);
+      err = gcry_mpi_aprint (GCRYMPI_FMT_USG, &frame, &nframe, decoded);
       mpi_release (decoded);
       if (err)
         goto leave;
@@ -258,7 +271,7 @@ get_it (PKT_pubkey_enc *enc, DEK *dek, PKT_public_key *sk, u32 *keyid)
     }
   else
     {
-      if (!card)
+      if (padding)
         {
           if (n + 7 > nframe)
             {
@@ -290,8 +303,6 @@ get_it (PKT_pubkey_enc *enc, DEK *dek, PKT_public_key *sk, u32 *keyid)
 
   dek->keylen = nframe - (n + 1) - 2;
   dek->algo = frame[n++];
-  if (dek->algo == CIPHER_ALGO_IDEA)
-    write_status (STATUS_RSA_OR_IDEA);
   err = openpgp_cipher_test_algo (dek->algo);
   if (err)
     {
@@ -300,8 +311,6 @@ get_it (PKT_pubkey_enc *enc, DEK *dek, PKT_public_key *sk, u32 *keyid)
           log_info (_("cipher algorithm %d%s is unknown or disabled\n"),
                     dek->algo,
                     dek->algo == CIPHER_ALGO_IDEA ? " (IDEA)" : "");
-          if (dek->algo == CIPHER_ALGO_IDEA)
-            idea_cipher_warn (0);
         }
       dek->algo = 0;
       goto leave;
@@ -313,8 +322,7 @@ get_it (PKT_pubkey_enc *enc, DEK *dek, PKT_public_key *sk, u32 *keyid)
     }
 
   /* Copy the key to DEK and compare the checksum.  */
-  csum = frame[nframe - 2] << 8;
-  csum |= frame[nframe - 1];
+  csum = buf16_to_u16 (frame+nframe-2);
   memcpy (dek->key, frame + n, dek->keylen);
   for (csum2 = 0, n = 0; n < dek->keylen; n++)
     csum2 += dek->key[n];
@@ -323,7 +331,9 @@ get_it (PKT_pubkey_enc *enc, DEK *dek, PKT_public_key *sk, u32 *keyid)
       err = gpg_error (GPG_ERR_WRONG_SECKEY);
       goto leave;
     }
-  if (DBG_CIPHER)
+  if (DBG_CLOCK)
+    log_clock ("decryption ready");
+  if (DBG_CRYPTO)
     log_printhex ("DEK is:", dek->key, dek->keylen);
 
   /* Check that the algo is in the preferences and whether it has expired.  */
@@ -365,14 +375,14 @@ get_it (PKT_pubkey_enc *enc, DEK *dek, PKT_public_key *sk, u32 *keyid)
           BUG ();
         if (pk->expiredate && pk->expiredate <= make_timestamp ())
           {
-            log_info (_("NOTE: secret key %s expired at %s\n"),
+            log_info (_("Note: secret key %s expired at %s\n"),
                       keystr (keyid), asctimestamp (pk->expiredate));
           }
       }
 
     if (pk && pk->flags.revoked)
       {
-        log_info (_("NOTE: key has been revoked"));
+        log_info (_("Note: key has been revoked"));
         log_printf ("\n");
         show_revocation_reason (pk, 1);
       }
@@ -400,22 +410,22 @@ get_override_session_key (DEK *dek, const char *string)
   int i;
 
   if (!string)
-    return G10ERR_BAD_KEY;
+    return GPG_ERR_BAD_KEY;
   dek->algo = atoi (string);
   if (dek->algo < 1)
-    return G10ERR_BAD_KEY;
+    return GPG_ERR_BAD_KEY;
   if (!(s = strchr (string, ':')))
-    return G10ERR_BAD_KEY;
+    return GPG_ERR_BAD_KEY;
   s++;
   for (i = 0; i < DIM (dek->key) && *s; i++, s += 2)
     {
       int c = hextobyte (s);
       if (c == -1)
-        return G10ERR_BAD_KEY;
+        return GPG_ERR_BAD_KEY;
       dek->key[i] = c;
     }
   if (*s)
-    return G10ERR_BAD_KEY;
+    return GPG_ERR_BAD_KEY;
   dek->keylen = i;
   return 0;
 }