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