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