* main.h, mainproc.c (check_sig_and_print), keylist.c
[gnupg.git] / g10 / pkclist.c
index 4516f67..3203a7e 100644 (file)
@@ -1,12 +1,12 @@
 /* pkclist.c - create a list of public keys
- * Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005,
- *               2006 Free Software Foundation, Inc.
+ * Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007,
+ *               2008 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,9 +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., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301,
- * USA.
+ * along with this program; if not, see <http://www.gnu.org/licenses/>.
  */
 
 #include <config.h>
@@ -30,7 +28,7 @@
 #include "gpg.h"
 #include "options.h"
 #include "packet.h"
-#include "errors.h"
+#include "status.h"
 #include "keydb.h"
 #include "util.h"
 #include "main.h"
@@ -76,7 +74,7 @@ do_show_revocation_reason( PKT_signature *sig )
            fputs( text, log_get_stream() );
        else
            fprintf( log_get_stream(), "code=%02x", *p );
-       putc( '\n', log_get_stream() );
+       log_printf ("\n");
        n--; p++;
        pp = NULL;
        do {
@@ -88,9 +86,9 @@ do_show_revocation_reason( PKT_signature *sig )
            if( n ) {
                pp = memchr( p, '\n', n );
                nn = pp? pp - p : n;
-               log_info( _("revocation comment: ") );
-               print_string( log_get_stream(), p, nn, 0 );
-               putc( '\n', log_get_stream() );
+               log_info ( _("revocation comment: ") );
+               print_string ( log_get_stream(), p, nn, 0 );
+               log_printf ("\n");
                p += nn; n -= nn;
            }
        } while( pp );
@@ -238,7 +236,8 @@ do_edit_ownertrust (PKT_public_key *pk, int mode,
                if((opt.verify_options&VERIFY_SHOW_PHOTOS)
                   && un->pkt->pkt.user_id->attrib_data)
                  show_photos(un->pkt->pkt.user_id->attribs,
-                             un->pkt->pkt.user_id->numattribs,pk,NULL);
+                             un->pkt->pkt.user_id->numattribs,pk,NULL,
+                             un->pkt->pkt.user_id);
 
                p=utf8_to_native(un->pkt->pkt.user_id->name,
                                 un->pkt->pkt.user_id->len,0);
@@ -464,6 +463,18 @@ do_we_trust_pre( PKT_public_key *pk, unsigned int trustlevel )
 
       tty_printf("\n");
 
+      
+      if (is_status_enabled ())
+        {
+          u32 kid[2];
+          char *hint_str;
+          
+          keyid_from_pk (pk, kid);
+          hint_str = get_long_user_id_string ( kid );
+          write_status_text ( STATUS_USERID_HINT, hint_str );
+          xfree (hint_str);
+        }
+
       if( cpr_get_answer_is_yes("untrusted_key.override",
                                _("Use this key anyway? (y/N) "))  )
        rc = 1;
@@ -703,7 +714,7 @@ default_recipient(void)
 }
 
 static int
