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