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