-expand_id(const char *id,STRLIST *into,unsigned int flags)
+expand_id(const char *id,strlist_t *into,unsigned int flags)
 {
   struct groupitem *groups;
   int count=0;
@@ -713,7 +724,7 @@ expand_id(const char *id,STRLIST *into,unsigned int flags)
       /* need strcasecmp() here, as this should be localized */
       if(strcasecmp(groups->name,id)==0)
        {
-         STRLIST each,sl;
+         strlist_t each,sl;
 
          /* this maintains the current utf8-ness */
          for(each=groups->values;each;each=each->next)
@@ -732,10 +743,10 @@ expand_id(const char *id,STRLIST *into,unsigned int flags)
 
 /* For simplicity, and to avoid potential loops, we only expand once -
    you can't make an alias that points to an alias. */
-static STRLIST
-expand_group(STRLIST input)
+static strlist_t
+expand_group(strlist_t input)
 {
-  STRLIST sl,output=NULL,rover;
+  strlist_t sl,output=NULL,rover;
 
   for(rover=input;rover;rover=rover->next)
     if(expand_id(rover->d,&output,rover->flags)==0)
@@ -764,20 +775,19 @@ expand_group(STRLIST input)
      Bit 1: This is a hidden recipient.
 
    USE is the desired use for the key - usually PUBKEY_USAGE_ENC.
-   RET_PK_LIST.
 
    On success a list of keys is stored at the address RET_PK_LIST; the
    caller must free this list.  On error the value at this address is
    not changed.
  */
 int
-build_pk_list( STRLIST rcpts, PK_LIST *ret_pk_list, unsigned int use )
+build_pk_list( strlist_t rcpts, PK_LIST *ret_pk_list, unsigned int use )
 {
   PK_LIST pk_list = NULL;
   PKT_public_key *pk=NULL;
   int rc=0;
   int any_recipients=0;
-  STRLIST rov,remusr;
+  strlist_t rov,remusr;
   char *def_rec = NULL;
 
   /* Try to expand groups if any have been defined. */
@@ -815,8 +825,9 @@ build_pk_list( STRLIST rcpts, PK_LIST *ret_pk_list, unsigned int use )
           pk->req_usage = use;
 
           /* We explicitly allow encrypt-to to an disabled key; thus
-             we pass 1 as last argument. */
-          if ( (rc = get_pubkey_byname ( pk, rov->d, NULL, NULL, 1 )) ) 
+             we pass 1for the second last argument and 1 as the last
+             argument to disable AKL. */
+          if ( (rc = get_pubkey_byname (NULL, pk, rov->d, NULL, NULL, 1, 1)) ) 
             {
               free_public_key ( pk ); pk = NULL;
               log_error (_("%s: skipped: %s\n"), rov->d, g10_errstr(rc) );
@@ -875,7 +886,7 @@ build_pk_list( STRLIST rcpts, PK_LIST *ret_pk_list, unsigned int use )
     { 
       int have_def_rec;
       char *answer = NULL;
-      STRLIST backlog = NULL;
+      strlist_t backlog = NULL;
 
       if (pk_list)
         any_recipients = 1;
@@ -955,7 +966,7 @@ build_pk_list( STRLIST rcpts, PK_LIST *ret_pk_list, unsigned int use )
             free_public_key (pk);
           pk = xmalloc_clear( sizeof *pk );
           pk->req_usage = use;
-          rc = get_pubkey_byname( pk, answer, NULL, NULL, 0 );
+          rc = get_pubkey_byname (NULL, pk, answer, NULL, NULL, 0, 0 );
           if (rc)
             tty_printf(_("No such user ID.\n"));
           else if ( !(rc=openpgp_pk_test_algo2 (pk->pubkey_algo, use)) ) 
@@ -1028,8 +1039,8 @@ build_pk_list( STRLIST rcpts, PK_LIST *ret_pk_list, unsigned int use )
       pk->req_usage = use;
 
       /* The default recipient is allowed to be disabled; thus pass 1
-         as last argument. */
-      rc = get_pubkey_byname (pk, def_rec, NULL, NULL, 1);
+         as second last argument.  We also don't want an AKL. */
+      rc = get_pubkey_byname (NULL, pk, def_rec, NULL, NULL, 1, 1);
       if (rc)
         log_error(_("unknown default recipient \"%s\"\n"), def_rec );
       else if ( !(rc=openpgp_pk_test_algo2(pk->pubkey_algo, use)) ) 
@@ -1069,7 +1080,7 @@ build_pk_list( STRLIST rcpts, PK_LIST *ret_pk_list, unsigned int use )
 
           pk = xmalloc_clear( sizeof *pk );
           pk->req_usage = use;
-          if ( (rc = get_pubkey_byname( pk, remusr->d, NULL, NULL, 0 )) ) 
+          if ((rc = get_pubkey_byname (NULL, pk, remusr->d, NULL, NULL, 0, 0)))
             {
               /* Key not found or other error. */
               free_public_key( pk ); pk = NULL;
@@ -1186,7 +1197,7 @@ build_pk_list( STRLIST rcpts, PK_LIST *ret_pk_list, unsigned int use )
    preference list, so I'm including it. -dms */
 
 int
-algo_available( preftype_t preftype, int algo, void *hint )
+algo_available( preftype_t preftype, int algo, const union pref_hint *hint)
 {
   if( preftype == PREFTYPE_SYM )
     {
@@ -1210,18 +1221,18 @@ algo_available( preftype_t preftype, int algo, void *hint )
     }
   else if( preftype == PREFTYPE_HASH )
     {
-      if(hint)
+      if (hint && hint->digest_length)
        {
-         if(opt.flags.dsa2)
+         if (hint->digest_length!=20 || opt.flags.dsa2)
            {
-             /* If --enable-dsa2 is set, then we'll accept a hash
-                that is larger than we need.  If --enable-dsa2 is not
-                set, then we won't accept any hash that isn't exactly
-                the right size. */
-             if ((*(int *)hint) > gcry_md_get_algo_dlen (algo))
+             /* If --enable-dsa2 is set or the hash isn't 160 bits
+                (which implies DSA2), then we'll accept a hash that
+                is larger than we need.  Otherwise we won't accept
+                any hash that isn't exactly the right size. */
+             if (hint->digest_length > gcry_md_get_algo_dlen (algo))
                return 0;
            }
-         else if (((*(int *)hint) != gcry_md_get_algo_dlen (algo)))
+         else if (hint->digest_length != gcry_md_get_algo_dlen (algo))
            return 0;
        }
 
@@ -1253,195 +1264,254 @@ algo_available( preftype_t preftype, int algo, void *hint )
     return 0;
 }
 
-
-
 /****************
  * Return -1 if we could not find an algorithm.
  */
 int
-select_algo_from_prefs(PK_LIST pk_list, int preftype, int request, void *hint)
+select_algo_from_prefs(PK_LIST pk_list, int preftype,
+                      int request, const union pref_hint *hint)
 {
-    PK_LIST pkr;
-    u32 bits[8];
-    const prefitem_t *prefs;
-    int i, j;
-    int compr_hack=0;
-    int any;
-
-    if( !pk_list )
-       return -1;
-
-    memset( bits, ~0, 8 * sizeof *bits );
-    for( pkr = pk_list; pkr; pkr = pkr->next ) {
-       u32 mask[8];
-
-       memset( mask, 0, 8 * sizeof *mask );
-       if( preftype == PREFTYPE_SYM ) {
-         if( PGP2 &&
-             pkr->pk->version < 4 &&
-             pkr->pk->selfsigversion < 4 )
-           mask[0] |= (1<<1); /* IDEA is implicitly there for v3 keys
-                                 with v3 selfsigs (rfc2440:12.1) if
-                                 --pgp2 mode is on.  This doesn't
-                                 mean it's actually available, of
-                                 course. */
+  PK_LIST pkr;
+  u32 bits[8];
+  const prefitem_t *prefs;
+  int result=-1,i;
+  unsigned int best=-1;    
+  byte scores[256];
+    
+  if( !pk_list )
+    return -1;
+
+  memset(bits,0xFF,sizeof(bits));
+  memset(scores,0,sizeof(scores));
+
+  for( pkr = pk_list; pkr; pkr = pkr->next )
+    {
+      u32 mask[8];
+      int rank=1,implicit=-1;
+
+      memset(mask,0,sizeof(mask));
+
+      switch(preftype)
+       {
+       case PREFTYPE_SYM:
+         /* IDEA is implicitly there for v3 keys with v3 selfsigs if
+            --pgp2 mode is on.  This was a 2440 thing that was
+            dropped from 4880 but is still relevant to GPG's 1991
+            support.  All this doesn't mean IDEA is actually
+            available, of course. */
+         if(PGP2 && pkr->pk->version<4 && pkr->pk->selfsigversion<4)
+           implicit=CIPHER_ALGO_IDEA;
          else
-           mask[0] |= (1<<2); /* 3DES is implicitly there for everyone else */
-       }
-       else if( preftype == PREFTYPE_HASH ) {
+           implicit=CIPHER_ALGO_3DES;
+
+         break;
+
+       case PREFTYPE_HASH:
          /* While I am including this code for completeness, note
             that currently --pgp2 mode locks the hash at MD5, so this
-            function will never even be called.  Even if the hash
-            wasn't locked at MD5, we don't support sign+encrypt in
-            --pgp2 mode, and that's the only time PREFTYPE_HASH is
-            used anyway. -dms */
-         if( PGP2 &&
-             pkr->pk->version < 4 &&
-             pkr->pk->selfsigversion < 4 )
-           mask[0] |= (1<<1); /* MD5 is there for v3 keys with v3
-                                 selfsigs when --pgp2 is on. */
+            code will never even be called.  Even if the hash wasn't
+            locked at MD5, we don't support sign+encrypt in --pgp2
+            mode, and that's the only time PREFTYPE_HASH is used
+            anyway. -dms */
+
+         /* MD5 is there for v3 keys with v3 selfsigs when --pgp2 is
+            on. */
+         if(PGP2 && pkr->pk->version<4 && pkr->pk->selfsigversion<4)
+           implicit=DIGEST_ALGO_MD5;
          else
-           mask[0] |= (1<<2); /* SHA1 is there for everyone else */
+           implicit=DIGEST_ALGO_SHA1;
+
+         break;
+
+       case PREFTYPE_ZIP:
+         /* Uncompressed is always an option. */
+         implicit=COMPRESS_ALGO_NONE;
        }
-       else if( preftype == PREFTYPE_ZIP )
-         mask[0] |= (1<<0); /* Uncompressed is implicit */
 
-        if (pkr->pk->user_id) /* selected by user ID */
-            prefs = pkr->pk->user_id->prefs;
-        else
-            prefs = pkr->pk->prefs;
-
-       any = 0;
-       if( prefs ) {
-           for (i=0; prefs[i].type; i++ ) {
-               if( prefs[i].type == preftype ) {
-                   mask[prefs[i].value/32] |= 1 << (prefs[i].value%32);
-                   any = 1;
+      if (pkr->pk->user_id) /* selected by user ID */
+       prefs = pkr->pk->user_id->prefs;
+      else
+       prefs = pkr->pk->prefs;
+
+      if( prefs )
+       {
+         for (i=0; prefs[i].type; i++ )
+           {
+             if( prefs[i].type == preftype )
+               {
+                 scores[prefs[i].value]+=rank;
+                 mask[prefs[i].value/32] |= 1<<(prefs[i].value%32);
+
+                 rank++;
+
+                 /* We saw the implicit algorithm, so we don't need
+                    tack it on the end ourselves. */
+                 if(implicit==prefs[i].value)
+                   implicit=-1;
                }
            }
        }
 
-       if( (!prefs || !any) && preftype == PREFTYPE_ZIP ) {
-           mask[0] |= 3; /* asume no_compression and old pgp */
-           compr_hack = 1;
+      if(rank==1 && preftype==PREFTYPE_ZIP)
+       {
+         /* If the compression preferences are not present, they are
+            assumed to be ZIP, Uncompressed (RFC4880:13.3.1) */
+         scores[1]=1; /* ZIP is first choice */
+         scores[0]=2; /* Uncompressed is second choice */
+         mask[0]|=3;
        }
 
-#if 0
-       log_debug("pref mask=%08lX%08lX%08lX%08lX%08lX%08lX%08lX%08lX\n",
-              (ulong)mask[7], (ulong)mask[6], (ulong)mask[5], (ulong)mask[4],
-            (ulong)mask[3], (ulong)mask[2], (ulong)mask[1], (ulong)mask[0]);
-#endif
-       for(i=0; i < 8; i++ )
-           bits[i] &= mask[i];
-#if 0
-       log_debug("pref bits=%08lX%08lX%08lX%08lX%08lX%08lX%08lX%08lX\n",
-              (ulong)bits[7], (ulong)bits[6], (ulong)bits[5], (ulong)bits[4],
-            (ulong)bits[3], (ulong)bits[2], (ulong)bits[1], (ulong)bits[0]);
-#endif
-    }
-    /* usable algorithms are now in bits
-     * We now use the last key from pk_list to select
-     * the algorithm we want to use. there are no
-     * preferences for the last key, we select the one
-     * corresponding to first set bit.
-     */
-    i = -1;
-    any = 0;
-
-    /* Can we use the requested algorithm? */
-    if(request>-1 && (bits[request/32] & (1<<(request%32))) &&
-       algo_available(preftype,request,hint))
-      return request;
-
-    /* If we have personal prefs set, use them instead of the last key */
-    if(preftype==PREFTYPE_SYM && opt.personal_cipher_prefs)
-      prefs=opt.personal_cipher_prefs;
-    else if(preftype==PREFTYPE_HASH && opt.personal_digest_prefs)
-      prefs=opt.personal_digest_prefs;
-    else if(preftype==PREFTYPE_ZIP && opt.personal_compress_prefs)
-      prefs=opt.personal_compress_prefs;
-
-    if( prefs ) {
-       for(j=0; prefs[j].type; j++ ) {
-           if( prefs[j].type == preftype ) {
-                if( (bits[prefs[j].value/32] & (1<<(prefs[j].value%32))) ) {
-                   if( algo_available( preftype, prefs[j].value, hint ) ) {
-                       any = 1;
-                       i = prefs[j].value;
-                       break;
-                   }
-               }
-           }
+      /* If the key didn't have the implicit algorithm listed
+        explicitly, add it here at the tail of the list. */
+      if(implicit>-1)
+       {
+         scores[implicit]+=rank;
+         mask[implicit/32] |= 1<<(implicit%32);
        }
-    }
-    if( !prefs || !any ) {
-       for(j=0; j < 256; j++ )
-           if( (bits[j/32] & (1<<(j%32))) ) {
-               if( algo_available( preftype, j, hint ) ) {
-                   i = j;
-                   break;
-               }
-           }
-    }
 
-#if 0
-    log_debug("prefs of type %d: selected %d\n", preftype, i );
-#endif
-    if( compr_hack && !i ) {
-       /* selected no compression, but we should check whether
-        * algorithm 1 is also available (the ordering is not relevant
-        * in this case). */
-       if( bits[0] & (1<<1) )
-           i = 1; /* yep; we can use compression algo 1 */
+      for(i=0;i<8;i++)
+       bits[i]&=mask[i];
     }
 
-    /* "If you are building an authentication system, the recipient
-       may specify a preferred signing algorithm. However, the signer
-       would be foolish to use a weak algorithm simply because the
-       recipient requests it." RFC2440:13.  If we settle on MD5, and
-       SHA1 is also available, use SHA1 instead.  Of course, if the
-       user intentionally chose MD5 (by putting it in their personal
-       prefs), then we should do what they say. */
+  /* We've now scored all of the algorithms, and the usable ones have
+     bits set.  Let's pick the winner. */
 
-    if(preftype==PREFTYPE_HASH &&
-       i==DIGEST_ALGO_MD5 && (bits[0] & (1<<DIGEST_ALGO_SHA1)))
-      {
-       i=DIGEST_ALGO_SHA1;
+  /* The caller passed us a request.  Can we use it? */
+  if(request>-1 && (bits[request/32] & (1<<(request%32))) &&
+     algo_available(preftype,request,hint))
+    result=request;
 
-       if(opt.personal_digest_prefs)
-         for(j=0; prefs[j].type; j++ )
-           if(opt.personal_digest_prefs[j].type==PREFTYPE_HASH &&
-              opt.personal_digest_prefs[j].value==DIGEST_ALGO_MD5)
+  if(result==-1)
+    {
+      /* If we have personal prefs set, use them. */
+      prefs=NULL;
+      if(preftype==PREFTYPE_SYM && opt.personal_cipher_prefs)
+       prefs=opt.personal_cipher_prefs;
+      else if(preftype==PREFTYPE_HASH && opt.personal_digest_prefs)
+       prefs=opt.personal_digest_prefs;
+      else if(preftype==PREFTYPE_ZIP && opt.personal_compress_prefs)
+       prefs=opt.personal_compress_prefs;
+
+      if( prefs )
+       for(i=0; prefs[i].type; i++ )
+         {
+           if(bits[prefs[i].value/32] & (1<<(prefs[i].value%32))
+              && algo_available( preftype, prefs[i].value, hint))
              {
-               i=DIGEST_ALGO_MD5;
+               result = prefs[i].value;
                break;
              }
-      }
+         }
+    }
+
+  if(result==-1)
+    {
+      /* At this point, we have not selected an algorithm due to a
+        special request or via personal prefs.  Pick the highest
+        ranked algorithm (i.e. the one with the lowest score). */
 
-    return i;
+      for(i=0;i<256;i++)
+       {
+         /* Note the '<' here.  This means in case of a tie, we will
+            favor the lower algorithm number.  We have a choice
+            between the lower number (probably an older algorithm
+            with more time in use), or the higher number (probably a
+            newer algorithm with less time in use).  Older is
+            probably safer here, even though the newer algorithms
+            tend to be "stronger". */
+         if(scores[i] && scores[i]<best
+            && (bits[i/32] & (1<<(i%32)))
+            && algo_available(preftype,i,hint))
+           {
+             best=scores[i];
+             result=i;
+           }
+       }
+
+      /* "If you are building an authentication system, the recipient
+        may specify a preferred signing algorithm. However, the
+        signer would be foolish to use a weak algorithm simply
+        because the recipient requests it." (RFC4880:14).  If we
+        settle on MD5, and SHA1 is also available, use SHA1 instead.
+        Note that if the user intentionally chose MD5 by putting it
+        in their personal prefs, then we do what the user said (as we
+        never reach this code). */
+      if(preftype==PREFTYPE_HASH && result==DIGEST_ALGO_MD5
+        && (bits[0] & (1<<DIGEST_ALGO_SHA1)))
+       result=DIGEST_ALGO_SHA1;
+    }
+
+  return result;
 }
 
 /*
- * Select the MDC flag from the pk_list.  We can only use MDC if all recipients
- * support this feature 
+ * Select the MDC flag from the pk_list.  We can only use MDC if all
+ * recipients support this feature.
  */
 int
 select_mdc_from_pklist (PK_LIST pk_list)
 {
-    PK_LIST pkr;
+  PK_LIST pkr;
 
-    if( !pk_list )
-       return 0;
+  if ( !pk_list )
+    return 0;
+  
+  for (pkr = pk_list; pkr; pkr = pkr->next) 
+    {
+      int mdc;
+      
+      if (pkr->pk->user_id) /* selected by user ID */
+        mdc = pkr->pk->user_id->flags.mdc;
+      else
+        mdc = pkr->pk->mdc_feature;
+      if (!mdc)
+        return 0;  /* At least one recipient does not support it. */
+    }
+  return 1; /* Can be used. */
+}
 
-    for (pkr = pk_list; pkr; pkr = pkr->next) {
-        int mdc;
 
-        if (pkr->pk->user_id) /* selected by user ID */
-            mdc = pkr->pk->user_id->flags.mdc;
-        else
-            mdc = pkr->pk->mdc_feature;
-        if (!mdc)
-            return 0; /* at least one recipient does not support it */
+/* Print a warning for all keys in PK_LIST missing the MDC feature. */
+void
+warn_missing_mdc_from_pklist (PK_LIST pk_list)
+{
+  PK_LIST pkr;
+  
+  for (pkr = pk_list; pkr; pkr = pkr->next) 
+    {
+      int mdc;
+
+      if (pkr->pk->user_id) /* selected by user ID */
+        mdc = pkr->pk->user_id->flags.mdc;
+      else
+        mdc = pkr->pk->mdc_feature;
+      if (!mdc)
+        log_info (_("Note: key %s has no %s feature\n"),
+                  keystr_from_pk (pkr->pk), "MDC");
+    }
+}
+
+void
+warn_missing_aes_from_pklist (PK_LIST pk_list)
+{
+  PK_LIST pkr;
+  for (pkr = pk_list; pkr; pkr = pkr->next) 
+    {
+      const prefitem_t *prefs;
+      int i;
+      int gotit = 0;
+
+      prefs = pkr->pk->user_id? pkr->pk->user_id->prefs : pkr->pk->prefs;
+      if (prefs)
+        {
+          for (i=0; !gotit && prefs[i].type; i++ )
+            if (prefs[i].type == PREFTYPE_SYM 
+                && prefs[i].value == CIPHER_ALGO_AES)
+              gotit++;
+       }
+      if (!gotit)
+        log_info (_("Note: key %s has no preference for %s\n"),
+                  keystr_from_pk (pkr->pk), "AES");
     }
-    return 1; /* can be used */
 }