* misc.c (optsep): Add the ability to understand keyword="quoted arg with
[gnupg.git] / g10 / pkclist.c
1 /* pkclist.c
2  * Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003,
3  *               2004 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 2 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, write to the Free Software
19  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
20  */
21
22 #include <config.h>
23 #include <stdio.h>
24 #include <stdlib.h>
25 #include <string.h>
26 #include <errno.h>
27 #include <assert.h>
28
29 #include "options.h"
30 #include "packet.h"
31 #include "errors.h"
32 #include "keydb.h"
33 #include "memory.h"
34 #include "util.h"
35 #include "main.h"
36 #include "trustdb.h"
37 #include "ttyio.h"
38 #include "status.h"
39 #include "photoid.h"
40 #include "i18n.h"
41
42 #define CONTROL_D ('D' - 'A' + 1)
43
44 /****************
45  * Show the revocation reason as it is stored with the given signature
46  */
47 static void
48 do_show_revocation_reason( PKT_signature *sig )
49 {
50     size_t n, nn;
51     const byte *p, *pp;
52     int seq = 0;
53     const char *text;
54
55     while( (p = enum_sig_subpkt (sig->hashed, SIGSUBPKT_REVOC_REASON,
56                                  &n, &seq, NULL )) ) {
57         if( !n )
58             continue; /* invalid - just skip it */
59
60         if( *p == 0 )
61             text = _("No reason specified");
62         else if( *p == 0x01 )
63             text = _("Key is superseded");
64         else if( *p == 0x02 )
65             text = _("Key has been compromised");
66         else if( *p == 0x03 )
67             text = _("Key is no longer used");
68         else if( *p == 0x20 )
69             text = _("User ID is no longer valid");
70         else
71             text = NULL;
72
73         log_info( _("reason for revocation: ") );
74         if( text )
75             fputs( text, log_stream() );
76         else
77             fprintf( log_stream(), "code=%02x", *p );
78         putc( '\n', log_stream() );
79         n--; p++;
80         pp = NULL;
81         do {
82             /* We don't want any empty lines, so skip them */
83             while( n && *p == '\n' ) {
84                 p++;
85                 n--;
86             }
87             if( n ) {
88                 pp = memchr( p, '\n', n );
89                 nn = pp? pp - p : n;
90                 log_info( _("revocation comment: ") );
91                 print_string( log_stream(), p, nn, 0 );
92                 putc( '\n', log_stream() );
93                 p += nn; n -= nn;
94             }
95         } while( pp );
96     }
97 }
98
99 /* Mode 0: try and find the revocation based on the pk (i.e. check
100    subkeys, etc.)  Mode 1: use only the revocation on the main pk */
101
102 void
103 show_revocation_reason( PKT_public_key *pk, int mode )
104 {
105     /* Hmmm, this is not so easy becuase we have to duplicate the code
106      * used in the trustbd to calculate the keyflags.  We need to find
107      * a clean way to check revocation certificates on keys and
108      * signatures.  And there should be no duplicate code.  Because we
109      * enter this function only when the trustdb told us that we have
110      * a revoked key, we could simply look for a revocation cert and
111      * display this one, when there is only one. Let's try to do this
112      * until we have a better solution.  */
113     KBNODE node, keyblock = NULL;
114     byte fingerprint[MAX_FINGERPRINT_LEN];
115     size_t fingerlen;
116     int rc;
117
118     /* get the keyblock */
119     fingerprint_from_pk( pk, fingerprint, &fingerlen );
120     rc = get_keyblock_byfprint( &keyblock, fingerprint, fingerlen );
121     if( rc ) { /* that should never happen */
122         log_debug( "failed to get the keyblock\n");
123         return;
124     }
125
126     for( node=keyblock; node; node = node->next ) {
127         if( (mode && node->pkt->pkttype == PKT_PUBLIC_KEY) ||
128           ( ( node->pkt->pkttype == PKT_PUBLIC_KEY
129               || node->pkt->pkttype == PKT_PUBLIC_SUBKEY )
130             && !cmp_public_keys( node->pkt->pkt.public_key, pk ) ) )
131             break;
132     }
133     if( !node ) {
134         log_debug("Oops, PK not in keyblock\n");
135         release_kbnode( keyblock );
136         return;
137     }
138     /* now find the revocation certificate */
139     for( node = node->next; node ; node = node->next ) {
140         if( node->pkt->pkttype == PKT_PUBLIC_SUBKEY )
141             break;
142         if( node->pkt->pkttype == PKT_SIGNATURE
143             && (node->pkt->pkt.signature->sig_class == 0x20
144                 || node->pkt->pkt.signature->sig_class == 0x28 ) ) {
145                 /* FIXME: we should check the signature here */
146                 do_show_revocation_reason ( node->pkt->pkt.signature );
147                 break;
148         }
149     }
150
151     /* We didn't find it, so check if the whole key is revoked */
152     if(!node && !mode)
153       show_revocation_reason(pk,1);
154
155     release_kbnode( keyblock );
156 }
157
158
159 /****************
160  * mode: 0 = standard
161  *       1 = Without key info and additional menu option 'm'
162  *           this does also add an option to set the key to ultimately trusted.
163  * Returns: 
164  *      -2 = nothing changed - caller should show some additional info
165  *      -1 = quit operation
166  *       0 = nothing changed
167  *       1 = new ownertrust now in new_trust
168  */
169 static int
170 do_edit_ownertrust (PKT_public_key *pk, int mode,
171                     unsigned *new_trust, int defer_help )
172 {
173   char *p;
174   size_t n;
175   u32 keyid[2];
176   int changed=0;
177   int quit=0;
178   int show=0;
179   int min_num;
180   int did_help=defer_help;
181   unsigned int minimum=get_min_ownertrust(pk);
182
183   switch(minimum)
184     {
185     default:              min_num=0; break;
186     case TRUST_UNDEFINED: min_num=1; break;
187     case TRUST_NEVER:     min_num=2; break;
188     case TRUST_MARGINAL:  min_num=3; break;
189     case TRUST_FULLY:     min_num=4; break;
190     }
191
192   keyid_from_pk (pk, keyid);
193   for(;;) {
194     /* a string with valid answers */
195     const char *ans = _("iImMqQsS");
196
197     if( !did_help ) 
198       {
199         if( !mode ) 
200           {
201             KBNODE keyblock, un;
202
203             tty_printf(_("No trust value assigned to:\n"));
204             tty_printf("%4u%c/%s %s\n",nbits_from_pk( pk ),
205                        pubkey_letter( pk->pubkey_algo ),
206                        keystr(keyid), datestr_from_pk( pk ) );
207             tty_printf(_("          \""));
208             p = get_user_id( keyid, &n );
209             tty_print_utf8_string( p, n );
210             m_free(p);
211             tty_printf("\"\n");
212
213             keyblock = get_pubkeyblock (keyid);
214             if (!keyblock)
215                 BUG ();
216             for (un=keyblock; un; un = un->next)
217               {
218                 if (un->pkt->pkttype != PKT_USER_ID )
219                   continue;
220                 if (un->pkt->pkt.user_id->is_revoked )
221                   continue;
222                 if (un->pkt->pkt.user_id->is_expired )
223                   continue;
224                 /* Only skip textual primaries */
225                 if (un->pkt->pkt.user_id->is_primary
226                     && !un->pkt->pkt.user_id->attrib_data )
227                   continue;
228                 
229                 if((opt.verify_options&VERIFY_SHOW_PHOTOS)
230                    && un->pkt->pkt.user_id->attrib_data)
231                   show_photos(un->pkt->pkt.user_id->attribs,
232                               un->pkt->pkt.user_id->numattribs,pk,NULL);
233
234                 tty_printf(_("      aka \""));
235                 tty_print_utf8_string (un->pkt->pkt.user_id->name,
236                                        un->pkt->pkt.user_id->len );
237                 tty_printf("\"\n");
238               }
239         
240             print_fingerprint (pk, NULL, 2);
241             tty_printf("\n");
242             release_kbnode (keyblock);
243           }
244         /* This string also used in keyedit.c:sign_uids */
245         tty_printf (_(
246                      "Please decide how far you trust this user to correctly\n"
247                      "verify other users' keys (by looking at passports,\n"
248                      "checking fingerprints from different sources...)?\n\n"));
249         if(min_num<=1)
250           tty_printf (_(" %d = I don't know or won't say\n"), 1);
251         if(min_num<=2)
252           tty_printf (_(" %d = I do NOT trust\n"), 2);
253         if(min_num<=3)
254           tty_printf (_(" %d = I trust marginally\n"), 3);
255         if(min_num<=4)
256           tty_printf (_(" %d = I trust fully\n"), 4);
257         if (mode)
258           tty_printf (_(" %d = I trust ultimately\n"), 5);
259 #if 0
260         /* not yet implemented */
261         tty_printf (_(" i = please show me more information\n") );
262 #endif
263         if( mode )
264           tty_printf(_(" m = back to the main menu\n"));
265         else
266           {
267             tty_printf(_(" s = skip this key\n"));
268             tty_printf(_(" q = quit\n"));
269           }
270         tty_printf("\n");
271         if(minimum)
272           tty_printf(_("The minimum trust level for this key is: %s\n\n"),
273                      trust_value_to_string(minimum));
274         did_help = 1;
275       }
276     if( strlen(ans) != 8 )
277       BUG();
278     p = cpr_get("edit_ownertrust.value",_("Your decision? "));
279     trim_spaces(p);
280     cpr_kill_prompt();
281     if( !*p )
282       did_help = 0;
283     else if( *p && p[1] )
284       ;
285     else if( !p[1] && ((*p >= '0'+min_num) && *p <= (mode?'5':'4')) ) 
286       {
287         unsigned int trust;
288         switch( *p )
289           {
290           case '1': trust = TRUST_UNDEFINED; break;
291           case '2': trust = TRUST_NEVER    ; break;
292           case '3': trust = TRUST_MARGINAL ; break;
293           case '4': trust = TRUST_FULLY    ; break;
294           case '5': trust = TRUST_ULTIMATE ; break;
295           default: BUG();
296           }
297         if (trust == TRUST_ULTIMATE
298             && !cpr_get_answer_is_yes ("edit_ownertrust.set_ultimate.okay",
299                                        _("Do you really want to set this key"
300                                          " to ultimate trust? ")))
301           ; /* no */
302         else
303           {
304             *new_trust = trust;
305             changed = 1;
306             break;
307           }
308       }
309 #if 0
310     /* not yet implemented */
311     else if( *p == ans[0] || *p == ans[1] ) 
312       {
313         tty_printf(_("Certificates leading to an ultimately trusted key:\n"));
314         show = 1;
315         break;
316       }
317 #endif
318     else if( mode && (*p == ans[2] || *p == ans[3] || *p == CONTROL_D ) ) 
319       {
320         break ; /* back to the menu */
321       }
322     else if( !mode && (*p == ans[6] || *p == ans[7] ) )
323       {
324         break; /* skip */
325       }
326     else if( !mode && (*p == ans[4] || *p == ans[5] ) )
327       {
328         quit = 1;
329         break ; /* back to the menu */
330       }
331     m_free(p); p = NULL;
332   }
333   m_free(p);
334   return show? -2: quit? -1 : changed;
335 }
336
337 /* 
338  * Display a menu to change the ownertrust of the key PK (which should
339  * be a primary key).  
340  * For mode values see do_edit_ownertrust ()
341  */
342 int
343 edit_ownertrust (PKT_public_key *pk, int mode )
344 {
345   unsigned int trust;
346   int no_help = 0;
347
348   for(;;)
349     {
350       switch ( do_edit_ownertrust (pk, mode, &trust, no_help ) )
351         {
352         case -1: /* quit */
353           return -1;
354         case -2: /* show info */
355           no_help = 1;
356           break;
357         case 1: /* trust value set */
358           trust &= ~TRUST_FLAG_DISABLED;
359           trust |= get_ownertrust (pk) & TRUST_FLAG_DISABLED;
360           update_ownertrust (pk, trust );
361           return 1;
362         default:
363           return 0;
364         }
365     }
366 }
367
368
369 /****************
370  * Check whether we can trust this pk which has a trustlevel of TRUSTLEVEL
371  * Returns: true if we trust.
372  */
373 static int
374 do_we_trust( PKT_public_key *pk, unsigned int *trustlevel )
375 {
376     unsigned int trustmask = 0;
377
378     /* FIXME: get_pubkey_byname already checks the validity and won't
379      * return keys which are either expired or revoked - so these
380      * question here won't get triggered.  We have to find a solution
381      * for this.  It might make sense to have a function in getkey.c
382      * which does only the basic checks and returns even revoked and
383      * expired keys.  This fnction could then also returhn a list of
384      * keys if the speicified name is ambiguous
385      */
386     if( (*trustlevel & TRUST_FLAG_REVOKED) ) {
387         log_info(_("key %08lX: key has been revoked!\n"),
388                                         (ulong)keyid_from_pk( pk, NULL) );
389         show_revocation_reason( pk, 0 );
390         if( opt.batch )
391           return 0; /* no */
392
393         if( !cpr_get_answer_is_yes("revoked_key.override",
394                                     _("Use this key anyway? ")) )
395           return 0; /* no */
396         trustmask |= TRUST_FLAG_REVOKED;
397     }
398     if( (*trustlevel & TRUST_FLAG_SUB_REVOKED) ) {
399         log_info(_("key %08lX: subkey has been revoked!\n"),
400                                         (ulong)keyid_from_pk( pk, NULL) );
401         show_revocation_reason( pk, 0 );
402         if( opt.batch )
403             return 0;
404
405         if( !cpr_get_answer_is_yes("revoked_key.override",
406                                     _("Use this key anyway? ")) )
407             return 0;
408         trustmask |= TRUST_FLAG_SUB_REVOKED;
409     }
410     *trustlevel &= ~trustmask;
411
412     if( opt.trust_model==TM_ALWAYS ) {
413         if( opt.verbose )
414             log_info("No trust check due to --trust-model always option\n");
415         return 1;
416     }
417
418     switch( (*trustlevel & TRUST_MASK) ) {
419       case TRUST_EXPIRED:
420         log_info(_("%08lX: key has expired\n"),
421                                     (ulong)keyid_from_pk( pk, NULL) );
422         return 0; /* no */
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(_("%08lX: There is no assurance this key belongs "
431                    "to the named user\n"),(ulong)keyid_from_pk( pk, NULL) );
432         return 0; /* no */
433
434         /* No way to get here? */
435       case TRUST_NEVER:
436         log_info(_("%08lX: We do NOT trust this key\n"),
437                                         (ulong)keyid_from_pk( pk, NULL) );
438         return 0; /* no */
439
440       case TRUST_MARGINAL:
441         log_info(_("%08lX: There is limited assurance this key belongs "
442                    "to the named user\n"),(ulong)keyid_from_pk(pk,NULL));
443         return 1; /* yes */
444
445       case TRUST_FULLY:
446         if( opt.verbose )
447             log_info(_("This key probably belongs to the named user\n"));
448         return 1; /* yes */
449
450       case TRUST_ULTIMATE:
451         if( opt.verbose )
452             log_info(_("This key belongs to us\n"));
453         return 1; /* yes */
454     }
455
456     return 1; /* yes */
457 }
458
459
460
461 /****************
462  * wrapper around do_we_trust, so we can ask whether to use the
463  * key anyway.
464  */
465 static int
466 do_we_trust_pre( PKT_public_key *pk, unsigned int trustlevel )
467 {
468     int rc;
469
470     rc = do_we_trust( pk, &trustlevel );
471
472     if( (trustlevel & TRUST_FLAG_REVOKED) && !rc )
473         return 0;
474     if( (trustlevel & TRUST_FLAG_SUB_REVOKED) && !rc )
475         return 0;
476
477     if( !opt.batch && !rc ) {
478         u32 keyid[2];
479
480         keyid_from_pk( pk, keyid);
481         tty_printf( "%4u%c/%08lX %s \"",
482                   nbits_from_pk( pk ), pubkey_letter( pk->pubkey_algo ),
483                   (ulong)keyid[1], datestr_from_pk( pk ) );
484         /* If the pk was chosen by a particular user ID, this is the
485            one to ask about. */
486         if(pk->user_id)
487           tty_print_utf8_string(pk->user_id->name,pk->user_id->len);
488         else
489           {
490             size_t n;
491             char *p = get_user_id( keyid, &n );
492             tty_print_utf8_string( p, n );
493             m_free(p);
494           }
495         tty_printf("\"\n");
496         print_fingerprint (pk, NULL, 2);
497         tty_printf("\n");
498
499         tty_printf(_(
500 "It is NOT certain that the key belongs to the person named\n"
501 "in the user ID.  If you *really* know what you are doing,\n"
502 "you may answer the next question with yes\n\n"));
503
504         if( cpr_get_answer_is_yes("untrusted_key.override",
505                                   _("Use this key anyway? "))  )
506             rc = 1;
507
508         /* Hmmm: Should we set a flag to tell the user about
509          *       his decision the next time he encrypts for this recipient?
510          */
511     }
512     else if( opt.trust_model==TM_ALWAYS && !rc ) {
513         if( !opt.quiet )
514             log_info(_("WARNING: Using untrusted key!\n"));
515         rc = 1;
516     }
517     return rc;
518 }
519
520
521
522 /****************
523  * Check whether we can trust this signature.
524  * Returns: Error if we shall not trust this signatures.
525  */
526 int
527 check_signatures_trust( PKT_signature *sig )
528 {
529   PKT_public_key *pk = m_alloc_clear( sizeof *pk );
530   unsigned int trustlevel;
531   int rc=0;
532
533   rc = get_pubkey( pk, sig->keyid );
534   if (rc) 
535     { /* this should not happen */
536       log_error("Ooops; the key vanished  - can't check the trust\n");
537       rc = G10ERR_NO_PUBKEY;
538       goto leave;
539     }
540
541   if ( opt.trust_model==TM_ALWAYS )
542     {
543       if( !opt.quiet )
544         log_info(_("WARNING: Using untrusted key!\n"));
545       if (opt.with_fingerprint)
546         print_fingerprint (pk, NULL, 1);
547       goto leave;
548     }
549
550   if(pk->maybe_revoked && !pk->is_revoked)
551     log_info(_("WARNING: this key might be revoked (revocation key"
552                " not present)\n"));
553
554   trustlevel = get_validity (pk, NULL);
555
556   if ( (trustlevel & TRUST_FLAG_REVOKED) ) 
557     {
558       write_status( STATUS_KEYREVOKED );
559       if(pk->is_revoked==2)
560         log_info(_("WARNING: This key has been revoked by its"
561                    " designated revoker!\n"));
562       else
563         log_info(_("WARNING: This key has been revoked by its owner!\n"));
564       log_info(_("         This could mean that the signature is forgery.\n"));
565       show_revocation_reason( pk, 0 );
566     }
567   else if ((trustlevel & TRUST_FLAG_SUB_REVOKED) ) 
568     {
569       write_status( STATUS_KEYREVOKED );
570       log_info(_("WARNING: This subkey has been revoked by its owner!\n"));
571       show_revocation_reason( pk, 0 );
572     }
573   
574   if ((trustlevel & TRUST_FLAG_DISABLED))
575     log_info (_("Note: This key has been disabled.\n"));
576
577   switch ( (trustlevel & TRUST_MASK) ) 
578     {
579     case TRUST_EXPIRED:
580       log_info(_("Note: This key has expired!\n"));
581       print_fingerprint (pk, NULL, 1);
582       break;
583         
584     default:
585       log_error ("invalid trustlevel %u returned from validation layer\n",
586                  trustlevel);
587       /* fall thru */
588     case TRUST_UNKNOWN: 
589     case TRUST_UNDEFINED:
590       write_status( STATUS_TRUST_UNDEFINED );
591       log_info(_("WARNING: This key is not certified with"
592                  " a trusted signature!\n"));
593       log_info(_("         There is no indication that the "
594                  "signature belongs to the owner.\n" ));
595       print_fingerprint (pk, NULL, 1);
596       break;
597
598     case TRUST_NEVER:
599       /* currently we won't get that status */
600       write_status( STATUS_TRUST_NEVER );
601       log_info(_("WARNING: We do NOT trust this key!\n"));
602       log_info(_("         The signature is probably a FORGERY.\n"));
603       if (opt.with_fingerprint)
604         print_fingerprint (pk, NULL, 1);
605       rc = G10ERR_BAD_SIGN;
606       break;
607
608     case TRUST_MARGINAL:
609       write_status( STATUS_TRUST_MARGINAL );
610       log_info(_("WARNING: This key is not certified with"
611                  " sufficiently trusted signatures!\n"));
612       log_info(_("         It is not certain that the"
613                  " signature belongs to the owner.\n" ));
614       print_fingerprint (pk, NULL, 1);
615       break;
616
617     case TRUST_FULLY:
618       write_status( STATUS_TRUST_FULLY );
619       if (opt.with_fingerprint)
620         print_fingerprint (pk, NULL, 1);
621       break;
622
623     case TRUST_ULTIMATE:
624       write_status( STATUS_TRUST_ULTIMATE );
625       if (opt.with_fingerprint)
626         print_fingerprint (pk, NULL, 1);
627       break;
628     }
629
630  leave:
631   free_public_key( pk );
632   return rc;
633 }
634
635
636 void
637 release_pk_list( PK_LIST pk_list )
638 {
639     PK_LIST pk_rover;
640
641     for( ; pk_list; pk_list = pk_rover ) {
642         pk_rover = pk_list->next;
643         free_public_key( pk_list->pk );
644         m_free( pk_list );
645     }
646 }
647
648
649 static int
650 key_present_in_pk_list(PK_LIST pk_list, PKT_public_key *pk)
651 {
652     for( ; pk_list; pk_list = pk_list->next)
653         if (cmp_public_keys(pk_list->pk, pk) == 0)
654             return 0;
655
656     return -1;
657 }
658
659
660 /****************
661  * Return a malloced string with a default reciepient if there is any
662  */
663 static char *
664 default_recipient(void)
665 {
666     PKT_secret_key *sk;
667     byte fpr[MAX_FINGERPRINT_LEN+1];
668     size_t n;
669     char *p;
670     int i;
671
672     if( opt.def_recipient )
673         return m_strdup( opt.def_recipient );
674     if( !opt.def_recipient_self )
675         return NULL;
676     sk = m_alloc_clear( sizeof *sk );
677     i = get_seckey_byname( sk, NULL, 0 );
678     if( i ) {
679         free_secret_key( sk );
680         return NULL;
681     }
682     n = MAX_FINGERPRINT_LEN;
683     fingerprint_from_sk( sk, fpr, &n );
684     free_secret_key( sk );
685     p = m_alloc( 2*n+3 );
686     *p++ = '0';
687     *p++ = 'x';
688     for(i=0; i < n; i++ )
689         sprintf( p+2*i, "%02X", fpr[i] );
690     p -= 2;
691     return p;
692 }
693
694 static int
695 expand_id(const char *id,STRLIST *into,unsigned int flags)
696 {
697   struct groupitem *groups;
698   int count=0;
699
700   for(groups=opt.grouplist;groups;groups=groups->next)
701     {
702       /* need strcasecmp() here, as this should be localized */
703       if(strcasecmp(groups->name,id)==0)
704         {
705           STRLIST each,sl;
706
707           /* this maintains the current utf8-ness */
708           for(each=groups->values;each;each=each->next)
709             {
710               sl=add_to_strlist(into,each->d);
711               sl->flags=flags;
712               count++;
713             }
714
715           break;
716         }
717     }
718
719   return count;
720 }
721
722 /* For simplicity, and to avoid potential loops, we only expand once -
723    you can't make an alias that points to an alias. */
724 static STRLIST
725 expand_group(STRLIST input)
726 {
727   STRLIST sl,output=NULL,rover;
728
729   for(rover=input;rover;rover=rover->next)
730     if(expand_id(rover->d,&output,rover->flags)==0)
731       {
732         /* Didn't find any groups, so use the existing string */
733         sl=add_to_strlist(&output,rover->d);
734         sl->flags=rover->flags;
735       }
736
737   return output;
738 }
739
740 int
741 build_pk_list( STRLIST rcpts, PK_LIST *ret_pk_list, unsigned use )
742 {
743     PK_LIST pk_list = NULL;
744     PKT_public_key *pk=NULL;
745     int rc=0;
746     int any_recipients=0;
747     STRLIST rov,remusr;
748     char *def_rec = NULL;
749
750     if(opt.grouplist)
751       remusr=expand_group(rcpts);
752     else
753       remusr=rcpts;
754
755     /* check whether there are any recipients in the list and build the
756      * list of the encrypt-to ones (we always trust them) */
757     for( rov = remusr; rov; rov = rov->next ) {
758         if( !(rov->flags & 1) )
759           {
760             any_recipients = 1;
761
762             if((rov->flags&2) && (PGP2 || PGP6 || PGP7 || PGP8))
763               {
764                 log_info(_("you may not use %s while in %s mode\n"),
765                          "--hidden-recipient",
766                          compliance_option_string());
767
768                 compliance_failure();
769               }
770           }
771         else if( (use & PUBKEY_USAGE_ENC) && !opt.no_encrypt_to ) {
772             pk = m_alloc_clear( sizeof *pk );
773             pk->req_usage = use;
774             /* We can encrypt-to a disabled key */
775             if( (rc = get_pubkey_byname( pk, rov->d, NULL, NULL, 1 )) ) {
776                 free_public_key( pk ); pk = NULL;
777                 log_error(_("%s: skipped: %s\n"), rov->d, g10_errstr(rc) );
778                 write_status_text_and_buffer (STATUS_INV_RECP, "0 ",
779                                               rov->d, strlen (rov->d), -1);
780                 goto fail;
781             }
782             else if( !(rc=check_pubkey_algo2(pk->pubkey_algo, use )) ) {
783                 /* Skip the actual key if the key is already present
784                  * in the list */
785                 if (key_present_in_pk_list(pk_list, pk) == 0) {
786                     free_public_key(pk); pk = NULL;
787                     log_info(_("%s: skipped: public key already present\n"),
788                                                             rov->d);
789                 }
790                 else {
791                     PK_LIST r;
792                     r = m_alloc( sizeof *r );
793                     r->pk = pk; pk = NULL;
794                     r->next = pk_list;
795                     r->flags = (rov->flags&2)?1:0;
796                     pk_list = r;
797
798                     if(r->flags&1 && (PGP2 || PGP6 || PGP7 || PGP8))
799                       {
800                         log_info(_("you may not use %s while in %s mode\n"),
801                                  "--hidden-encrypt-to",
802                                  compliance_option_string());
803
804                         compliance_failure();
805                       }
806                 }
807             }
808             else {
809                 free_public_key( pk ); pk = NULL;
810                 log_error(_("%s: skipped: %s\n"), rov->d, g10_errstr(rc) );
811                 write_status_text_and_buffer (STATUS_INV_RECP, "0 ",
812                                               rov->d, strlen (rov->d), -1);
813                 goto fail;
814             }
815         }
816     }
817
818     if( !any_recipients && !opt.batch ) { /* ask */
819         int have_def_rec;
820         char *answer=NULL;
821         STRLIST backlog=NULL;
822
823         if(pk_list)
824           any_recipients = 1;
825         def_rec = default_recipient();
826         have_def_rec = !!def_rec;
827         if( !have_def_rec )
828             tty_printf(_(
829                 "You did not specify a user ID. (you may use \"-r\")\n"));
830         for(;;) {
831             rc = 0;
832             m_free(answer);
833             if( have_def_rec ) {
834                 answer = def_rec;
835                 def_rec = NULL;
836             }
837             else if(backlog) {
838               answer=pop_strlist(&backlog);
839             }
840             else
841               {
842                 PK_LIST iter;
843
844                 tty_printf("\n");
845                 tty_printf(_("Current recipients:\n"));
846                 for(iter=pk_list;iter;iter=iter->next)
847                   {
848                     u32 keyid[2];
849
850                     keyid_from_pk(iter->pk,keyid);
851                     tty_printf("%4u%c/%08lX %s \"",
852                                nbits_from_pk(iter->pk),
853                                pubkey_letter(iter->pk->pubkey_algo),
854                                (ulong)keyid[1],
855                                datestr_from_pk(iter->pk));
856
857                     if(iter->pk->user_id)
858                       tty_print_utf8_string(iter->pk->user_id->name,
859                                             iter->pk->user_id->len);
860                     else
861                       {
862                         size_t n;
863                         char *p = get_user_id( keyid, &n );
864                         tty_print_utf8_string( p, n );
865                         m_free(p);
866                       }
867                     tty_printf("\"\n");
868                   }
869
870                 answer = cpr_get_utf8("pklist.user_id.enter",
871                          _("\nEnter the user ID.  End with an empty line: "));
872                 trim_spaces(answer);
873                 cpr_kill_prompt();
874               }
875             if( !answer || !*answer ) {
876                 m_free(answer);
877                 break;
878             }
879             if(expand_id(answer,&backlog,0))
880               continue;
881             if( pk )
882                 free_public_key( pk );
883             pk = m_alloc_clear( sizeof *pk );
884             pk->req_usage = use;
885             rc = get_pubkey_byname( pk, answer, NULL, NULL, 0 );
886             if( rc )
887                 tty_printf(_("No such user ID.\n"));
888             else if( !(rc=check_pubkey_algo2(pk->pubkey_algo, use)) ) {
889                 if( have_def_rec ) {
890                     if (key_present_in_pk_list(pk_list, pk) == 0) {
891                         free_public_key(pk); pk = NULL;
892                         log_info(_("skipped: public key "
893                                    "already set as default recipient\n") );
894                     }
895                     else {
896                         PK_LIST r = m_alloc( sizeof *r );
897                         r->pk = pk; pk = NULL;
898                         r->next = pk_list;
899                         r->flags = 0; /* no throwing default ids */
900                         pk_list = r;
901                     }
902                     any_recipients = 1;
903                     continue;
904                 }
905                 else {
906                     int trustlevel;
907                     
908                     trustlevel = get_validity (pk, pk->user_id);
909                     if( (trustlevel & TRUST_FLAG_DISABLED) ) {
910                         tty_printf(_("Public key is disabled.\n") );
911                     }
912                     else if( do_we_trust_pre( pk, trustlevel ) ) {
913                         /* Skip the actual key if the key is already present
914                          * in the list */
915                         if (key_present_in_pk_list(pk_list, pk) == 0) {
916                             free_public_key(pk); pk = NULL;
917                             log_info(_("skipped: public key already set\n") );
918                         }
919                         else {
920                             PK_LIST r;
921                             r = m_alloc( sizeof *r );
922                             r->pk = pk; pk = NULL;
923                             r->next = pk_list;
924                             r->flags = 0; /* no throwing interactive ids */
925                             pk_list = r;
926                         }
927                         any_recipients = 1;
928                         continue;
929                     }
930                 }
931             }
932             m_free(def_rec); def_rec = NULL;
933             have_def_rec = 0;
934         }
935         if( pk ) {
936             free_public_key( pk );
937             pk = NULL;
938         }
939     }
940     else if( !any_recipients && (def_rec = default_recipient()) ) {
941         pk = m_alloc_clear( sizeof *pk );
942         pk->req_usage = use;
943         /* The default recipient may be disabled */
944         rc = get_pubkey_byname( pk, def_rec, NULL, NULL, 1 );
945         if( rc )
946             log_error(_("unknown default recipient `%s'\n"), def_rec );
947         else if( !(rc=check_pubkey_algo2(pk->pubkey_algo, use)) ) {
948           /* Mark any_recipients here since the default recipient
949              would have been used if it wasn't already there.  It
950              doesn't really matter if we got this key from the default
951              recipient or an encrypt-to. */
952           any_recipients = 1;
953           if (key_present_in_pk_list(pk_list, pk) == 0)
954             log_info(_("skipped: public key already set as default recipient\n"));
955           else {
956             PK_LIST r = m_alloc( sizeof *r );
957             r->pk = pk; pk = NULL;
958             r->next = pk_list;
959             r->flags = 0; /* no throwing default ids */
960             pk_list = r;
961           }
962         }
963         if( pk ) {
964             free_public_key( pk );
965             pk = NULL;
966         }
967         m_free(def_rec); def_rec = NULL;
968     }
969     else {
970         any_recipients = 0;
971         for(; remusr; remusr = remusr->next ) {
972             if( (remusr->flags & 1) )
973                 continue; /* encrypt-to keys are already handled */
974
975             pk = m_alloc_clear( sizeof *pk );
976             pk->req_usage = use;
977             if( (rc = get_pubkey_byname( pk, remusr->d, NULL, NULL, 0 )) ) {
978                 free_public_key( pk ); pk = NULL;
979                 log_error(_("%s: skipped: %s\n"), remusr->d, g10_errstr(rc) );
980                 write_status_text_and_buffer (STATUS_INV_RECP, "0 ",
981                                               remusr->d, strlen (remusr->d),
982                                               -1);
983                 goto fail;
984             }
985             else if( !(rc=check_pubkey_algo2(pk->pubkey_algo, use )) ) {
986                 int trustlevel;
987
988                 trustlevel = get_validity (pk, pk->user_id);
989                 if( (trustlevel & TRUST_FLAG_DISABLED) ) {
990                     free_public_key(pk); pk = NULL;
991                     log_info(_("%s: skipped: public key is disabled\n"),
992                                                                     remusr->d);
993                     write_status_text_and_buffer (STATUS_INV_RECP, "0 ",
994                                                   remusr->d,
995                                                   strlen (remusr->d),
996                                                   -1);
997                     rc=G10ERR_UNU_PUBKEY;
998                     goto fail;
999                 }
1000                 else if( do_we_trust_pre( pk, trustlevel ) ) {
1001                     /* note: do_we_trust may have changed the trustlevel */
1002
1003                     /* We have at least one valid recipient. It doesn't matters
1004                      * if this recipient is already present. */
1005                     any_recipients = 1;
1006
1007                     /* Skip the actual key if the key is already present
1008                      * in the list */
1009                     if (key_present_in_pk_list(pk_list, pk) == 0) {
1010                         free_public_key(pk); pk = NULL;
1011                         log_info(_("%s: skipped: public key already present\n"),
1012                                                                     remusr->d);
1013                     }
1014                     else {
1015                         PK_LIST r;
1016                         r = m_alloc( sizeof *r );
1017                         r->pk = pk; pk = NULL;
1018                         r->next = pk_list;
1019                         r->flags = (remusr->flags&2)?1:0;
1020                         pk_list = r;
1021                     }
1022                 }
1023                 else { /* we don't trust this pk */
1024                     free_public_key( pk ); pk = NULL;
1025                     write_status_text_and_buffer (STATUS_INV_RECP, "10 ",
1026                                                   remusr->d,
1027                                                   strlen (remusr->d),
1028                                                   -1);
1029                     rc=G10ERR_UNU_PUBKEY;
1030                     goto fail;
1031                 }
1032             }
1033             else {
1034                 free_public_key( pk ); pk = NULL;
1035                 write_status_text_and_buffer (STATUS_INV_RECP, "0 ",
1036                                               remusr->d,
1037                                               strlen (remusr->d),
1038                                               -1);
1039                 log_error(_("%s: skipped: %s\n"), remusr->d, g10_errstr(rc) );
1040                 goto fail;
1041             }
1042         }
1043     }
1044
1045     if( !rc && !any_recipients ) {
1046         log_error(_("no valid addressees\n"));
1047         write_status_text (STATUS_NO_RECP, "0");
1048         rc = G10ERR_NO_USER_ID;
1049     }
1050
1051  fail:
1052
1053     if( rc )
1054         release_pk_list( pk_list );
1055     else
1056         *ret_pk_list = pk_list;
1057     if(opt.grouplist)
1058       free_strlist(remusr);
1059     return rc;
1060 }
1061
1062
1063 /* In pgp6 mode, disallow all ciphers except IDEA (1), 3DES (2), and
1064    CAST5 (3), all hashes except MD5 (1), SHA1 (2), and RIPEMD160 (3),
1065    and all compressions except none (0) and ZIP (1).  pgp7 and pgp8
1066    mode expands the cipher list to include AES128 (7), AES192 (8),
1067    AES256 (9), and TWOFISH (10).  pgp8 adds the SHA-256 hash (8).  For
1068    a true PGP key all of this is unneeded as they are the only items
1069    present in the preferences subpacket, but checking here covers the
1070    weird case of encrypting to a key that had preferences from a
1071    different implementation which was then used with PGP.  I am not
1072    completely comfortable with this as the right thing to do, as it
1073    slightly alters the list of what the user is supposedly requesting.
1074    It is not against the RFC however, as the preference chosen will
1075    never be one that the user didn't specify somewhere ("The
1076    implementation may use any mechanism to pick an algorithm in the
1077    intersection"), and PGP has no mechanism to fix such a broken
1078    preference list, so I'm including it. -dms */
1079
1080 int
1081 algo_available( preftype_t preftype, int algo, void *hint )
1082 {
1083   if( preftype == PREFTYPE_SYM )
1084     {
1085       if(PGP6 && (algo != CIPHER_ALGO_IDEA
1086                   && algo != CIPHER_ALGO_3DES
1087                   && algo != CIPHER_ALGO_CAST5))
1088         return 0;
1089       
1090       if((PGP7 || PGP8) && (algo != CIPHER_ALGO_IDEA
1091                             && algo != CIPHER_ALGO_3DES
1092                             && algo != CIPHER_ALGO_CAST5
1093                             && algo != CIPHER_ALGO_AES
1094                             && algo != CIPHER_ALGO_AES192
1095                             && algo != CIPHER_ALGO_AES256
1096                             && algo != CIPHER_ALGO_TWOFISH))
1097         return 0;
1098
1099       return algo && !check_cipher_algo( algo );
1100     }
1101   else if( preftype == PREFTYPE_HASH )
1102     {
1103       if(hint && ((*(int *)hint) != md_digest_length(algo)))
1104         return 0;
1105
1106       if((PGP6 || PGP7) && (algo != DIGEST_ALGO_MD5
1107                             && algo != DIGEST_ALGO_SHA1
1108                             && algo != DIGEST_ALGO_RMD160))
1109         return 0;
1110
1111
1112       if(PGP8 && (algo != DIGEST_ALGO_MD5
1113                   && algo != DIGEST_ALGO_SHA1
1114                   && algo != DIGEST_ALGO_RMD160
1115                   && algo != DIGEST_ALGO_SHA256))
1116         return 0;
1117
1118       return algo && !check_digest_algo( algo );
1119     }
1120   else if( preftype == PREFTYPE_ZIP )
1121     {
1122       if((PGP6 || PGP7 || PGP8) && (algo != COMPRESS_ALGO_NONE
1123                                     && algo != COMPRESS_ALGO_ZIP))
1124         return 0;
1125
1126       return !check_compress_algo( algo );
1127     }
1128   else
1129     return 0;
1130 }
1131
1132
1133
1134 /****************
1135  * Return -1 if we could not find an algorithm.
1136  */
1137 int
1138 select_algo_from_prefs(PK_LIST pk_list, int preftype, int request, void *hint)
1139 {
1140     PK_LIST pkr;
1141     u32 bits[8];
1142     const prefitem_t *prefs;
1143     int i, j;
1144     int compr_hack=0;
1145     int any;
1146
1147     if( !pk_list )
1148         return -1;
1149
1150     memset( bits, ~0, 8 * sizeof *bits );
1151     for( pkr = pk_list; pkr; pkr = pkr->next ) {
1152         u32 mask[8];
1153
1154         memset( mask, 0, 8 * sizeof *mask );
1155         if( preftype == PREFTYPE_SYM ) {
1156           if( PGP2 &&
1157               pkr->pk->version < 4 &&
1158               pkr->pk->selfsigversion < 4 )
1159             mask[0] |= (1<<1); /* IDEA is implicitly there for v3 keys
1160                                   with v3 selfsigs (rfc2440:12.1) if
1161                                   --pgp2 mode is on.  This doesn't
1162                                   mean it's actually available, of
1163                                   course. */
1164           else
1165             mask[0] |= (1<<2); /* 3DES is implicitly there for everyone else */
1166         }
1167         else if( preftype == PREFTYPE_HASH ) {
1168           /* While I am including this code for completeness, note
1169              that currently --pgp2 mode locks the hash at MD5, so this
1170              function will never even be called.  Even if the hash
1171              wasn't locked at MD5, we don't support sign+encrypt in
1172              --pgp2 mode, and that's the only time PREFTYPE_HASH is
1173              used anyway. -dms */
1174           if( PGP2 &&
1175               pkr->pk->version < 4 &&
1176               pkr->pk->selfsigversion < 4 )
1177             mask[0] |= (1<<1); /* MD5 is there for v3 keys with v3
1178                                   selfsigs when --pgp2 is on. */
1179           else
1180             mask[0] |= (1<<2); /* SHA1 is there for everyone else */
1181         }
1182         else if( preftype == PREFTYPE_ZIP )
1183           mask[0] |= (1<<0); /* Uncompressed is implicit */
1184
1185         if (pkr->pk->user_id) /* selected by user ID */
1186             prefs = pkr->pk->user_id->prefs;
1187         else
1188             prefs = pkr->pk->prefs;
1189
1190         any = 0;
1191         if( prefs ) {
1192             for (i=0; prefs[i].type; i++ ) {
1193                 if( prefs[i].type == preftype ) {
1194                     mask[prefs[i].value/32] |= 1 << (prefs[i].value%32);
1195                     any = 1;
1196                 }
1197             }
1198         }
1199
1200         if( (!prefs || !any) && preftype == PREFTYPE_ZIP ) {
1201             mask[0] |= 3; /* asume no_compression and old pgp */
1202             compr_hack = 1;
1203         }
1204
1205 #if 0
1206         log_debug("pref mask=%08lX%08lX%08lX%08lX%08lX%08lX%08lX%08lX\n",
1207                (ulong)mask[7], (ulong)mask[6], (ulong)mask[5], (ulong)mask[4],
1208              (ulong)mask[3], (ulong)mask[2], (ulong)mask[1], (ulong)mask[0]);
1209 #endif
1210         for(i=0; i < 8; i++ )
1211             bits[i] &= mask[i];
1212 #if 0
1213         log_debug("pref bits=%08lX%08lX%08lX%08lX%08lX%08lX%08lX%08lX\n",
1214                (ulong)bits[7], (ulong)bits[6], (ulong)bits[5], (ulong)bits[4],
1215              (ulong)bits[3], (ulong)bits[2], (ulong)bits[1], (ulong)bits[0]);
1216 #endif
1217     }
1218     /* usable algorithms are now in bits
1219      * We now use the last key from pk_list to select
1220      * the algorithm we want to use. there are no
1221      * preferences for the last key, we select the one
1222      * corresponding to first set bit.
1223      */
1224     i = -1;
1225     any = 0;
1226
1227     /* Can we use the requested algorithm? */
1228     if(request>-1 && (bits[request/32] & (1<<(request%32))) &&
1229        algo_available(preftype,request,hint))
1230       return request;
1231
1232     /* If we have personal prefs set, use them instead of the last key */
1233     if(preftype==PREFTYPE_SYM && opt.personal_cipher_prefs)
1234       prefs=opt.personal_cipher_prefs;
1235     else if(preftype==PREFTYPE_HASH && opt.personal_digest_prefs)
1236       prefs=opt.personal_digest_prefs;
1237     else if(preftype==PREFTYPE_ZIP && opt.personal_compress_prefs)
1238       prefs=opt.personal_compress_prefs;
1239
1240     if( prefs ) {
1241         for(j=0; prefs[j].type; j++ ) {
1242             if( prefs[j].type == preftype ) {
1243                 if( (bits[prefs[j].value/32] & (1<<(prefs[j].value%32))) ) {
1244                     if( algo_available( preftype, prefs[j].value, hint ) ) {
1245                         any = 1;
1246                         i = prefs[j].value;
1247                         break;
1248                     }
1249                 }
1250             }
1251         }
1252     }
1253     if( !prefs || !any ) {
1254         for(j=0; j < 256; j++ )
1255             if( (bits[j/32] & (1<<(j%32))) ) {
1256                 if( algo_available( preftype, j, hint ) ) {
1257                     i = j;
1258                     break;
1259                 }
1260             }
1261     }
1262
1263 #if 0
1264     log_debug("prefs of type %d: selected %d\n", preftype, i );
1265 #endif
1266     if( compr_hack && !i ) {
1267         /* selected no compression, but we should check whether
1268          * algorithm 1 is also available (the ordering is not relevant
1269          * in this case). */
1270         if( bits[0] & (1<<1) )
1271             i = 1; /* yep; we can use compression algo 1 */
1272     }
1273
1274     /* "If you are building an authentication system, the recipient
1275        may specify a preferred signing algorithm. However, the signer
1276        would be foolish to use a weak algorithm simply because the
1277        recipient requests it." RFC2440:13.  If we settle on MD5, and
1278        SHA1 is also available, use SHA1 instead.  Of course, if the
1279        user intentionally chose MD5 (by putting it in their personal
1280        prefs), then we should do what they say. */
1281
1282     if(preftype==PREFTYPE_HASH &&
1283        i==DIGEST_ALGO_MD5 && (bits[0] & (1<<DIGEST_ALGO_SHA1)))
1284       {
1285         i=DIGEST_ALGO_SHA1;
1286
1287         if(opt.personal_digest_prefs)
1288           for(j=0; prefs[j].type; j++ )
1289             if(opt.personal_digest_prefs[j].type==PREFTYPE_HASH &&
1290                opt.personal_digest_prefs[j].value==DIGEST_ALGO_MD5)
1291               {
1292                 i=DIGEST_ALGO_MD5;
1293                 break;
1294               }
1295       }
1296
1297     return i;
1298 }
1299
1300 /*
1301  * Select the MDC flag from the pk_list.  We can only use MDC if all recipients
1302  * support this feature 
1303  */
1304 int
1305 select_mdc_from_pklist (PK_LIST pk_list)
1306 {
1307     PK_LIST pkr;
1308
1309     if( !pk_list )
1310         return 0;
1311
1312     for (pkr = pk_list; pkr; pkr = pkr->next) {
1313         int mdc;
1314
1315         if (pkr->pk->user_id) /* selected by user ID */
1316             mdc = pkr->pk->user_id->mdc_feature;
1317         else
1318             mdc = pkr->pk->mdc_feature;
1319         if (!mdc)
1320             return 0; /* at least one recipient does not support it */
1321     }
1322     return 1; /* can be used */
1323 }