gpg: Sanitize diagnostic with the original file name.
[gnupg.git] / g10 / pubkey-enc.c
index 1772936..0185097 100644 (file)
 #include <string.h>
 
 #include "gpg.h"
-#include "util.h"
+#include "../common/util.h"
 #include "packet.h"
 #include "keydb.h"
 #include "trustdb.h"
-#include "status.h"
+#include "../common/status.h"
 #include "options.h"
 #include "main.h"
-#include "i18n.h"
+#include "../common/i18n.h"
 #include "pkglue.h"
 #include "call-agent.h"
-#include "host2net.h"
+#include "../common/host2net.h"
+#include "../common/compliance.h"
 
 
-static gpg_error_t get_it (PKT_pubkey_enc *k,
+static gpg_error_t get_it (ctrl_t ctrl, PKT_pubkey_enc *k,
                            DEK *dek, PKT_public_key *sk, u32 *keyid);
 
 
@@ -54,7 +55,7 @@ is_algo_in_prefs (kbnode_t keyblock, preftype_t type, int algo)
           PKT_user_id *uid = k->pkt->pkt.user_id;
           prefitem_t *prefs = uid->prefs;
 
-          if (uid->created && prefs && !uid->is_revoked && !uid->is_expired)
+          if (uid->created && prefs && !uid->flags.revoked && !uid->flags.expired)
             {
               for (; prefs->type; prefs++)
                 if (prefs->type == type && prefs->value == algo)
@@ -87,8 +88,22 @@ get_session_key (ctrl_t ctrl, PKT_pubkey_enc * k, DEK * dek)
     {
       sk = xmalloc_clear (sizeof *sk);
       sk->pubkey_algo = k->pubkey_algo; /* We want a pubkey with this algo.  */
-      if (!(rc = get_seckey (sk, k->keyid)))
-        rc = get_it (k, dek, sk, k->keyid);
+      if (!(rc = get_seckey (ctrl, sk, k->keyid)))
+        {
+          /* Check compliance.  */
+          if (! gnupg_pk_is_allowed (opt.compliance, PK_USE_DECRYPTION,
+                                     sk->pubkey_algo,
+                                     sk->pkey, nbits_from_pk (sk), NULL))
+            {
+              log_info (_("key %s is not suitable for decryption"
+                          " in %s mode\n"),
+                        keystr_from_pk (sk),
+                        gnupg_compliance_option_string (opt.compliance));
+              rc = gpg_error (GPG_ERR_PUBKEY_ALGO);
+            }
+          else
+            rc = get_it (ctrl, k, dek, sk, k->keyid);
+        }
     }
   else if (opt.skip_hidden_recipients)
     rc = gpg_error (GPG_ERR_NO_SECKEY);
@@ -116,7 +131,19 @@ get_session_key (ctrl_t ctrl, PKT_pubkey_enc * k, DEK * dek)
             log_info (_("anonymous recipient; trying secret key %s ...\n"),
                       keystr (keyid));
 
-          rc = get_it (k, dek, sk, keyid);
+          /* Check compliance.  */
+          if (! gnupg_pk_is_allowed (opt.compliance, PK_USE_DECRYPTION,
+                                     sk->pubkey_algo,
+                                     sk->pkey, nbits_from_pk (sk), NULL))
+            {
+              log_info (_("key %s is not suitable for decryption"
+                          " in %s mode\n"),
+                          keystr_from_pk (sk),
+                          gnupg_compliance_option_string (opt.compliance));
+              continue;
+            }
+
+          rc = get_it (ctrl, k, dek, sk, keyid);
           if (!rc)
             {
               if (!opt.quiet)
@@ -129,7 +156,7 @@ get_session_key (ctrl_t ctrl, PKT_pubkey_enc * k, DEK * dek)
       enum_secret_keys (ctrl, &enum_context, NULL);  /* free context */
     }
 
-leave:
+ leave:
   free_public_key (sk);
   if (DBG_CLOCK)
     log_clock ("get_session_key leave");
@@ -138,7 +165,8 @@ leave:
 
 
 static gpg_error_t
-get_it (PKT_pubkey_enc *enc, DEK *dek, PKT_public_key *sk, u32 *keyid)
+get_it (ctrl_t ctrl,
+        PKT_pubkey_enc *enc, DEK *dek, PKT_public_key *sk, u32 *keyid)
 {
   gpg_error_t err;
   byte *frame = NULL;
@@ -200,7 +228,7 @@ get_it (PKT_pubkey_enc *enc, DEK *dek, PKT_public_key *sk, u32 *keyid)
     }
 
   /* Decrypt. */
-  desc = gpg_format_keydesc (sk, FORMAT_KEYDESC_NORMAL, 1);
+  desc = gpg_format_keydesc (ctrl, sk, FORMAT_KEYDESC_NORMAL, 1);
   err = agent_pkdecrypt (NULL, keygrip,
                          desc, sk->keyid, sk->main_keyid, sk->pubkey_algo,
                          s_data, &frame, &nframe, &padding);
@@ -227,7 +255,7 @@ get_it (PKT_pubkey_enc *enc, DEK *dek, PKT_public_key *sk, u32 *keyid)
    * CSUM
    */
   if (DBG_CRYPTO)
-    log_printhex ("DEK frame:", frame, nframe);
+    log_printhex (frame, nframe, "DEK frame:");
   n = 0;
 
   if (sk->pubkey_algo == PUBKEY_ALGO_ECDH)
@@ -333,14 +361,14 @@ get_it (PKT_pubkey_enc *enc, DEK *dek, PKT_public_key *sk, u32 *keyid)
   if (DBG_CLOCK)
     log_clock ("decryption ready");
   if (DBG_CRYPTO)
-    log_printhex ("DEK is:", dek->key, dek->keylen);
+    log_printhex (dek->key, dek->keylen, "DEK is:");
 
   /* Check that the algo is in the preferences and whether it has
    * expired.  Also print a status line with the key's fingerprint.  */
   {
     PKT_public_key *pk = NULL;
     PKT_public_key *mainpk = NULL;
-    KBNODE pkb = get_pubkeyblock (keyid);
+    KBNODE pkb = get_pubkeyblock (ctrl, keyid);
 
     if (!pkb)
       {
@@ -393,7 +421,7 @@ get_it (PKT_pubkey_enc *enc, DEK *dek, PKT_public_key *sk, u32 *keyid)
       {
         log_info (_("Note: key has been revoked"));
         log_printf ("\n");
-        show_revocation_reason (pk, 1);
+        show_revocation_reason (ctrl, pk, 1);
       }
 
     if (is_status_enabled () && pk && mainpk)
@@ -404,8 +432,13 @@ get_it (PKT_pubkey_enc *enc, DEK *dek, PKT_public_key *sk, u32 *keyid)
         hexfingerprint (pk, pkhex, sizeof pkhex);
         hexfingerprint (mainpk, mainpkhex, sizeof mainpkhex);
 
+        /* Note that we do not want to create a trustdb just for
+         * getting the ownertrust: If there is no trustdb there can't
+         * be ulitmately trusted key anyway and thus the ownertrust
+         * value is irrelevant.  */
         write_status_printf (STATUS_DECRYPTION_KEY, "%s %s %c",
-                             pkhex, mainpkhex, get_ownertrust_info (mainpk));
+                             pkhex, mainpkhex,
+                             get_ownertrust_info (ctrl, mainpk, 1));
 
       }