g10: Remove option --always-trust if compiled without trust models.
[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   /* XXX: Change this function to use get_pubkeys instead of
918      get_pubkey_byname to detect ambiguous key specifications and warn
919      about duplicate keyblocks.  For ambiguous key specifications on
920      the command line or provided interactively, prompt the user to
921      select the best key.  If a key specification is ambiguous and we
922      are in batch mode, die.  */
923
924   if (opt.encrypt_to_default_key)
925     {
926       static int warned;
927
928       const char *default_key = parse_def_secret_key (ctrl);
929       if (default_key)
930         {
931           PK_LIST r = xmalloc_clear (sizeof *r);
932
933           r->pk = xmalloc_clear (sizeof *r->pk);
934           r->pk->req_usage = PUBKEY_USAGE_ENC;
935
936           rc = get_pubkey_byname (ctrl, NULL, r->pk, default_key,
937                                    NULL, NULL, 0, 1);
938           if (rc)
939             {
940               xfree (r->pk);
941               xfree (r);
942
943               log_error (_("can't encrypt to '%s'\n"), default_key);
944               if (!opt.quiet)
945                 log_info (_("(check argument of option '%s')\n"),
946                           "--default-key");
947             }
948           else
949             {
950               r->next = pk_list;
951               r->flags = 0;
952               pk_list = r;
953             }
954         }
955       else if (opt.def_secret_key)
956         {
957           if (! warned)
958             log_info (_("option '%s' given, but no valid default keys given\n"),
959                       "--encrypt-to-default-key");
960           warned = 1;
961         }
962       else
963         {
964           if (! warned)
965             log_info (_("option '%s' given, but option '%s' not given\n"),
966                       "--encrypt-to-default-key", "--default-key");
967           warned = 1;
968         }
969     }
970
971   /* Check whether there are any recipients in the list and build the
972    * list of the encrypt-to ones (we always trust them). */
973   for ( rov = remusr; rov; rov = rov->next )
974     {
975       if ( !(rov->flags & PK_LIST_ENCRYPT_TO) )
976         {
977           /* This is a regular recipient; i.e. not an encrypt-to
978              one. */
979           any_recipients = 1;
980
981           /* Hidden recipients are not allowed while in PGP mode,
982              issue a warning and switch into GnuPG mode. */
983           if ((rov->flags & PK_LIST_HIDDEN) && (PGP6 || PGP7 || PGP8))
984             {
985               log_info(_("you may not use %s while in %s mode\n"),
986                        "--hidden-recipient",
987                        compliance_option_string());
988
989               compliance_failure();
990             }
991         }
992       else if (!opt.no_encrypt_to)
993         {
994           /* --encrypt-to has not been disabled.  Check this
995              encrypt-to key. */
996           pk = xmalloc_clear( sizeof *pk );
997           pk->req_usage = PUBKEY_USAGE_ENC;
998
999           /* We explicitly allow encrypt-to to an disabled key; thus
1000              we pass 1 for the second last argument and 1 as the last
1001              argument to disable AKL. */
1002           if ( (rc = get_pubkey_byname (ctrl,
1003                                         NULL, pk, rov->d, NULL, NULL, 1, 1)) )
1004             {
1005               free_public_key ( pk ); pk = NULL;
1006               log_error (_("%s: skipped: %s\n"), rov->d, gpg_strerror (rc) );
1007               send_status_inv_recp (0, rov->d);
1008               goto fail;
1009             }
1010           else if ( !(rc=openpgp_pk_test_algo2 (pk->pubkey_algo,
1011                                                 PUBKEY_USAGE_ENC)) )
1012             {
1013               /* Skip the actual key if the key is already present
1014                * in the list.  Add it to our list if not. */
1015               if (key_present_in_pk_list(pk_list, pk) == 0)
1016                 {
1017                   free_public_key (pk); pk = NULL;
1018                   if (!opt.quiet)
1019                     log_info (_("%s: skipped: public key already present\n"),
1020                               rov->d);
1021                 }
1022               else
1023                 {
1024                   PK_LIST r;
1025                   r = xmalloc( sizeof *r );
1026                   r->pk = pk; pk = NULL;
1027                   r->next = pk_list;
1028                   r->flags = (rov->flags&PK_LIST_HIDDEN)?1:0;
1029                   pk_list = r;
1030
1031                   /* Hidden encrypt-to recipients are not allowed while
1032                      in PGP mode, issue a warning and switch into
1033                      GnuPG mode. */
1034                   if ((r->flags&PK_LIST_ENCRYPT_TO) && (PGP6 || PGP7 || PGP8))
1035                     {
1036                       log_info(_("you may not use %s while in %s mode\n"),
1037                                "--hidden-encrypt-to",
1038                                compliance_option_string());
1039
1040                       compliance_failure();
1041                     }
1042                 }
1043             }
1044           else
1045             {
1046               /* The public key is not usable for encryption. */
1047               free_public_key( pk ); pk = NULL;
1048               log_error(_("%s: skipped: %s\n"), rov->d, gpg_strerror (rc) );
1049               send_status_inv_recp (3, rov->d); /* Wrong key usage */
1050               goto fail;
1051             }
1052         }
1053     }
1054
1055   /* If we don't have any recipients yet and we are not in batch mode
1056      drop into interactive selection mode. */
1057   if ( !any_recipients && !opt.batch )
1058     {
1059       int have_def_rec;
1060       char *answer = NULL;
1061       strlist_t backlog = NULL;
1062
1063       if (pk_list)
1064         any_recipients = 1;
1065       def_rec = default_recipient(ctrl);
1066       have_def_rec = !!def_rec;
1067       if ( !have_def_rec )
1068         tty_printf(_("You did not specify a user ID. (you may use \"-r\")\n"));
1069
1070       for (;;)
1071         {
1072           rc = 0;
1073           xfree(answer);
1074           if ( have_def_rec )
1075             {
1076               /* A default recipient is taken as the first entry. */
1077               answer = def_rec;
1078               def_rec = NULL;
1079             }
1080           else if (backlog)
1081             {
1082               /* This is part of our trick to expand and display groups. */
1083               answer = strlist_pop (&backlog);
1084             }
1085           else
1086             {
1087               /* Show the list of already collected recipients and ask
1088                  for more. */
1089               PK_LIST iter;
1090
1091               tty_printf("\n");
1092               tty_printf(_("Current recipients:\n"));
1093               for (iter=pk_list;iter;iter=iter->next)
1094                 {
1095                   u32 keyid[2];
1096
1097                   keyid_from_pk(iter->pk,keyid);
1098                   tty_printf ("%s/%s %s \"",
1099                               pubkey_string (iter->pk,
1100                                              pkstrbuf, sizeof pkstrbuf),
1101                               keystr(keyid),
1102                               datestr_from_pk (iter->pk));
1103
1104                   if (iter->pk->user_id)
1105                     tty_print_utf8_string(iter->pk->user_id->name,
1106                                           iter->pk->user_id->len);
1107                   else
1108                     {
1109                       size_t n;
1110                       char *p = get_user_id( keyid, &n );
1111                       tty_print_utf8_string( p, n );
1112                       xfree(p);
1113                     }
1114                   tty_printf("\"\n");
1115                 }
1116
1117               answer = cpr_get_utf8("pklist.user_id.enter",
1118                                     _("\nEnter the user ID.  "
1119                                       "End with an empty line: "));
1120               trim_spaces(answer);
1121               cpr_kill_prompt();
1122             }
1123
1124           if ( !answer || !*answer )
1125             {
1126               xfree(answer);
1127               break;  /* No more recipients entered - get out of loop. */
1128             }
1129
1130           /* Do group expand here too.  The trick here is to continue
1131              the loop if any expansion occurred.  The code above will
1132              then list all expanded keys. */
1133           if (expand_id(answer,&backlog,0))
1134             continue;
1135
1136           /* Get and check key for the current name. */
1137           free_public_key (pk);
1138           pk = xmalloc_clear( sizeof *pk );
1139           pk->req_usage = PUBKEY_USAGE_ENC;
1140           rc = get_pubkey_byname (ctrl, NULL, pk, answer, NULL, NULL, 0, 0 );
1141           if (rc)
1142             tty_printf(_("No such user ID.\n"));
1143           else if ( !(rc=openpgp_pk_test_algo2 (pk->pubkey_algo,
1144                                                 PUBKEY_USAGE_ENC)) )
1145             {
1146               if ( have_def_rec )
1147                 {
1148                   /* No validation for a default recipient. */
1149                   if (!key_present_in_pk_list(pk_list, pk))
1150                     {
1151                       free_public_key (pk);
1152                       pk = NULL;
1153                       log_info (_("skipped: public key "
1154                                   "already set as default recipient\n") );
1155                     }
1156                   else
1157                     {
1158                       PK_LIST r = xmalloc (sizeof *r);
1159                       r->pk = pk; pk = NULL;
1160                       r->next = pk_list;
1161                       r->flags = 0; /* No throwing default ids. */
1162                       pk_list = r;
1163                     }
1164                   any_recipients = 1;
1165                   continue;
1166                 }
1167               else
1168                 { /* Check validity of this key. */
1169                   int trustlevel;
1170
1171                   trustlevel = get_validity (pk, pk->user_id, NULL, 1);
1172                   if ( (trustlevel & TRUST_FLAG_DISABLED) )
1173                     {
1174                       tty_printf (_("Public key is disabled.\n") );
1175                     }
1176                   else if ( do_we_trust_pre (pk, trustlevel) )
1177                     {
1178                       /* Skip the actual key if the key is already
1179                        * present in the list */
1180                       if (!key_present_in_pk_list(pk_list, pk))
1181                         {
1182                           free_public_key (pk);
1183                           pk = NULL;
1184                           log_info(_("skipped: public key already set\n") );
1185                         }
1186                       else
1187                         {
1188                           PK_LIST r;
1189                           r = xmalloc( sizeof *r );
1190                           r->pk = pk; pk = NULL;
1191                           r->next = pk_list;
1192                           r->flags = 0; /* No throwing interactive ids. */
1193                           pk_list = r;
1194                         }
1195                       any_recipients = 1;
1196                       continue;
1197                     }
1198                 }
1199             }
1200           xfree(def_rec); def_rec = NULL;
1201           have_def_rec = 0;
1202         }
1203       if ( pk )
1204         {
1205           free_public_key( pk );
1206           pk = NULL;
1207         }
1208     }
1209   else if ( !any_recipients && (def_rec = default_recipient(ctrl)) )
1210     {
1211       /* We are in batch mode and have only a default recipient. */
1212       pk = xmalloc_clear( sizeof *pk );
1213       pk->req_usage = PUBKEY_USAGE_ENC;
1214
1215       /* The default recipient is allowed to be disabled; thus pass 1
1216          as second last argument.  We also don't want an AKL. */
1217       rc = get_pubkey_byname (ctrl, NULL, pk, def_rec, NULL, NULL, 1, 1);
1218       if (rc)
1219         log_error(_("unknown default recipient \"%s\"\n"), def_rec );
1220       else if ( !(rc=openpgp_pk_test_algo2(pk->pubkey_algo,
1221                                            PUBKEY_USAGE_ENC)) )
1222         {
1223           /* Mark any_recipients here since the default recipient
1224              would have been used if it wasn't already there.  It
1225              doesn't really matter if we got this key from the default
1226              recipient or an encrypt-to. */
1227           any_recipients = 1;
1228           if (!key_present_in_pk_list(pk_list, pk))
1229             log_info (_("skipped: public key already set "
1230                         "as default recipient\n"));
1231           else
1232             {
1233               PK_LIST r = xmalloc( sizeof *r );
1234               r->pk = pk; pk = NULL;
1235               r->next = pk_list;
1236               r->flags = 0; /* No throwing default ids. */
1237               pk_list = r;
1238             }
1239         }
1240       if ( pk )
1241         {
1242           free_public_key( pk );
1243           pk = NULL;
1244         }
1245       xfree(def_rec); def_rec = NULL;
1246     }
1247   else
1248     {
1249       /* General case: Check all keys. */
1250       any_recipients = 0;
1251       for (; remusr; remusr = remusr->next )
1252         {
1253           if ( (remusr->flags & PK_LIST_ENCRYPT_TO) )
1254             continue; /* encrypt-to keys are already handled. */
1255
1256           rc = find_and_check_key (ctrl, remusr->d, PUBKEY_USAGE_ENC,
1257                                    !!(remusr->flags&PK_LIST_HIDDEN),
1258                                    &pk_list);
1259           if (rc)
1260             goto fail;
1261           any_recipients = 1;
1262         }
1263     }
1264
1265   if ( !rc && !any_recipients )
1266     {
1267       log_error(_("no valid addressees\n"));
1268       write_status_text (STATUS_NO_RECP, "0");
1269       rc = GPG_ERR_NO_USER_ID;
1270     }
1271
1272  fail:
1273
1274   if ( rc )
1275     release_pk_list( pk_list );
1276   else
1277     *ret_pk_list = pk_list;
1278   if (opt.grouplist)
1279     free_strlist(remusr);
1280   return rc;
1281 }
1282
1283
1284 /* In pgp6 mode, disallow all ciphers except IDEA (1), 3DES (2), and
1285    CAST5 (3), all hashes except MD5 (1), SHA1 (2), and RIPEMD160 (3),
1286    and all compressions except none (0) and ZIP (1).  pgp7 and pgp8
1287    mode expands the cipher list to include AES128 (7), AES192 (8),
1288    AES256 (9), and TWOFISH (10).  pgp8 adds the SHA-256 hash (8).  For
1289    a true PGP key all of this is unneeded as they are the only items
1290    present in the preferences subpacket, but checking here covers the
1291    weird case of encrypting to a key that had preferences from a
1292    different implementation which was then used with PGP.  I am not
1293    completely comfortable with this as the right thing to do, as it
1294    slightly alters the list of what the user is supposedly requesting.
1295    It is not against the RFC however, as the preference chosen will
1296    never be one that the user didn't specify somewhere ("The
1297    implementation may use any mechanism to pick an algorithm in the
1298    intersection"), and PGP has no mechanism to fix such a broken
1299    preference list, so I'm including it. -dms */
1300
1301 int
1302 algo_available( preftype_t preftype, int algo, const union pref_hint *hint)
1303 {
1304   if( preftype == PREFTYPE_SYM )
1305     {
1306       if(PGP6 && (algo != CIPHER_ALGO_IDEA
1307                   && algo != CIPHER_ALGO_3DES
1308                   && algo != CIPHER_ALGO_CAST5))
1309         return 0;
1310
1311       if(PGP7 && (algo != CIPHER_ALGO_IDEA
1312                   && algo != CIPHER_ALGO_3DES
1313                   && algo != CIPHER_ALGO_CAST5
1314                   && algo != CIPHER_ALGO_AES
1315                   && algo != CIPHER_ALGO_AES192
1316                   && algo != CIPHER_ALGO_AES256
1317                   && algo != CIPHER_ALGO_TWOFISH))
1318         return 0;
1319
1320       /* PGP8 supports all the ciphers we do.. */
1321
1322       return algo && !openpgp_cipher_test_algo ( algo );
1323     }
1324   else if( preftype == PREFTYPE_HASH )
1325     {
1326       if (hint && hint->digest_length)
1327         {
1328           if (hint->digest_length!=20 || opt.flags.dsa2)
1329             {
1330               /* If --enable-dsa2 is set or the hash isn't 160 bits
1331                  (which implies DSA2), then we'll accept a hash that
1332                  is larger than we need.  Otherwise we won't accept
1333                  any hash that isn't exactly the right size. */
1334               if (hint->digest_length > gcry_md_get_algo_dlen (algo))
1335                 return 0;
1336             }
1337           else if (hint->digest_length != gcry_md_get_algo_dlen (algo))
1338             return 0;
1339         }
1340
1341       if((PGP6 || PGP7) && (algo != DIGEST_ALGO_MD5
1342                             && algo != DIGEST_ALGO_SHA1
1343                             && algo != DIGEST_ALGO_RMD160))
1344         return 0;
1345
1346
1347       if(PGP8 && (algo != DIGEST_ALGO_MD5
1348                   && algo != DIGEST_ALGO_SHA1
1349                   && algo != DIGEST_ALGO_RMD160
1350                   && algo != DIGEST_ALGO_SHA256))
1351         return 0;
1352
1353       return algo && !openpgp_md_test_algo (algo);
1354     }
1355   else if( preftype == PREFTYPE_ZIP )
1356     {
1357       if((PGP6 || PGP7) && (algo != COMPRESS_ALGO_NONE
1358                             && algo != COMPRESS_ALGO_ZIP))
1359         return 0;
1360
1361       /* PGP8 supports all the compression algos we do */
1362
1363       return !check_compress_algo( algo );
1364     }
1365   else
1366     return 0;
1367 }
1368
1369 /****************
1370  * Return -1 if we could not find an algorithm.
1371  */
1372 int
1373 select_algo_from_prefs(PK_LIST pk_list, int preftype,
1374                        int request, const union pref_hint *hint)
1375 {
1376   PK_LIST pkr;
1377   u32 bits[8];
1378   const prefitem_t *prefs;
1379   int result=-1,i;
1380   u16 scores[256];
1381
1382   if( !pk_list )
1383     return -1;
1384
1385   memset(bits,0xFF,sizeof(bits));
1386   memset(scores,0,sizeof(scores));
1387
1388   for( pkr = pk_list; pkr; pkr = pkr->next )
1389     {
1390       u32 mask[8];
1391       int rank=1,implicit=-1;
1392
1393       memset(mask,0,sizeof(mask));
1394
1395       switch(preftype)
1396         {
1397         case PREFTYPE_SYM:
1398           /* IDEA is implicitly there for v3 keys with v3 selfsigs if
1399              --pgp2 mode is on.  This was a 2440 thing that was
1400              dropped from 4880 but is still relevant to GPG's 1991
1401              support.  All this doesn't mean IDEA is actually
1402              available, of course. */
1403           implicit=CIPHER_ALGO_3DES;
1404
1405           break;
1406
1407         case PREFTYPE_HASH:
1408           /* While I am including this code for completeness, note
1409              that currently --pgp2 mode locks the hash at MD5, so this
1410              code will never even be called.  Even if the hash wasn't
1411              locked at MD5, we don't support sign+encrypt in --pgp2
1412              mode, and that's the only time PREFTYPE_HASH is used
1413              anyway. -dms */
1414
1415           implicit=DIGEST_ALGO_SHA1;
1416
1417           break;
1418
1419         case PREFTYPE_ZIP:
1420           /* Uncompressed is always an option. */
1421           implicit=COMPRESS_ALGO_NONE;
1422         }
1423
1424       if (pkr->pk->user_id) /* selected by user ID */
1425         prefs = pkr->pk->user_id->prefs;
1426       else
1427         prefs = pkr->pk->prefs;
1428
1429       if( prefs )
1430         {
1431           for (i=0; prefs[i].type; i++ )
1432             {
1433               if( prefs[i].type == preftype )
1434                 {
1435                   /* Make sure all scores don't add up past 0xFFFF
1436                      (and roll around) */
1437                   if(rank+scores[prefs[i].value]<=0xFFFF)
1438                     scores[prefs[i].value]+=rank;
1439                   else
1440                     scores[prefs[i].value]=0xFFFF;
1441
1442                   mask[prefs[i].value/32] |= 1<<(prefs[i].value%32);
1443
1444                   rank++;
1445
1446                   /* We saw the implicit algorithm, so we don't need
1447                      tack it on the end ourselves. */
1448                   if(implicit==prefs[i].value)
1449                     implicit=-1;
1450                 }
1451             }
1452         }
1453
1454       if(rank==1 && preftype==PREFTYPE_ZIP)
1455         {
1456           /* If the compression preferences are not present, they are
1457              assumed to be ZIP, Uncompressed (RFC4880:13.3.1) */
1458           scores[1]=1; /* ZIP is first choice */
1459           scores[0]=2; /* Uncompressed is second choice */
1460           mask[0]|=3;
1461         }
1462
1463       /* If the key didn't have the implicit algorithm listed
1464          explicitly, add it here at the tail of the list. */
1465       if(implicit>-1)
1466         {
1467           scores[implicit]+=rank;
1468           mask[implicit/32] |= 1<<(implicit%32);
1469         }
1470
1471       for(i=0;i<8;i++)
1472         bits[i]&=mask[i];
1473     }
1474
1475   /* We've now scored all of the algorithms, and the usable ones have
1476      bits set.  Let's pick the winner. */
1477
1478   /* The caller passed us a request.  Can we use it? */
1479   if(request>-1 && (bits[request/32] & (1<<(request%32))) &&
1480      algo_available(preftype,request,hint))
1481     result=request;
1482
1483   if(result==-1)
1484     {
1485       /* If we have personal prefs set, use them. */
1486       prefs=NULL;
1487       if(preftype==PREFTYPE_SYM && opt.personal_cipher_prefs)
1488         prefs=opt.personal_cipher_prefs;
1489       else if(preftype==PREFTYPE_HASH && opt.personal_digest_prefs)
1490         prefs=opt.personal_digest_prefs;
1491       else if(preftype==PREFTYPE_ZIP && opt.personal_compress_prefs)
1492         prefs=opt.personal_compress_prefs;
1493
1494       if( prefs )
1495         for(i=0; prefs[i].type; i++ )
1496           {
1497             if(bits[prefs[i].value/32] & (1<<(prefs[i].value%32))
1498                && algo_available( preftype, prefs[i].value, hint))
1499               {
1500                 result = prefs[i].value;
1501                 break;
1502               }
1503           }
1504     }
1505
1506   if(result==-1)
1507     {
1508       unsigned int best=-1;
1509
1510       /* At this point, we have not selected an algorithm due to a
1511          special request or via personal prefs.  Pick the highest
1512          ranked algorithm (i.e. the one with the lowest score). */
1513
1514       if(preftype==PREFTYPE_HASH && scores[DIGEST_ALGO_MD5])
1515         {
1516           /* "If you are building an authentication system, the recipient
1517              may specify a preferred signing algorithm. However, the
1518              signer would be foolish to use a weak algorithm simply
1519              because the recipient requests it." (RFC4880:14).  If any
1520              other hash algorithm is available, pretend that MD5 isn't.
1521              Note that if the user intentionally chose MD5 by putting it
1522              in their personal prefs, then we do what the user said (as we
1523              never reach this code). */
1524
1525           for(i=DIGEST_ALGO_MD5+1;i<256;i++)
1526             if(scores[i])
1527               {
1528                 scores[DIGEST_ALGO_MD5]=0;
1529                 break;
1530               }
1531         }
1532
1533       for(i=0;i<256;i++)
1534         {
1535           /* Note the '<' here.  This means in case of a tie, we will
1536              favor the lower algorithm number.  We have a choice
1537              between the lower number (probably an older algorithm
1538              with more time in use), or the higher number (probably a
1539              newer algorithm with less time in use).  Older is
1540              probably safer here, even though the newer algorithms
1541              tend to be "stronger". */
1542           if(scores[i] && scores[i]<best
1543              && (bits[i/32] & (1<<(i%32)))
1544              && algo_available(preftype,i,hint))
1545             {
1546               best=scores[i];
1547               result=i;
1548             }
1549         }
1550     }
1551
1552   return result;
1553 }
1554
1555 /*
1556  * Select the MDC flag from the pk_list.  We can only use MDC if all
1557  * recipients support this feature.
1558  */
1559 int
1560 select_mdc_from_pklist (PK_LIST pk_list)
1561 {
1562   PK_LIST pkr;
1563
1564   if ( !pk_list )
1565     return 0;
1566
1567   for (pkr = pk_list; pkr; pkr = pkr->next)
1568     {
1569       int mdc;
1570
1571       if (pkr->pk->user_id) /* selected by user ID */
1572         mdc = pkr->pk->user_id->flags.mdc;
1573       else
1574         mdc = pkr->pk->flags.mdc;
1575       if (!mdc)
1576         return 0;  /* At least one recipient does not support it. */
1577     }
1578   return 1; /* Can be used. */
1579 }
1580
1581
1582 /* Print a warning for all keys in PK_LIST missing the MDC feature. */
1583 void
1584 warn_missing_mdc_from_pklist (PK_LIST pk_list)
1585 {
1586   PK_LIST pkr;
1587
1588   for (pkr = pk_list; pkr; pkr = pkr->next)
1589     {
1590       int mdc;
1591
1592       if (pkr->pk->user_id) /* selected by user ID */
1593         mdc = pkr->pk->user_id->flags.mdc;
1594       else
1595         mdc = pkr->pk->flags.mdc;
1596       if (!mdc)
1597         log_info (_("Note: key %s has no %s feature\n"),
1598                   keystr_from_pk (pkr->pk), "MDC");
1599     }
1600 }
1601
1602 void
1603 warn_missing_aes_from_pklist (PK_LIST pk_list)
1604 {
1605   PK_LIST pkr;
1606
1607   for (pkr = pk_list; pkr; pkr = pkr->next)
1608     {
1609       const prefitem_t *prefs;
1610       int i;
1611       int gotit = 0;
1612
1613       prefs = pkr->pk->user_id? pkr->pk->user_id->prefs : pkr->pk->prefs;
1614       if (prefs)
1615         {
1616           for (i=0; !gotit && prefs[i].type; i++ )
1617             if (prefs[i].type == PREFTYPE_SYM
1618                 && prefs[i].value == CIPHER_ALGO_AES)
1619               gotit++;
1620         }
1621       if (!gotit)
1622         log_info (_("Note: key %s has no preference for %s\n"),
1623                   keystr_from_pk (pkr->pk), "AES");
1624     }
1625 }