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