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