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