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