LCOV - code coverage report
Current view: top level - g10 - pkclist.c (source / functions) Hit Total Coverage
Test: coverage.info Lines: 198 737 26.9 %
Date: 2016-09-12 12:29:17 Functions: 11 21 52.4 %

          Line data    Source code
       1             : /* pkclist.c - create a list of public keys
       2             :  * Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007,
       3             :  *               2008, 2009, 2010 Free Software Foundation, Inc.
       4             :  *
       5             :  * This file is part of GnuPG.
       6             :  *
       7             :  * GnuPG is free software; you can redistribute it and/or modify
       8             :  * it under the terms of the GNU General Public License as published by
       9             :  * the Free Software Foundation; either version 3 of the License, or
      10             :  * (at your option) any later version.
      11             :  *
      12             :  * GnuPG is distributed in the hope that it will be useful,
      13             :  * but WITHOUT ANY WARRANTY; without even the implied warranty of
      14             :  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
      15             :  * GNU General Public License for more details.
      16             :  *
      17             :  * You should have received a copy of the GNU General Public License
      18             :  * along with this program; if not, see <http://www.gnu.org/licenses/>.
      19             :  */
      20             : 
      21             : #include <config.h>
      22             : #include <stdio.h>
      23             : #include <stdlib.h>
      24             : #include <string.h>
      25             : #include <errno.h>
      26             : 
      27             : #include "gpg.h"
      28             : #include "options.h"
      29             : #include "packet.h"
      30             : #include "status.h"
      31             : #include "keydb.h"
      32             : #include "util.h"
      33             : #include "main.h"
      34             : #include "trustdb.h"
      35             : #include "ttyio.h"
      36             : #include "status.h"
      37             : #include "photoid.h"
      38             : #include "i18n.h"
      39             : #include "tofu.h"
      40             : 
      41             : #define CONTROL_D ('D' - 'A' + 1)
      42             : 
      43             : static void
      44           0 : send_status_inv_recp (int reason, const char *name)
      45             : {
      46             :   char buf[40];
      47             : 
      48           0 :   snprintf (buf, sizeof buf, "%d ", reason);
      49           0 :   write_status_text_and_buffer (STATUS_INV_RECP, buf,
      50             :                                 name, strlen (name),
      51             :                                 -1);
      52           0 : }
      53             : 
      54             : 
      55             : /****************
      56             :  * Show the revocation reason as it is stored with the given signature
      57             :  */
      58             : static void
      59           0 : do_show_revocation_reason( PKT_signature *sig )
      60             : {
      61             :     size_t n, nn;
      62             :     const byte *p, *pp;
      63           0 :     int seq = 0;
      64             :     const char *text;
      65             : 
      66           0 :     while( (p = enum_sig_subpkt (sig->hashed, SIGSUBPKT_REVOC_REASON,
      67             :                                  &n, &seq, NULL )) ) {
      68           0 :         if( !n )
      69           0 :             continue; /* invalid - just skip it */
      70             : 
      71           0 :         if( *p == 0 )
      72           0 :             text = _("No reason specified");
      73           0 :         else if( *p == 0x01 )
      74           0 :             text = _("Key is superseded");
      75           0 :         else if( *p == 0x02 )
      76           0 :             text = _("Key has been compromised");
      77           0 :         else if( *p == 0x03 )
      78           0 :             text = _("Key is no longer used");
      79           0 :         else if( *p == 0x20 )
      80           0 :             text = _("User ID is no longer valid");
      81             :         else
      82           0 :             text = NULL;
      83             : 
      84           0 :         log_info ( _("reason for revocation: "));
      85           0 :         if (text)
      86           0 :           log_printf ("%s\n", text);
      87             :         else
      88           0 :           log_printf ("code=%02x\n", *p );
      89           0 :         n--; p++;
      90           0 :         pp = NULL;
      91             :         do {
      92             :             /* We don't want any empty lines, so skip them */
      93           0 :             while( n && *p == '\n' ) {
      94           0 :                 p++;
      95           0 :                 n--;
      96             :             }
      97           0 :             if( n ) {
      98           0 :                 pp = memchr( p, '\n', n );
      99           0 :                 nn = pp? pp - p : n;
     100           0 :                 log_info ( _("revocation comment: ") );
     101           0 :                 es_write_sanitized (log_get_stream(), p, nn, NULL, NULL);
     102           0 :                 log_printf ("\n");
     103           0 :                 p += nn; n -= nn;
     104             :             }
     105           0 :         } while( pp );
     106             :     }
     107           0 : }
     108             : 
     109             : /* Mode 0: try and find the revocation based on the pk (i.e. check
     110             :    subkeys, etc.)  Mode 1: use only the revocation on the main pk */
     111             : 
     112             : void
     113           0 : show_revocation_reason( PKT_public_key *pk, int mode )
     114             : {
     115             :     /* Hmmm, this is not so easy because we have to duplicate the code
     116             :      * used in the trustbd to calculate the keyflags.  We need to find
     117             :      * a clean way to check revocation certificates on keys and
     118             :      * signatures.  And there should be no duplicate code.  Because we
     119             :      * enter this function only when the trustdb told us that we have
     120             :      * a revoked key, we could simply look for a revocation cert and
     121             :      * display this one, when there is only one. Let's try to do this
     122             :      * until we have a better solution.  */
     123           0 :     KBNODE node, keyblock = NULL;
     124             :     byte fingerprint[MAX_FINGERPRINT_LEN];
     125             :     size_t fingerlen;
     126             :     int rc;
     127             : 
     128             :     /* get the keyblock */
     129           0 :     fingerprint_from_pk( pk, fingerprint, &fingerlen );
     130           0 :     rc = get_pubkey_byfprint(NULL, &keyblock, fingerprint, fingerlen);
     131           0 :     if( rc ) { /* that should never happen */
     132           0 :         log_debug( "failed to get the keyblock\n");
     133           0 :         return;
     134             :     }
     135             : 
     136           0 :     for( node=keyblock; node; node = node->next ) {
     137           0 :         if( (mode && node->pkt->pkttype == PKT_PUBLIC_KEY) ||
     138           0 :           ( ( node->pkt->pkttype == PKT_PUBLIC_KEY
     139           0 :               || node->pkt->pkttype == PKT_PUBLIC_SUBKEY )
     140           0 :             && !cmp_public_keys( node->pkt->pkt.public_key, pk ) ) )
     141             :             break;
     142             :     }
     143           0 :     if( !node ) {
     144           0 :         log_debug("Oops, PK not in keyblock\n");
     145           0 :         release_kbnode( keyblock );
     146           0 :         return;
     147             :     }
     148             :     /* now find the revocation certificate */
     149           0 :     for( node = node->next; node ; node = node->next ) {
     150           0 :         if( node->pkt->pkttype == PKT_PUBLIC_SUBKEY )
     151           0 :             break;
     152           0 :         if( node->pkt->pkttype == PKT_SIGNATURE
     153           0 :             && (node->pkt->pkt.signature->sig_class == 0x20
     154           0 :                 || node->pkt->pkt.signature->sig_class == 0x28 ) ) {
     155             :                 /* FIXME: we should check the signature here */
     156           0 :                 do_show_revocation_reason ( node->pkt->pkt.signature );
     157           0 :                 break;
     158             :         }
     159             :     }
     160             : 
     161             :     /* We didn't find it, so check if the whole key is revoked */
     162           0 :     if(!node && !mode)
     163           0 :       show_revocation_reason(pk,1);
     164             : 
     165           0 :     release_kbnode( keyblock );
     166             : }
     167             : 
     168             : 
     169             : /****************
     170             :  * mode: 0 = standard
     171             :  *       1 = Without key info and additional menu option 'm'
     172             :  *           this does also add an option to set the key to ultimately trusted.
     173             :  * Returns:
     174             :  *      -2 = nothing changed - caller should show some additional info
     175             :  *      -1 = quit operation
     176             :  *       0 = nothing changed
     177             :  *       1 = new ownertrust now in new_trust
     178             :  */
     179             : #ifndef NO_TRUST_MODELS
     180             : static int
     181           0 : do_edit_ownertrust (ctrl_t ctrl, PKT_public_key *pk, int mode,
     182             :                     unsigned *new_trust, int defer_help )
     183             : {
     184             :   char *p;
     185             :   u32 keyid[2];
     186           0 :   int changed=0;
     187           0 :   int quit=0;
     188           0 :   int show=0;
     189             :   int min_num;
     190           0 :   int did_help=defer_help;
     191           0 :   unsigned int minimum = tdb_get_min_ownertrust (pk);
     192             : 
     193           0 :   switch(minimum)
     194             :     {
     195             :     default:
     196           0 :     case TRUST_UNDEFINED: min_num=1; break;
     197           0 :     case TRUST_NEVER:     min_num=2; break;
     198           0 :     case TRUST_MARGINAL:  min_num=3; break;
     199           0 :     case TRUST_FULLY:     min_num=4; break;
     200             :     }
     201             : 
     202           0 :   keyid_from_pk (pk, keyid);
     203             :   for(;;) {
     204             :     /* A string with valid answers.
     205             : 
     206             :        TRANSLATORS: These are the allowed answers in lower and
     207             :        uppercase.  Below you will find the matching strings which
     208             :        should be translated accordingly and the letter changed to
     209             :        match the one in the answer string.
     210             : 
     211             :          i = please show me more information
     212             :          m = back to the main menu
     213             :          s = skip this key
     214             :          q = quit
     215             :     */
     216           0 :     const char *ans = _("iImMqQsS");
     217             : 
     218           0 :     if( !did_help )
     219             :       {
     220           0 :         if( !mode )
     221             :           {
     222             :             KBNODE keyblock, un;
     223             : 
     224           0 :             tty_printf (_("No trust value assigned to:\n"));
     225           0 :             print_key_line (NULL, pk, 0);
     226             : 
     227           0 :             p = get_user_id_native(keyid);
     228           0 :             tty_printf (_("      \"%s\"\n"),p);
     229           0 :             xfree (p);
     230             : 
     231           0 :             keyblock = get_pubkeyblock (keyid);
     232           0 :             if (!keyblock)
     233           0 :                 BUG ();
     234           0 :             for (un=keyblock; un; un = un->next)
     235             :               {
     236           0 :                 if (un->pkt->pkttype != PKT_USER_ID )
     237           0 :                   continue;
     238           0 :                 if (un->pkt->pkt.user_id->is_revoked )
     239           0 :                   continue;
     240           0 :                 if (un->pkt->pkt.user_id->is_expired )
     241           0 :                   continue;
     242             :                 /* Only skip textual primaries */
     243           0 :                 if (un->pkt->pkt.user_id->is_primary
     244           0 :                     && !un->pkt->pkt.user_id->attrib_data )
     245           0 :                   continue;
     246             : 
     247           0 :                 if((opt.verify_options&VERIFY_SHOW_PHOTOS)
     248           0 :                    && un->pkt->pkt.user_id->attrib_data)
     249           0 :                   show_photos (ctrl,
     250           0 :                                un->pkt->pkt.user_id->attribs,
     251           0 :                                un->pkt->pkt.user_id->numattribs, pk,
     252           0 :                                un->pkt->pkt.user_id);
     253             : 
     254           0 :                 p=utf8_to_native(un->pkt->pkt.user_id->name,
     255           0 :                                  un->pkt->pkt.user_id->len,0);
     256             : 
     257           0 :                 tty_printf(_("  aka \"%s\"\n"),p);
     258             :               }
     259             : 
     260           0 :             print_fingerprint (NULL, pk, 2);
     261           0 :             tty_printf("\n");
     262           0 :             release_kbnode (keyblock);
     263             :           }
     264             : 
     265           0 :         if(opt.trust_model==TM_DIRECT)
     266             :           {
     267           0 :             tty_printf(_("How much do you trust that this key actually "
     268             :                          "belongs to the named user?\n"));
     269           0 :             tty_printf("\n");
     270             :           }
     271             :         else
     272             :           {
     273             :             /* This string also used in keyedit.c:trustsig_prompt */
     274           0 :             tty_printf(_("Please decide how far you trust this user to"
     275             :                          " correctly verify other users' keys\n"
     276             :                          "(by looking at passports, checking fingerprints from"
     277             :                          " different sources, etc.)\n"));
     278           0 :             tty_printf("\n");
     279             :           }
     280             : 
     281           0 :         if(min_num<=1)
     282           0 :           tty_printf (_("  %d = I don't know or won't say\n"), 1);
     283           0 :         if(min_num<=2)
     284           0 :           tty_printf (_("  %d = I do NOT trust\n"), 2);
     285           0 :         if(min_num<=3)
     286           0 :           tty_printf (_("  %d = I trust marginally\n"), 3);
     287           0 :         if(min_num<=4)
     288           0 :           tty_printf (_("  %d = I trust fully\n"), 4);
     289           0 :         if (mode)
     290           0 :           tty_printf (_("  %d = I trust ultimately\n"), 5);
     291             : #if 0
     292             :         /* not yet implemented */
     293             :         tty_printf ("  i = please show me more information\n");
     294             : #endif
     295           0 :         if( mode )
     296           0 :           tty_printf(_("  m = back to the main menu\n"));
     297             :         else
     298             :           {
     299           0 :             tty_printf(_("  s = skip this key\n"));
     300           0 :             tty_printf(_("  q = quit\n"));
     301             :           }
     302           0 :         tty_printf("\n");
     303           0 :         if(minimum)
     304           0 :           tty_printf(_("The minimum trust level for this key is: %s\n\n"),
     305             :                      trust_value_to_string(minimum));
     306           0 :         did_help = 1;
     307             :       }
     308           0 :     if( strlen(ans) != 8 )
     309           0 :       BUG();
     310           0 :     p = cpr_get("edit_ownertrust.value",_("Your decision? "));
     311           0 :     trim_spaces(p);
     312           0 :     cpr_kill_prompt();
     313           0 :     if( !*p )
     314           0 :       did_help = 0;
     315           0 :     else if( *p && p[1] )
     316             :       ;
     317           0 :     else if( !p[1] && ((*p >= '0'+min_num) && *p <= (mode?'5':'4')) )
     318           0 :       {
     319             :         unsigned int trust;
     320           0 :         switch( *p )
     321             :           {
     322           0 :           case '1': trust = TRUST_UNDEFINED; break;
     323           0 :           case '2': trust = TRUST_NEVER    ; break;
     324           0 :           case '3': trust = TRUST_MARGINAL ; break;
     325           0 :           case '4': trust = TRUST_FULLY    ; break;
     326           0 :           case '5': trust = TRUST_ULTIMATE ; break;
     327           0 :           default: BUG();
     328             :           }
     329           0 :         if (trust == TRUST_ULTIMATE
     330           0 :             && !cpr_get_answer_is_yes ("edit_ownertrust.set_ultimate.okay",
     331           0 :                                        _("Do you really want to set this key"
     332             :                                          " to ultimate trust? (y/N) ")))
     333             :           ; /* no */
     334             :         else
     335             :           {
     336           0 :             *new_trust = trust;
     337           0 :             changed = 1;
     338           0 :             break;
     339             :           }
     340             :       }
     341             : #if 0
     342             :     /* not yet implemented */
     343             :     else if( *p == ans[0] || *p == ans[1] )
     344             :       {
     345             :         tty_printf(_("Certificates leading to an ultimately trusted key:\n"));
     346             :         show = 1;
     347             :         break;
     348             :       }
     349             : #endif
     350           0 :     else if( mode && (*p == ans[2] || *p == ans[3] || *p == CONTROL_D ) )
     351             :       {
     352             :         break ; /* back to the menu */
     353             :       }
     354           0 :     else if( !mode && (*p == ans[6] || *p == ans[7] ) )
     355             :       {
     356             :         break; /* skip */
     357             :       }
     358           0 :     else if( !mode && (*p == ans[4] || *p == ans[5] ) )
     359             :       {
     360           0 :         quit = 1;
     361           0 :         break ; /* back to the menu */
     362             :       }
     363           0 :     xfree(p); p = NULL;
     364           0 :   }
     365           0 :   xfree(p);
     366           0 :   return show? -2: quit? -1 : changed;
     367             : }
     368             : #endif /*!NO_TRUST_MODELS*/
     369             : 
     370             : 
     371             : /*
     372             :  * Display a menu to change the ownertrust of the key PK (which should
     373             :  * be a primary key).
     374             :  * For mode values see do_edit_ownertrust ()
     375             :  */
     376             : #ifndef NO_TRUST_MODELS
     377             : int
     378           0 : edit_ownertrust (ctrl_t ctrl, PKT_public_key *pk, int mode )
     379             : {
     380           0 :   unsigned int trust = 0;
     381           0 :   int no_help = 0;
     382             : 
     383             :   for(;;)
     384             :     {
     385           0 :       switch ( do_edit_ownertrust (ctrl, pk, mode, &trust, no_help ) )
     386             :         {
     387             :         case -1: /* quit */
     388           0 :           return -1;
     389             :         case -2: /* show info */
     390           0 :           no_help = 1;
     391           0 :           break;
     392             :         case 1: /* trust value set */
     393           0 :           trust &= ~TRUST_FLAG_DISABLED;
     394           0 :           trust |= get_ownertrust (pk) & TRUST_FLAG_DISABLED;
     395           0 :           update_ownertrust (pk, trust );
     396           0 :           return 1;
     397             :         default:
     398           0 :           return 0;
     399             :         }
     400           0 :     }
     401             : }
     402             : #endif /*!NO_TRUST_MODELS*/
     403             : 
     404             : 
     405             : /****************
     406             :  * Check whether we can trust this pk which has a trustlevel of TRUSTLEVEL
     407             :  * Returns: true if we trust.
     408             :  */
     409             : static int
     410         244 : do_we_trust( PKT_public_key *pk, unsigned int trustlevel )
     411             : {
     412             :   /* We should not be able to get here with a revoked or expired
     413             :      key */
     414         244 :   if(trustlevel & TRUST_FLAG_REVOKED
     415         244 :      || trustlevel & TRUST_FLAG_SUB_REVOKED
     416         244 :      || (trustlevel & TRUST_MASK) == TRUST_EXPIRED)
     417           0 :     BUG();
     418             : 
     419         244 :   if( opt.trust_model==TM_ALWAYS )
     420             :     {
     421         244 :       if( opt.verbose )
     422           0 :         log_info("No trust check due to '--trust-model always' option\n");
     423         244 :       return 1;
     424             :     }
     425             : 
     426           0 :   switch(trustlevel & TRUST_MASK)
     427             :     {
     428             :     default:
     429           0 :       log_error ("invalid trustlevel %u returned from validation layer\n",
     430             :                  trustlevel);
     431             :       /* fall thru */
     432             :     case TRUST_UNKNOWN:
     433             :     case TRUST_UNDEFINED:
     434           0 :       log_info(_("%s: There is no assurance this key belongs"
     435             :                  " to the named user\n"),keystr_from_pk(pk));
     436           0 :       return 0; /* no */
     437             : 
     438             :     case TRUST_MARGINAL:
     439           0 :       log_info(_("%s: There is limited assurance this key belongs"
     440             :                  " to the named user\n"),keystr_from_pk(pk));
     441           0 :       return 1; /* yes */
     442             : 
     443             :     case TRUST_FULLY:
     444           0 :       if( opt.verbose )
     445           0 :         log_info(_("This key probably belongs to the named user\n"));
     446           0 :       return 1; /* yes */
     447             : 
     448             :     case TRUST_ULTIMATE:
     449           0 :       if( opt.verbose )
     450           0 :         log_info(_("This key belongs to us\n"));
     451           0 :       return 1; /* yes */
     452             : 
     453             :     case TRUST_NEVER:
     454             :       /* This is retruned can be returned by TOFU, which can return
     455             :          negative assertions.  */
     456           0 :       log_info(_("%s: This key is bad!  It has been marked as untrusted!\n"),
     457             :                keystr_from_pk(pk));
     458           0 :       return 0; /* no */
     459             :     }
     460             : 
     461             :   return 1; /*NOTREACHED*/
     462             : }
     463             : 
     464             : 
     465             : /****************
     466             :  * wrapper around do_we_trust, so we can ask whether to use the
     467             :  * key anyway.
     468             :  */
     469             : static int
     470         244 : do_we_trust_pre( PKT_public_key *pk, unsigned int trustlevel )
     471             : {
     472             :   int rc;
     473             : 
     474         244 :   rc = do_we_trust( pk, trustlevel );
     475             : 
     476         244 :   if( !opt.batch && !rc )
     477             :     {
     478           0 :       print_pubkey_info(NULL,pk);
     479           0 :       print_fingerprint (NULL, pk, 2);
     480           0 :       tty_printf("\n");
     481             : 
     482           0 :       if ((trustlevel & TRUST_MASK) == TRUST_NEVER)
     483           0 :         tty_printf(
     484           0 :           _("This key has is bad!  It has been marked as untrusted!  If you\n"
     485             :             "*really* know what you are doing, you may answer the next\n"
     486             :             "question with yes.\n"));
     487             :       else
     488           0 :         tty_printf(
     489           0 :           _("It is NOT certain that the key belongs to the person named\n"
     490             :             "in the user ID.  If you *really* know what you are doing,\n"
     491             :             "you may answer the next question with yes.\n"));
     492             : 
     493           0 :       tty_printf("\n");
     494             : 
     495             : 
     496           0 :       if (is_status_enabled ())
     497             :         {
     498             :           u32 kid[2];
     499             :           char *hint_str;
     500             : 
     501           0 :           keyid_from_pk (pk, kid);
     502           0 :           hint_str = get_long_user_id_string ( kid );
     503           0 :           write_status_text ( STATUS_USERID_HINT, hint_str );
     504           0 :           xfree (hint_str);
     505             :         }
     506             : 
     507           0 :       if( cpr_get_answer_is_yes("untrusted_key.override",
     508           0 :                                 _("Use this key anyway? (y/N) "))  )
     509           0 :         rc = 1;
     510             : 
     511             :       /* Hmmm: Should we set a flag to tell the user about
     512             :        *         his decision the next time he encrypts for this recipient?
     513             :        */
     514             :     }
     515             : 
     516         244 :   return rc;
     517             : }
     518             : 
     519             : 
     520             : /* Write a TRUST_foo status line inclduing the validation model.  */
     521             : static void
     522           9 : write_trust_status (int statuscode, int trustlevel)
     523             : {
     524             : #ifdef NO_TRUST_MODELS
     525             :   write_status (statuscode);
     526             : #else /* NO_TRUST_MODELS */
     527             :   int tm;
     528             : 
     529             :   /* For the combined tofu+pgp method, we return the trust model which
     530             :    * was responsible for the trustlevel.  */
     531           9 :   if (opt.trust_model == TM_TOFU_PGP)
     532           0 :     tm = (trustlevel & TRUST_FLAG_TOFU_BASED)? TM_TOFU : TM_PGP;
     533             :   else
     534           9 :     tm = opt.trust_model;
     535           9 :   write_status_strings (statuscode, "0 ", trust_model_string (tm), NULL);
     536             : #endif /* NO_TRUST_MODELS */
     537           9 : }
     538             : 
     539             : 
     540             : /****************
     541             :  * Check whether we can trust this signature.
     542             :  * Returns an error code if we should not trust this signature.
     543             :  */
     544             : int
     545         160 : check_signatures_trust (ctrl_t ctrl, PKT_signature *sig)
     546             : {
     547         160 :   PKT_public_key *pk = xmalloc_clear( sizeof *pk );
     548         160 :   unsigned int trustlevel = TRUST_UNKNOWN;
     549         160 :   int rc=0;
     550             : 
     551         160 :   rc = get_pubkey( pk, sig->keyid );
     552         160 :   if (rc)
     553             :     { /* this should not happen */
     554           0 :       log_error("Ooops; the key vanished  - can't check the trust\n");
     555           0 :       rc = GPG_ERR_NO_PUBKEY;
     556           0 :       goto leave;
     557             :     }
     558             : 
     559         160 :   if ( opt.trust_model==TM_ALWAYS )
     560             :     {
     561         151 :       if( !opt.quiet )
     562         151 :         log_info(_("WARNING: Using untrusted key!\n"));
     563         151 :       if (opt.with_fingerprint)
     564           0 :         print_fingerprint (NULL, pk, 1);
     565         151 :       goto leave;
     566             :     }
     567             : 
     568           9 :   if(pk->flags.maybe_revoked && !pk->flags.revoked)
     569           0 :     log_info(_("WARNING: this key might be revoked (revocation key"
     570             :                " not present)\n"));
     571             : 
     572           9 :   trustlevel = get_validity (ctrl, pk, NULL, sig, 1);
     573             : 
     574           9 :   if ( (trustlevel & TRUST_FLAG_REVOKED) )
     575             :     {
     576           0 :       write_status( STATUS_KEYREVOKED );
     577           0 :       if(pk->flags.revoked == 2)
     578           0 :         log_info(_("WARNING: This key has been revoked by its"
     579             :                    " designated revoker!\n"));
     580             :       else
     581           0 :         log_info(_("WARNING: This key has been revoked by its owner!\n"));
     582           0 :       log_info(_("         This could mean that the signature is forged.\n"));
     583           0 :       show_revocation_reason( pk, 0 );
     584             :     }
     585           9 :   else if ((trustlevel & TRUST_FLAG_SUB_REVOKED) )
     586             :     {
     587           0 :       write_status( STATUS_KEYREVOKED );
     588           0 :       log_info(_("WARNING: This subkey has been revoked by its owner!\n"));
     589           0 :       show_revocation_reason( pk, 0 );
     590             :     }
     591             : 
     592           9 :   if ((trustlevel & TRUST_FLAG_DISABLED))
     593           0 :     log_info (_("Note: This key has been disabled.\n"));
     594             : 
     595             :   /* If we have PKA information adjust the trustlevel. */
     596           9 :   if (sig->pka_info && sig->pka_info->valid)
     597             :     {
     598             :       unsigned char fpr[MAX_FINGERPRINT_LEN];
     599             :       PKT_public_key *primary_pk;
     600             :       size_t fprlen;
     601             :       int okay;
     602             : 
     603             : 
     604           0 :       primary_pk = xmalloc_clear (sizeof *primary_pk);
     605           0 :       get_pubkey (primary_pk, pk->main_keyid);
     606           0 :       fingerprint_from_pk (primary_pk, fpr, &fprlen);
     607           0 :       free_public_key (primary_pk);
     608             : 
     609           0 :       if ( fprlen == 20 && !memcmp (sig->pka_info->fpr, fpr, 20) )
     610             :         {
     611           0 :           okay = 1;
     612           0 :           write_status_text (STATUS_PKA_TRUST_GOOD, sig->pka_info->email);
     613           0 :           log_info (_("Note: Verified signer's address is '%s'\n"),
     614           0 :                     sig->pka_info->email);
     615             :         }
     616             :       else
     617             :         {
     618           0 :           okay = 0;
     619           0 :           write_status_text (STATUS_PKA_TRUST_BAD, sig->pka_info->email);
     620           0 :           log_info (_("Note: Signer's address '%s' "
     621           0 :                       "does not match DNS entry\n"), sig->pka_info->email);
     622             :         }
     623             : 
     624           0 :       switch ( (trustlevel & TRUST_MASK) )
     625             :         {
     626             :         case TRUST_UNKNOWN:
     627             :         case TRUST_UNDEFINED:
     628             :         case TRUST_MARGINAL:
     629           0 :           if (okay && opt.verify_options&VERIFY_PKA_TRUST_INCREASE)
     630             :             {
     631           0 :               trustlevel = ((trustlevel & ~TRUST_MASK) | TRUST_FULLY);
     632           0 :               log_info (_("trustlevel adjusted to FULL"
     633             :                           " due to valid PKA info\n"));
     634             :             }
     635             :           /* (fall through) */
     636             :         case TRUST_FULLY:
     637           0 :           if (!okay)
     638             :             {
     639           0 :               trustlevel = ((trustlevel & ~TRUST_MASK) | TRUST_NEVER);
     640           0 :               log_info (_("trustlevel adjusted to NEVER"
     641             :                           " due to bad PKA info\n"));
     642             :             }
     643           0 :           break;
     644             :         }
     645             :     }
     646             : 
     647             :   /* Now let the user know what up with the trustlevel. */
     648           9 :   switch ( (trustlevel & TRUST_MASK) )
     649             :     {
     650             :     case TRUST_EXPIRED:
     651           0 :       log_info(_("Note: This key has expired!\n"));
     652           0 :       print_fingerprint (NULL, pk, 1);
     653           0 :       break;
     654             : 
     655             :     default:
     656           0 :       log_error ("invalid trustlevel %u returned from validation layer\n",
     657             :                  trustlevel);
     658             :       /* fall thru */
     659             :     case TRUST_UNKNOWN:
     660             :     case TRUST_UNDEFINED:
     661           8 :       write_trust_status (STATUS_TRUST_UNDEFINED, trustlevel);
     662           8 :       log_info(_("WARNING: This key is not certified with"
     663             :                  " a trusted signature!\n"));
     664           8 :       log_info(_("         There is no indication that the "
     665             :                  "signature belongs to the owner.\n" ));
     666           8 :       print_fingerprint (NULL, pk, 1);
     667           8 :       break;
     668             : 
     669             :     case TRUST_NEVER:
     670             :       /* This level can be returned by TOFU, which supports negative
     671             :        * assertions.  */
     672           0 :       write_trust_status (STATUS_TRUST_NEVER, trustlevel);
     673           0 :       log_info(_("WARNING: We do NOT trust this key!\n"));
     674           0 :       log_info(_("         The signature is probably a FORGERY.\n"));
     675           0 :       if (opt.with_fingerprint)
     676           0 :         print_fingerprint (NULL, pk, 1);
     677           0 :       rc = gpg_error (GPG_ERR_BAD_SIGNATURE);
     678           0 :       break;
     679             : 
     680             :     case TRUST_MARGINAL:
     681           1 :       write_trust_status (STATUS_TRUST_MARGINAL, trustlevel);
     682           1 :       log_info(_("WARNING: This key is not certified with"
     683             :                  " sufficiently trusted signatures!\n"));
     684           1 :       log_info(_("         It is not certain that the"
     685             :                  " signature belongs to the owner.\n" ));
     686           1 :       print_fingerprint (NULL, pk, 1);
     687           1 :       break;
     688             : 
     689             :     case TRUST_FULLY:
     690           0 :       write_trust_status (STATUS_TRUST_FULLY, trustlevel);
     691           0 :       if (opt.with_fingerprint)
     692           0 :         print_fingerprint (NULL, pk, 1);
     693           0 :       break;
     694             : 
     695             :     case TRUST_ULTIMATE:
     696           0 :       write_trust_status (STATUS_TRUST_ULTIMATE, trustlevel);
     697           0 :       if (opt.with_fingerprint)
     698           0 :         print_fingerprint (NULL, pk, 1);
     699           0 :       break;
     700             :     }
     701             : 
     702             :  leave:
     703         160 :   free_public_key( pk );
     704         160 :   return rc;
     705             : }
     706             : 
     707             : 
     708             : void
     709         333 : release_pk_list (pk_list_t pk_list)
     710             : {
     711             :   PK_LIST pk_rover;
     712             : 
     713         588 :   for ( ; pk_list; pk_list = pk_rover)
     714             :     {
     715         255 :       pk_rover = pk_list->next;
     716         255 :       free_public_key ( pk_list->pk );
     717         255 :       xfree ( pk_list );
     718             :     }
     719         333 : }
     720             : 
     721             : 
     722             : static int
     723         250 : key_present_in_pk_list(PK_LIST pk_list, PKT_public_key *pk)
     724             : {
     725         258 :     for( ; pk_list; pk_list = pk_list->next)
     726           8 :         if (cmp_public_keys(pk_list->pk, pk) == 0)
     727           0 :             return 0;
     728             : 
     729         250 :     return -1;
     730             : }
     731             : 
     732             : 
     733             : /****************
     734             :  * Return a malloced string with a default recipient if there is any
     735             :  */
     736             : static char *
     737           0 : default_recipient(ctrl_t ctrl)
     738             : {
     739             :     PKT_public_key *pk;
     740             :     byte fpr[MAX_FINGERPRINT_LEN+1];
     741             :     size_t n;
     742             :     char *p;
     743             :     int i;
     744             : 
     745           0 :     if( opt.def_recipient )
     746           0 :         return xstrdup( opt.def_recipient );
     747           0 :     if( !opt.def_recipient_self )
     748           0 :         return NULL;
     749           0 :     pk = xmalloc_clear( sizeof *pk );
     750           0 :     i = get_seckey_default (ctrl, pk);
     751           0 :     if( i ) {
     752           0 :         free_public_key( pk );
     753           0 :         return NULL;
     754             :     }
     755           0 :     n = MAX_FINGERPRINT_LEN;
     756           0 :     fingerprint_from_pk( pk, fpr, &n );
     757           0 :     free_public_key( pk );
     758           0 :     p = xmalloc( 2*n+3 );
     759           0 :     *p++ = '0';
     760           0 :     *p++ = 'x';
     761           0 :     for(i=0; i < n; i++ )
     762           0 :         sprintf( p+2*i, "%02X", fpr[i] );
     763           0 :     p -= 2;
     764           0 :     return p;
     765             : }
     766             : 
     767             : static int
     768           0 : expand_id(const char *id,strlist_t *into,unsigned int flags)
     769             : {
     770             :   struct groupitem *groups;
     771           0 :   int count=0;
     772             : 
     773           0 :   for(groups=opt.grouplist;groups;groups=groups->next)
     774             :     {
     775             :       /* need strcasecmp() here, as this should be localized */
     776           0 :       if(strcasecmp(groups->name,id)==0)
     777             :         {
     778             :           strlist_t each,sl;
     779             : 
     780             :           /* this maintains the current utf8-ness */
     781           0 :           for(each=groups->values;each;each=each->next)
     782             :             {
     783           0 :               sl=add_to_strlist(into,each->d);
     784           0 :               sl->flags=flags;
     785           0 :               count++;
     786             :             }
     787             : 
     788           0 :           break;
     789             :         }
     790             :     }
     791             : 
     792           0 :   return count;
     793             : }
     794             : 
     795             : /* For simplicity, and to avoid potential loops, we only expand once -
     796             :  * you can't make an alias that points to an alias.  */
     797             : static strlist_t
     798           0 : expand_group (strlist_t input)
     799             : {
     800           0 :   strlist_t output = NULL;
     801             :   strlist_t sl, rover;
     802             : 
     803           0 :   for (rover = input; rover; rover = rover->next)
     804           0 :     if (!(rover->flags & PK_LIST_FROM_FILE)
     805           0 :         && !expand_id(rover->d,&output,rover->flags))
     806             :       {
     807             :         /* Didn't find any groups, so use the existing string */
     808           0 :         sl=add_to_strlist(&output,rover->d);
     809           0 :         sl->flags=rover->flags;
     810             :       }
     811             : 
     812           0 :   return output;
     813             : }
     814             : 
     815             : 
     816             : /* Helper for build_pk_list to find and check one key.  This helper is
     817             :  * also used directly in server mode by the RECIPIENTS command.  On
     818             :  * success the new key is added to PK_LIST_ADDR.  NAME is the user id
     819             :  * of the key.  USE the requested usage and a set MARK_HIDDEN will
     820             :  * mark the key in the updated list as a hidden recipient.  If
     821             :  * FROM_FILE is true, NAME is is not a user ID but the name of a file
     822             :  * holding a key. */
     823             : gpg_error_t
     824         250 : find_and_check_key (ctrl_t ctrl, const char *name, unsigned int use,
     825             :                     int mark_hidden, int from_file, pk_list_t *pk_list_addr)
     826             : {
     827             :   int rc;
     828             :   PKT_public_key *pk;
     829             : 
     830         250 :   if (!name || !*name)
     831           0 :     return gpg_error (GPG_ERR_INV_USER_ID);
     832             : 
     833         250 :   pk = xtrycalloc (1, sizeof *pk);
     834         250 :   if (!pk)
     835           0 :     return gpg_error_from_syserror ();
     836         250 :   pk->req_usage = use;
     837             : 
     838         250 :   if (from_file)
     839           6 :     rc = get_pubkey_fromfile (ctrl, pk, name);
     840             :   else
     841         244 :     rc = get_pubkey_byname (ctrl, NULL, pk, name, NULL, NULL, 0, 0);
     842         250 :   if (rc)
     843             :     {
     844             :       int code;
     845             : 
     846             :       /* Key not found or other error. */
     847           0 :       log_error (_("%s: skipped: %s\n"), name, gpg_strerror (rc) );
     848           0 :       switch (gpg_err_code (rc))
     849             :         {
     850             :         case GPG_ERR_NO_SECKEY:
     851           0 :         case GPG_ERR_NO_PUBKEY:   code =  1; break;
     852           0 :         case GPG_ERR_INV_USER_ID: code = 14; break;
     853           0 :         default: code = 0; break;
     854             :         }
     855           0 :       send_status_inv_recp (code, name);
     856           0 :       free_public_key (pk);
     857           0 :       return rc;
     858             :     }
     859             : 
     860         250 :   rc = openpgp_pk_test_algo2 (pk->pubkey_algo, use);
     861         250 :   if (rc)
     862             :     {
     863             :       /* Key found but not usable for us (e.g. sign-only key). */
     864           0 :       send_status_inv_recp (3, name); /* Wrong key usage */
     865           0 :       log_error (_("%s: skipped: %s\n"), name, gpg_strerror (rc) );
     866           0 :       free_public_key (pk);
     867           0 :       return rc;
     868             :     }
     869             : 
     870             :   /* Key found and usable.  Check validity. */
     871         250 :   if (!from_file)
     872             :     {
     873             :       int trustlevel;
     874             : 
     875         244 :       trustlevel = get_validity (ctrl, pk, pk->user_id, NULL, 1);
     876         244 :       if ( (trustlevel & TRUST_FLAG_DISABLED) )
     877             :         {
     878             :           /* Key has been disabled. */
     879           0 :           send_status_inv_recp (13, name);
     880           0 :           log_info (_("%s: skipped: public key is disabled\n"), name);
     881           0 :           free_public_key (pk);
     882           0 :           return GPG_ERR_UNUSABLE_PUBKEY;
     883             :         }
     884             : 
     885         244 :       if ( !do_we_trust_pre (pk, trustlevel) )
     886             :         {
     887             :           /* We don't trust this key.  */
     888           0 :           send_status_inv_recp (10, name);
     889           0 :           free_public_key (pk);
     890           0 :           return GPG_ERR_UNUSABLE_PUBKEY;
     891             :         }
     892             :     }
     893             : 
     894             :   /* Skip the actual key if the key is already present in the
     895             :      list.  */
     896         250 :   if (!key_present_in_pk_list (*pk_list_addr, pk))
     897             :     {
     898           0 :       if (!opt.quiet)
     899           0 :         log_info (_("%s: skipped: public key already present\n"), name);
     900           0 :       free_public_key (pk);
     901             :     }
     902             :   else
     903             :     {
     904             :       pk_list_t r;
     905             : 
     906         250 :       r = xtrymalloc (sizeof *r);
     907         250 :       if (!r)
     908             :         {
     909           0 :           rc = gpg_error_from_syserror ();
     910           0 :           free_public_key (pk);
     911           0 :           return rc;
     912             :         }
     913         250 :       r->pk = pk;
     914         250 :       r->next = *pk_list_addr;
     915         250 :       r->flags = mark_hidden? 1:0;
     916         250 :       *pk_list_addr = r;
     917             :     }
     918             : 
     919         250 :   return 0;
     920             : }
     921             : 
     922             : 
     923             : 
     924             : /* This is the central function to collect the keys for recipients.
     925             :  * It is thus used to prepare a public key encryption. encrypt-to
     926             :  * keys, default keys and the keys for the actual recipients are all
     927             :  * collected here.  When not in batch mode and no recipient has been
     928             :  * passed on the commandline, the function will also ask for
     929             :  * recipients.
     930             :  *
     931             :  * RCPTS is a string list with the recipients; NULL is an allowed
     932             :  * value but not very useful.  Group expansion is done on these names;
     933             :  * they may be in any of the user Id formats we can handle.  The flags
     934             :  * bits for each string in the string list are used for:
     935             :  *
     936             :  * - PK_LIST_ENCRYPT_TO :: This is an encrypt-to recipient.
     937             :  * - PK_LIST_HIDDEN     :: This is a hidden recipient.
     938             :  * - PK_LIST_FROM_FILE  :: The argument is a file with a key.
     939             :  *
     940             :  * On success a list of keys is stored at the address RET_PK_LIST; the
     941             :  * caller must free this list.  On error the value at this address is
     942             :  * not changed.
     943             :  */
     944             : int
     945         247 : build_pk_list (ctrl_t ctrl, strlist_t rcpts, PK_LIST *ret_pk_list)
     946             : {
     947         247 :   PK_LIST pk_list = NULL;
     948         247 :   PKT_public_key *pk=NULL;
     949         247 :   int rc=0;
     950         247 :   int any_recipients=0;
     951             :   strlist_t rov,remusr;
     952         247 :   char *def_rec = NULL;
     953             :   char pkstrbuf[PUBKEY_STRING_SIZE];
     954             : 
     955             :   /* Try to expand groups if any have been defined. */
     956         247 :   if (opt.grouplist)
     957           0 :     remusr = expand_group (rcpts);
     958             :   else
     959         247 :     remusr = rcpts;
     960             : 
     961             :   /* XXX: Change this function to use get_pubkeys instead of
     962             :      get_pubkey_byname to detect ambiguous key specifications and warn
     963             :      about duplicate keyblocks.  For ambiguous key specifications on
     964             :      the command line or provided interactively, prompt the user to
     965             :      select the best key.  If a key specification is ambiguous and we
     966             :      are in batch mode, die.  */
     967             : 
     968         247 :   if (opt.encrypt_to_default_key)
     969             :     {
     970             :       static int warned;
     971             : 
     972           5 :       const char *default_key = parse_def_secret_key (ctrl);
     973           5 :       if (default_key)
     974             :         {
     975           5 :           PK_LIST r = xmalloc_clear (sizeof *r);
     976             : 
     977           5 :           r->pk = xmalloc_clear (sizeof *r->pk);
     978           5 :           r->pk->req_usage = PUBKEY_USAGE_ENC;
     979             : 
     980           5 :           rc = get_pubkey_byname (ctrl, NULL, r->pk, default_key,
     981             :                                    NULL, NULL, 0, 1);
     982           5 :           if (rc)
     983             :             {
     984           0 :               xfree (r->pk);
     985           0 :               xfree (r);
     986             : 
     987           0 :               log_error (_("can't encrypt to '%s'\n"), default_key);
     988           0 :               if (!opt.quiet)
     989           0 :                 log_info (_("(check argument of option '%s')\n"),
     990             :                           "--default-key");
     991             :             }
     992             :           else
     993             :             {
     994           5 :               r->next = pk_list;
     995           5 :               r->flags = 0;
     996           5 :               pk_list = r;
     997             :             }
     998             :         }
     999           0 :       else if (opt.def_secret_key)
    1000             :         {
    1001           0 :           if (! warned)
    1002           0 :             log_info (_("option '%s' given, but no valid default keys given\n"),
    1003             :                       "--encrypt-to-default-key");
    1004           0 :           warned = 1;
    1005             :         }
    1006             :       else
    1007             :         {
    1008           0 :           if (! warned)
    1009           0 :             log_info (_("option '%s' given, but option '%s' not given\n"),
    1010             :                       "--encrypt-to-default-key", "--default-key");
    1011           0 :           warned = 1;
    1012             :         }
    1013             :     }
    1014             : 
    1015             :   /* Check whether there are any recipients in the list and build the
    1016             :    * list of the encrypt-to ones (we always trust them). */
    1017         497 :   for ( rov = remusr; rov; rov = rov->next )
    1018             :     {
    1019         250 :       if ( !(rov->flags & PK_LIST_ENCRYPT_TO) )
    1020             :         {
    1021             :           /* This is a regular recipient; i.e. not an encrypt-to
    1022             :              one. */
    1023         250 :           any_recipients = 1;
    1024             : 
    1025             :           /* Hidden recipients are not allowed while in PGP mode,
    1026             :              issue a warning and switch into GnuPG mode. */
    1027         250 :           if ((rov->flags & PK_LIST_HIDDEN) && (PGP6 || PGP7 || PGP8))
    1028             :             {
    1029           0 :               log_info(_("you may not use %s while in %s mode\n"),
    1030             :                        "--hidden-recipient",
    1031             :                        compliance_option_string());
    1032             : 
    1033           0 :               compliance_failure();
    1034             :             }
    1035             :         }
    1036           0 :       else if (!opt.no_encrypt_to)
    1037             :         {
    1038             :           /* --encrypt-to has not been disabled.  Check this
    1039             :              encrypt-to key. */
    1040           0 :           pk = xmalloc_clear( sizeof *pk );
    1041           0 :           pk->req_usage = PUBKEY_USAGE_ENC;
    1042             : 
    1043             :           /* We explicitly allow encrypt-to to an disabled key; thus
    1044             :              we pass 1 for the second last argument and 1 as the last
    1045             :              argument to disable AKL. */
    1046           0 :           if ( (rc = get_pubkey_byname (ctrl,
    1047           0 :                                         NULL, pk, rov->d, NULL, NULL, 1, 1)) )
    1048             :             {
    1049           0 :               free_public_key ( pk ); pk = NULL;
    1050           0 :               log_error (_("%s: skipped: %s\n"), rov->d, gpg_strerror (rc) );
    1051           0 :               send_status_inv_recp (0, rov->d);
    1052           0 :               goto fail;
    1053             :             }
    1054           0 :           else if ( !(rc=openpgp_pk_test_algo2 (pk->pubkey_algo,
    1055             :                                                 PUBKEY_USAGE_ENC)) )
    1056             :             {
    1057             :               /* Skip the actual key if the key is already present
    1058             :                * in the list.  Add it to our list if not. */
    1059           0 :               if (key_present_in_pk_list(pk_list, pk) == 0)
    1060             :                 {
    1061           0 :                   free_public_key (pk); pk = NULL;
    1062           0 :                   if (!opt.quiet)
    1063           0 :                     log_info (_("%s: skipped: public key already present\n"),
    1064           0 :                               rov->d);
    1065             :                 }
    1066             :               else
    1067             :                 {
    1068             :                   PK_LIST r;
    1069           0 :                   r = xmalloc( sizeof *r );
    1070           0 :                   r->pk = pk; pk = NULL;
    1071           0 :                   r->next = pk_list;
    1072           0 :                   r->flags = (rov->flags&PK_LIST_HIDDEN)?1:0;
    1073           0 :                   pk_list = r;
    1074             : 
    1075             :                   /* Hidden encrypt-to recipients are not allowed while
    1076             :                      in PGP mode, issue a warning and switch into
    1077             :                      GnuPG mode. */
    1078           0 :                   if ((r->flags&PK_LIST_ENCRYPT_TO) && (PGP6 || PGP7 || PGP8))
    1079             :                     {
    1080           0 :                       log_info(_("you may not use %s while in %s mode\n"),
    1081             :                                "--hidden-encrypt-to",
    1082             :                                compliance_option_string());
    1083             : 
    1084           0 :                       compliance_failure();
    1085             :                     }
    1086             :                 }
    1087             :             }
    1088             :           else
    1089             :             {
    1090             :               /* The public key is not usable for encryption. */
    1091           0 :               free_public_key( pk ); pk = NULL;
    1092           0 :               log_error(_("%s: skipped: %s\n"), rov->d, gpg_strerror (rc) );
    1093           0 :               send_status_inv_recp (3, rov->d); /* Wrong key usage */
    1094           0 :               goto fail;
    1095             :             }
    1096             :         }
    1097             :     }
    1098             : 
    1099             :   /* If we don't have any recipients yet and we are not in batch mode
    1100             :      drop into interactive selection mode. */
    1101         247 :   if ( !any_recipients && !opt.batch )
    1102           0 :     {
    1103             :       int have_def_rec;
    1104           0 :       char *answer = NULL;
    1105           0 :       strlist_t backlog = NULL;
    1106             : 
    1107           0 :       if (pk_list)
    1108           0 :         any_recipients = 1;
    1109           0 :       def_rec = default_recipient(ctrl);
    1110           0 :       have_def_rec = !!def_rec;
    1111           0 :       if ( !have_def_rec )
    1112           0 :         tty_printf(_("You did not specify a user ID. (you may use \"-r\")\n"));
    1113             : 
    1114             :       for (;;)
    1115             :         {
    1116           0 :           rc = 0;
    1117           0 :           xfree(answer);
    1118           0 :           if ( have_def_rec )
    1119             :             {
    1120             :               /* A default recipient is taken as the first entry. */
    1121           0 :               answer = def_rec;
    1122           0 :               def_rec = NULL;
    1123             :             }
    1124           0 :           else if (backlog)
    1125             :             {
    1126             :               /* This is part of our trick to expand and display groups. */
    1127           0 :               answer = strlist_pop (&backlog);
    1128             :             }
    1129             :           else
    1130             :             {
    1131             :               /* Show the list of already collected recipients and ask
    1132             :                  for more. */
    1133             :               PK_LIST iter;
    1134             : 
    1135           0 :               tty_printf("\n");
    1136           0 :               tty_printf(_("Current recipients:\n"));
    1137           0 :               for (iter=pk_list;iter;iter=iter->next)
    1138             :                 {
    1139             :                   u32 keyid[2];
    1140             : 
    1141           0 :                   keyid_from_pk(iter->pk,keyid);
    1142           0 :                   tty_printf ("%s/%s %s \"",
    1143             :                               pubkey_string (iter->pk,
    1144             :                                              pkstrbuf, sizeof pkstrbuf),
    1145             :                               keystr(keyid),
    1146             :                               datestr_from_pk (iter->pk));
    1147             : 
    1148           0 :                   if (iter->pk->user_id)
    1149           0 :                     tty_print_utf8_string(iter->pk->user_id->name,
    1150           0 :                                           iter->pk->user_id->len);
    1151             :                   else
    1152             :                     {
    1153             :                       size_t n;
    1154           0 :                       char *p = get_user_id( keyid, &n );
    1155           0 :                       tty_print_utf8_string( p, n );
    1156           0 :                       xfree(p);
    1157             :                     }
    1158           0 :                   tty_printf("\"\n");
    1159             :                 }
    1160             : 
    1161           0 :               answer = cpr_get_utf8("pklist.user_id.enter",
    1162           0 :                                     _("\nEnter the user ID.  "
    1163             :                                       "End with an empty line: "));
    1164           0 :               trim_spaces(answer);
    1165           0 :               cpr_kill_prompt();
    1166             :             }
    1167             : 
    1168           0 :           if ( !answer || !*answer )
    1169             :             {
    1170           0 :               xfree(answer);
    1171           0 :               break;  /* No more recipients entered - get out of loop. */
    1172             :             }
    1173             : 
    1174             :           /* Do group expand here too.  The trick here is to continue
    1175             :              the loop if any expansion occurred.  The code above will
    1176             :              then list all expanded keys. */
    1177           0 :           if (expand_id(answer,&backlog,0))
    1178           0 :             continue;
    1179             : 
    1180             :           /* Get and check key for the current name. */
    1181           0 :           free_public_key (pk);
    1182           0 :           pk = xmalloc_clear( sizeof *pk );
    1183           0 :           pk->req_usage = PUBKEY_USAGE_ENC;
    1184           0 :           rc = get_pubkey_byname (ctrl, NULL, pk, answer, NULL, NULL, 0, 0 );
    1185           0 :           if (rc)
    1186           0 :             tty_printf(_("No such user ID.\n"));
    1187           0 :           else if ( !(rc=openpgp_pk_test_algo2 (pk->pubkey_algo,
    1188             :                                                 PUBKEY_USAGE_ENC)) )
    1189             :             {
    1190           0 :               if ( have_def_rec )
    1191             :                 {
    1192             :                   /* No validation for a default recipient. */
    1193           0 :                   if (!key_present_in_pk_list(pk_list, pk))
    1194             :                     {
    1195           0 :                       free_public_key (pk);
    1196           0 :                       pk = NULL;
    1197           0 :                       log_info (_("skipped: public key "
    1198             :                                   "already set as default recipient\n") );
    1199             :                     }
    1200             :                   else
    1201             :                     {
    1202           0 :                       PK_LIST r = xmalloc (sizeof *r);
    1203           0 :                       r->pk = pk; pk = NULL;
    1204           0 :                       r->next = pk_list;
    1205           0 :                       r->flags = 0; /* No throwing default ids. */
    1206           0 :                       pk_list = r;
    1207             :                     }
    1208           0 :                   any_recipients = 1;
    1209           0 :                   continue;
    1210             :                 }
    1211             :               else
    1212             :                 { /* Check validity of this key. */
    1213             :                   int trustlevel;
    1214             : 
    1215           0 :                   trustlevel = get_validity (ctrl, pk, pk->user_id, NULL, 1);
    1216           0 :                   if ( (trustlevel & TRUST_FLAG_DISABLED) )
    1217             :                     {
    1218           0 :                       tty_printf (_("Public key is disabled.\n") );
    1219             :                     }
    1220           0 :                   else if ( do_we_trust_pre (pk, trustlevel) )
    1221             :                     {
    1222             :                       /* Skip the actual key if the key is already
    1223             :                        * present in the list */
    1224           0 :                       if (!key_present_in_pk_list(pk_list, pk))
    1225             :                         {
    1226           0 :                           free_public_key (pk);
    1227           0 :                           pk = NULL;
    1228           0 :                           log_info(_("skipped: public key already set\n") );
    1229             :                         }
    1230             :                       else
    1231             :                         {
    1232             :                           PK_LIST r;
    1233           0 :                           r = xmalloc( sizeof *r );
    1234           0 :                           r->pk = pk; pk = NULL;
    1235           0 :                           r->next = pk_list;
    1236           0 :                           r->flags = 0; /* No throwing interactive ids. */
    1237           0 :                           pk_list = r;
    1238             :                         }
    1239           0 :                       any_recipients = 1;
    1240           0 :                       continue;
    1241             :                     }
    1242             :                 }
    1243             :             }
    1244           0 :           xfree(def_rec); def_rec = NULL;
    1245           0 :           have_def_rec = 0;
    1246           0 :         }
    1247           0 :       if ( pk )
    1248             :         {
    1249           0 :           free_public_key( pk );
    1250           0 :           pk = NULL;
    1251             :         }
    1252             :     }
    1253         247 :   else if ( !any_recipients && (def_rec = default_recipient(ctrl)) )
    1254             :     {
    1255             :       /* We are in batch mode and have only a default recipient. */
    1256           0 :       pk = xmalloc_clear( sizeof *pk );
    1257           0 :       pk->req_usage = PUBKEY_USAGE_ENC;
    1258             : 
    1259             :       /* The default recipient is allowed to be disabled; thus pass 1
    1260             :          as second last argument.  We also don't want an AKL. */
    1261           0 :       rc = get_pubkey_byname (ctrl, NULL, pk, def_rec, NULL, NULL, 1, 1);
    1262           0 :       if (rc)
    1263           0 :         log_error(_("unknown default recipient \"%s\"\n"), def_rec );
    1264           0 :       else if ( !(rc=openpgp_pk_test_algo2(pk->pubkey_algo,
    1265             :                                            PUBKEY_USAGE_ENC)) )
    1266             :         {
    1267             :           /* Mark any_recipients here since the default recipient
    1268             :              would have been used if it wasn't already there.  It
    1269             :              doesn't really matter if we got this key from the default
    1270             :              recipient or an encrypt-to. */
    1271           0 :           any_recipients = 1;
    1272           0 :           if (!key_present_in_pk_list(pk_list, pk))
    1273           0 :             log_info (_("skipped: public key already set "
    1274             :                         "as default recipient\n"));
    1275             :           else
    1276             :             {
    1277           0 :               PK_LIST r = xmalloc( sizeof *r );
    1278           0 :               r->pk = pk; pk = NULL;
    1279           0 :               r->next = pk_list;
    1280           0 :               r->flags = 0; /* No throwing default ids. */
    1281           0 :               pk_list = r;
    1282             :             }
    1283             :         }
    1284           0 :       if ( pk )
    1285             :         {
    1286           0 :           free_public_key( pk );
    1287           0 :           pk = NULL;
    1288             :         }
    1289           0 :       xfree(def_rec); def_rec = NULL;
    1290             :     }
    1291             :   else
    1292             :     {
    1293             :       /* General case: Check all keys. */
    1294         247 :       any_recipients = 0;
    1295         497 :       for (; remusr; remusr = remusr->next )
    1296             :         {
    1297         250 :           if ( (remusr->flags & PK_LIST_ENCRYPT_TO) )
    1298           0 :             continue; /* encrypt-to keys are already handled. */
    1299             : 
    1300         500 :           rc = find_and_check_key (ctrl, remusr->d, PUBKEY_USAGE_ENC,
    1301         250 :                                    !!(remusr->flags&PK_LIST_HIDDEN),
    1302         250 :                                    !!(remusr->flags&PK_LIST_FROM_FILE),
    1303             :                                    &pk_list);
    1304         250 :           if (rc)
    1305           0 :             goto fail;
    1306         250 :           any_recipients = 1;
    1307             :         }
    1308             :     }
    1309             : 
    1310         247 :   if ( !rc && !any_recipients )
    1311             :     {
    1312           0 :       log_error(_("no valid addressees\n"));
    1313           0 :       write_status_text (STATUS_NO_RECP, "0");
    1314           0 :       rc = GPG_ERR_NO_USER_ID;
    1315             :     }
    1316             : 
    1317             : #ifdef USE_TOFU
    1318         247 :   if (! rc && (opt.trust_model == TM_TOFU_PGP || opt.trust_model == TM_TOFU))
    1319             :     {
    1320             :       PK_LIST iter;
    1321           0 :       for (iter = pk_list; iter; iter = iter->next)
    1322             :         {
    1323             :           int rc2;
    1324             : 
    1325             :           /* Note: we already resolved any conflict when looking up
    1326             :              the key.  Don't annoy the user again if she selected
    1327             :              accept once.  */
    1328           0 :           rc2 = tofu_register_encryption (ctrl, iter->pk, NULL, 0);
    1329           0 :           if (rc2)
    1330           0 :             log_info ("WARNING: Failed to register encryption to %s"
    1331             :                       " with TOFU engine\n",
    1332             :                       keystr (pk_main_keyid (iter->pk)));
    1333           0 :           else if (DBG_TRUST)
    1334           0 :             log_debug ("Registered encryption to %s with TOFU DB.\n",
    1335             :                       keystr (pk_main_keyid (iter->pk)));
    1336             :         }
    1337             :     }
    1338             : #endif /*USE_TOFU*/
    1339             : 
    1340             :  fail:
    1341             : 
    1342         247 :   if ( rc )
    1343           0 :     release_pk_list( pk_list );
    1344             :   else
    1345         247 :     *ret_pk_list = pk_list;
    1346         247 :   if (opt.grouplist)
    1347           0 :     free_strlist(remusr);
    1348         247 :   return rc;
    1349             : }
    1350             : 
    1351             : 
    1352             : /* In pgp6 mode, disallow all ciphers except IDEA (1), 3DES (2), and
    1353             :    CAST5 (3), all hashes except MD5 (1), SHA1 (2), and RIPEMD160 (3),
    1354             :    and all compressions except none (0) and ZIP (1).  pgp7 and pgp8
    1355             :    mode expands the cipher list to include AES128 (7), AES192 (8),
    1356             :    AES256 (9), and TWOFISH (10).  pgp8 adds the SHA-256 hash (8).  For
    1357             :    a true PGP key all of this is unneeded as they are the only items
    1358             :    present in the preferences subpacket, but checking here covers the
    1359             :    weird case of encrypting to a key that had preferences from a
    1360             :    different implementation which was then used with PGP.  I am not
    1361             :    completely comfortable with this as the right thing to do, as it
    1362             :    slightly alters the list of what the user is supposedly requesting.
    1363             :    It is not against the RFC however, as the preference chosen will
    1364             :    never be one that the user didn't specify somewhere ("The
    1365             :    implementation may use any mechanism to pick an algorithm in the
    1366             :    intersection"), and PGP has no mechanism to fix such a broken
    1367             :    preference list, so I'm including it. -dms */
    1368             : 
    1369             : int
    1370        2259 : algo_available( preftype_t preftype, int algo, const union pref_hint *hint)
    1371             : {
    1372        2259 :   if( preftype == PREFTYPE_SYM )
    1373             :     {
    1374        1602 :       if(PGP6 && (algo != CIPHER_ALGO_IDEA
    1375           0 :                   && algo != CIPHER_ALGO_3DES
    1376           0 :                   && algo != CIPHER_ALGO_CAST5))
    1377           0 :         return 0;
    1378             : 
    1379        1602 :       if(PGP7 && (algo != CIPHER_ALGO_IDEA
    1380           0 :                   && algo != CIPHER_ALGO_3DES
    1381           0 :                   && algo != CIPHER_ALGO_CAST5
    1382           0 :                   && algo != CIPHER_ALGO_AES
    1383           0 :                   && algo != CIPHER_ALGO_AES192
    1384           0 :                   && algo != CIPHER_ALGO_AES256
    1385           0 :                   && algo != CIPHER_ALGO_TWOFISH))
    1386           0 :         return 0;
    1387             : 
    1388             :       /* PGP8 supports all the ciphers we do.. */
    1389             : 
    1390        1602 :       return algo && !openpgp_cipher_test_algo ( algo );
    1391             :     }
    1392         657 :   else if( preftype == PREFTYPE_HASH )
    1393             :     {
    1394          28 :       if (hint && hint->digest_length)
    1395             :         {
    1396          24 :           if (hint->digest_length!=20 || opt.flags.dsa2)
    1397             :             {
    1398             :               /* If --enable-dsa2 is set or the hash isn't 160 bits
    1399             :                  (which implies DSA2), then we'll accept a hash that
    1400             :                  is larger than we need.  Otherwise we won't accept
    1401             :                  any hash that isn't exactly the right size. */
    1402           0 :               if (hint->digest_length > gcry_md_get_algo_dlen (algo))
    1403           0 :                 return 0;
    1404             :             }
    1405          24 :           else if (hint->digest_length != gcry_md_get_algo_dlen (algo))
    1406           0 :             return 0;
    1407             :         }
    1408             : 
    1409          28 :       if((PGP6 || PGP7) && (algo != DIGEST_ALGO_MD5
    1410           0 :                             && algo != DIGEST_ALGO_SHA1
    1411           0 :                             && algo != DIGEST_ALGO_RMD160))
    1412           0 :         return 0;
    1413             : 
    1414             : 
    1415          28 :       if(PGP8 && (algo != DIGEST_ALGO_MD5
    1416           0 :                   && algo != DIGEST_ALGO_SHA1
    1417           0 :                   && algo != DIGEST_ALGO_RMD160
    1418           0 :                   && algo != DIGEST_ALGO_SHA256))
    1419           0 :         return 0;
    1420             : 
    1421          28 :       return algo && !openpgp_md_test_algo (algo);
    1422             :     }
    1423         629 :   else if( preftype == PREFTYPE_ZIP )
    1424             :     {
    1425         629 :       if((PGP6 || PGP7) && (algo != COMPRESS_ALGO_NONE
    1426           0 :                             && algo != COMPRESS_ALGO_ZIP))
    1427           0 :         return 0;
    1428             : 
    1429             :       /* PGP8 supports all the compression algos we do */
    1430             : 
    1431         629 :       return !check_compress_algo( algo );
    1432             :     }
    1433             :   else
    1434           0 :     return 0;
    1435             : }
    1436             : 
    1437             : /****************
    1438             :  * Return -1 if we could not find an algorithm.
    1439             :  */
    1440             : int
    1441        1116 : select_algo_from_prefs(PK_LIST pk_list, int preftype,
    1442             :                        int request, const union pref_hint *hint)
    1443             : {
    1444             :   PK_LIST pkr;
    1445             :   u32 bits[8];
    1446             :   const prefitem_t *prefs;
    1447        1116 :   int result=-1,i;
    1448             :   u16 scores[256];
    1449             : 
    1450        1116 :   if( !pk_list )
    1451         202 :     return -1;
    1452             : 
    1453         914 :   memset(bits,0xFF,sizeof(bits));
    1454         914 :   memset(scores,0,sizeof(scores));
    1455             : 
    1456        1864 :   for( pkr = pk_list; pkr; pkr = pkr->next )
    1457             :     {
    1458             :       u32 mask[8];
    1459         950 :       int rank=1,implicit=-1;
    1460             : 
    1461         950 :       memset(mask,0,sizeof(mask));
    1462             : 
    1463         950 :       switch(preftype)
    1464             :         {
    1465             :         case PREFTYPE_SYM:
    1466             :           /* IDEA is implicitly there for v3 keys with v3 selfsigs if
    1467             :              --pgp2 mode is on.  This was a 2440 thing that was
    1468             :              dropped from 4880 but is still relevant to GPG's 1991
    1469             :              support.  All this doesn't mean IDEA is actually
    1470             :              available, of course. */
    1471         667 :           implicit=CIPHER_ALGO_3DES;
    1472             : 
    1473         667 :           break;
    1474             : 
    1475             :         case PREFTYPE_HASH:
    1476             :           /* While I am including this code for completeness, note
    1477             :              that currently --pgp2 mode locks the hash at MD5, so this
    1478             :              code will never even be called.  Even if the hash wasn't
    1479             :              locked at MD5, we don't support sign+encrypt in --pgp2
    1480             :              mode, and that's the only time PREFTYPE_HASH is used
    1481             :              anyway. -dms */
    1482             : 
    1483          28 :           implicit=DIGEST_ALGO_SHA1;
    1484             : 
    1485          28 :           break;
    1486             : 
    1487             :         case PREFTYPE_ZIP:
    1488             :           /* Uncompressed is always an option. */
    1489         255 :           implicit=COMPRESS_ALGO_NONE;
    1490             :         }
    1491             : 
    1492         950 :       if (pkr->pk->user_id) /* selected by user ID */
    1493         269 :         prefs = pkr->pk->user_id->prefs;
    1494             :       else
    1495         681 :         prefs = pkr->pk->prefs;
    1496             : 
    1497         950 :       if( prefs )
    1498             :         {
    1499        6373 :           for (i=0; prefs[i].type; i++ )
    1500             :             {
    1501        5423 :               if( prefs[i].type == preftype )
    1502             :                 {
    1503             :                   /* Make sure all scores don't add up past 0xFFFF
    1504             :                      (and roll around) */
    1505        2827 :                   if(rank+scores[prefs[i].value]<=0xFFFF)
    1506        2827 :                     scores[prefs[i].value]+=rank;
    1507             :                   else
    1508           0 :                     scores[prefs[i].value]=0xFFFF;
    1509             : 
    1510        2827 :                   mask[prefs[i].value/32] |= 1<<(prefs[i].value%32);
    1511             : 
    1512        2827 :                   rank++;
    1513             : 
    1514             :                   /* We saw the implicit algorithm, so we don't need
    1515             :                      tack it on the end ourselves. */
    1516        2827 :                   if(implicit==prefs[i].value)
    1517         672 :                     implicit=-1;
    1518             :                 }
    1519             :             }
    1520             :         }
    1521             : 
    1522         950 :       if(rank==1 && preftype==PREFTYPE_ZIP)
    1523             :         {
    1524             :           /* If the compression preferences are not present, they are
    1525             :              assumed to be ZIP, Uncompressed (RFC4880:13.3.1) */
    1526          98 :           scores[1]=1; /* ZIP is first choice */
    1527          98 :           scores[0]=2; /* Uncompressed is second choice */
    1528          98 :           mask[0]|=3;
    1529             :         }
    1530             : 
    1531             :       /* If the key didn't have the implicit algorithm listed
    1532             :          explicitly, add it here at the tail of the list. */
    1533         950 :       if(implicit>-1)
    1534             :         {
    1535         278 :           scores[implicit]+=rank;
    1536         278 :           mask[implicit/32] |= 1<<(implicit%32);
    1537             :         }
    1538             : 
    1539        8550 :       for(i=0;i<8;i++)
    1540        7600 :         bits[i]&=mask[i];
    1541             :     }
    1542             : 
    1543             :   /* We've now scored all of the algorithms, and the usable ones have
    1544             :      bits set.  Let's pick the winner. */
    1545             : 
    1546             :   /* The caller passed us a request.  Can we use it? */
    1547         978 :   if(request>-1 && (bits[request/32] & (1<<(request%32))) &&
    1548          64 :      algo_available(preftype,request,hint))
    1549          64 :     result=request;
    1550             : 
    1551         914 :   if(result==-1)
    1552             :     {
    1553             :       /* If we have personal prefs set, use them. */
    1554         850 :       prefs=NULL;
    1555         850 :       if(preftype==PREFTYPE_SYM && opt.personal_cipher_prefs)
    1556           0 :         prefs=opt.personal_cipher_prefs;
    1557         850 :       else if(preftype==PREFTYPE_HASH && opt.personal_digest_prefs)
    1558           0 :         prefs=opt.personal_digest_prefs;
    1559         850 :       else if(preftype==PREFTYPE_ZIP && opt.personal_compress_prefs)
    1560           0 :         prefs=opt.personal_compress_prefs;
    1561             : 
    1562         850 :       if( prefs )
    1563           0 :         for(i=0; prefs[i].type; i++ )
    1564             :           {
    1565           0 :             if(bits[prefs[i].value/32] & (1<<(prefs[i].value%32))
    1566           0 :                && algo_available( preftype, prefs[i].value, hint))
    1567             :               {
    1568           0 :                 result = prefs[i].value;
    1569           0 :                 break;
    1570             :               }
    1571             :           }
    1572             :     }
    1573             : 
    1574         914 :   if(result==-1)
    1575             :     {
    1576         850 :       unsigned int best=-1;
    1577             : 
    1578             :       /* At this point, we have not selected an algorithm due to a
    1579             :          special request or via personal prefs.  Pick the highest
    1580             :          ranked algorithm (i.e. the one with the lowest score). */
    1581             : 
    1582         850 :       if(preftype==PREFTYPE_HASH && scores[DIGEST_ALGO_MD5])
    1583             :         {
    1584             :           /* "If you are building an authentication system, the recipient
    1585             :              may specify a preferred signing algorithm. However, the
    1586             :              signer would be foolish to use a weak algorithm simply
    1587             :              because the recipient requests it." (RFC4880:14).  If any
    1588             :              other hash algorithm is available, pretend that MD5 isn't.
    1589             :              Note that if the user intentionally chose MD5 by putting it
    1590             :              in their personal prefs, then we do what the user said (as we
    1591             :              never reach this code). */
    1592             : 
    1593           0 :           for(i=DIGEST_ALGO_MD5+1;i<256;i++)
    1594           0 :             if(scores[i])
    1595             :               {
    1596           0 :                 scores[DIGEST_ALGO_MD5]=0;
    1597           0 :                 break;
    1598             :               }
    1599             :         }
    1600             : 
    1601      218450 :       for(i=0;i<256;i++)
    1602             :         {
    1603             :           /* Note the '<' here.  This means in case of a tie, we will
    1604             :              favor the lower algorithm number.  We have a choice
    1605             :              between the lower number (probably an older algorithm
    1606             :              with more time in use), or the higher number (probably a
    1607             :              newer algorithm with less time in use).  Older is
    1608             :              probably safer here, even though the newer algorithms
    1609             :              tend to be "stronger". */
    1610      217600 :           if(scores[i] && scores[i]<best
    1611        2280 :              && (bits[i/32] & (1<<(i%32)))
    1612        2195 :              && algo_available(preftype,i,hint))
    1613             :             {
    1614        2195 :               best=scores[i];
    1615        2195 :               result=i;
    1616             :             }
    1617             :         }
    1618             :     }
    1619             : 
    1620         914 :   return result;
    1621             : }
    1622             : 
    1623             : /*
    1624             :  * Select the MDC flag from the pk_list.  We can only use MDC if all
    1625             :  * recipients support this feature.
    1626             :  */
    1627             : int
    1628         280 : select_mdc_from_pklist (PK_LIST pk_list)
    1629             : {
    1630             :   PK_LIST pkr;
    1631             : 
    1632         280 :   if ( !pk_list )
    1633          33 :     return 0;
    1634             : 
    1635         399 :   for (pkr = pk_list; pkr; pkr = pkr->next)
    1636             :     {
    1637             :       int mdc;
    1638             : 
    1639         250 :       if (pkr->pk->user_id) /* selected by user ID */
    1640         125 :         mdc = pkr->pk->user_id->flags.mdc;
    1641             :       else
    1642         125 :         mdc = pkr->pk->flags.mdc;
    1643         250 :       if (!mdc)
    1644          98 :         return 0;  /* At least one recipient does not support it. */
    1645             :     }
    1646         149 :   return 1; /* Can be used. */
    1647             : }
    1648             : 
    1649             : 
    1650             : /* Print a warning for all keys in PK_LIST missing the MDC feature. */
    1651             : void
    1652           0 : warn_missing_mdc_from_pklist (PK_LIST pk_list)
    1653             : {
    1654             :   PK_LIST pkr;
    1655             : 
    1656           0 :   for (pkr = pk_list; pkr; pkr = pkr->next)
    1657             :     {
    1658             :       int mdc;
    1659             : 
    1660           0 :       if (pkr->pk->user_id) /* selected by user ID */
    1661           0 :         mdc = pkr->pk->user_id->flags.mdc;
    1662             :       else
    1663           0 :         mdc = pkr->pk->flags.mdc;
    1664           0 :       if (!mdc)
    1665           0 :         log_info (_("Note: key %s has no %s feature\n"),
    1666             :                   keystr_from_pk (pkr->pk), "MDC");
    1667             :     }
    1668           0 : }
    1669             : 
    1670             : void
    1671           0 : warn_missing_aes_from_pklist (PK_LIST pk_list)
    1672             : {
    1673             :   PK_LIST pkr;
    1674             : 
    1675           0 :   for (pkr = pk_list; pkr; pkr = pkr->next)
    1676             :     {
    1677             :       const prefitem_t *prefs;
    1678             :       int i;
    1679           0 :       int gotit = 0;
    1680             : 
    1681           0 :       prefs = pkr->pk->user_id? pkr->pk->user_id->prefs : pkr->pk->prefs;
    1682           0 :       if (prefs)
    1683             :         {
    1684           0 :           for (i=0; !gotit && prefs[i].type; i++ )
    1685           0 :             if (prefs[i].type == PREFTYPE_SYM
    1686           0 :                 && prefs[i].value == CIPHER_ALGO_AES)
    1687           0 :               gotit++;
    1688             :         }
    1689           0 :       if (!gotit)
    1690           0 :         log_info (_("Note: key %s has no preference for %s\n"),
    1691             :                   keystr_from_pk (pkr->pk), "AES");
    1692             :     }
    1693           0 : }

Generated by: LCOV version 1.11