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