See ChangeLog: Mon Sep 18 16:35:45 CEST 2000 Werner Koch
[gnupg.git] / g10 / pkclist.c
1 /* pkclist.c
2  *      Copyright (C) 1998, 1999, 2000 Free Software Foundation, Inc.
3  *
4  * This file is part of GnuPG.
5  *
6  * GnuPG is free software; you can redistribute it and/or modify
7  * it under the terms of the GNU General Public License as published by
8  * the Free Software Foundation; either version 2 of the License, or
9  * (at your option) any later version.
10  *
11  * GnuPG is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14  * GNU General Public License for more details.
15  *
16  * You should have received a copy of the GNU General Public License
17  * along with this program; if not, write to the Free Software
18  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
19  */
20
21 #include <config.h>
22 #include <stdio.h>
23 #include <stdlib.h>
24 #include <string.h>
25 #include <errno.h>
26 #include <assert.h>
27
28 #include <gcrypt.h>
29 #include "options.h"
30 #include "packet.h"
31 #include "errors.h"
32 #include "keydb.h"
33 #include "util.h"
34 #include "trustdb.h"
35 #include "ttyio.h"
36 #include "status.h"
37 #include "i18n.h"
38 #include "main.h"
39
40
41 #define CONTROL_D ('D' - 'A' + 1)
42
43 /* fixme: we have nearly the same code in keyedit.c */
44 static void
45 print_fpr( PKT_public_key *pk )
46 {
47     byte array[MAX_FINGERPRINT_LEN], *p;
48     size_t i, n;
49
50     fingerprint_from_pk( pk, array, &n );
51     p = array;
52     /* Translators: this shoud fit into 24 bytes to that the fingerprint
53      * data is properly aligned with the user ID */
54     tty_printf(_("             Fingerprint:"));
55     if( n == 20 ) {
56         for(i=0; i < n ; i++, i++, p += 2 ) {
57             if( i == 10 )
58                 tty_printf(" ");
59             tty_printf(" %02X%02X", *p, p[1] );
60         }
61     }
62     else {
63         for(i=0; i < n ; i++, p++ ) {
64             if( i && !(i%8) )
65                 tty_printf(" ");
66             tty_printf(" %02X", *p );
67         }
68     }
69     tty_printf("\n");
70 }
71
72 static void
73 fpr_info( PKT_public_key *pk )
74 {
75     byte array[MAX_FINGERPRINT_LEN], *p;
76     size_t i, n;
77     FILE *fp = log_stream();
78
79     fingerprint_from_pk( pk, array, &n );
80     p = array;
81     log_info(_("Fingerprint:"));
82     if( n == 20 ) {
83         for(i=0; i < n ; i++, i++, p += 2 ) {
84             if( i == 10 )
85                 putc(' ', fp);
86             fprintf(fp, " %02X%02X", *p, p[1] );
87         }
88     }
89     else {
90         for(i=0; i < n ; i++, p++ ) {
91             if( i && !(i%8) )
92                 putc(' ', fp);
93             fprintf(fp, " %02X", *p );
94         }
95     }
96     putc('\n', fp );
97 }
98
99
100 /****************
101  * Show the revocation reason as it is stored with the given signature
102  */
103 static void
104 do_show_revocation_reason( PKT_signature *sig )
105 {
106     size_t n, nn;
107     const byte *p, *pp;
108     int seq = 0;
109     const char *text;
110
111     while( (p = enum_sig_subpkt( sig->hashed_data, SIGSUBPKT_REVOC_REASON,
112                                  &n, &seq )) ) {
113         if( !n )
114             continue; /* invalid - just skip it */
115
116         if( *p == 0 )
117             text = _("No reason specified");
118         else if( *p == 0x01 )
119             text = _("Key is superseeded");
120         else if( *p == 0x02 )
121             text = _("Key has been compromised");
122         else if( *p == 0x03 )
123             text = _("Key is no longer used");
124         else if( *p == 0x20 )
125             text = _("User ID is no longer valid");
126         else
127             text = NULL;
128
129         log_info( _("Reason for revocation: ") );
130         if( text )
131             fputs( text, log_stream() );
132         else
133             fprintf( log_stream(), "code=%02x", *p );
134         putc( '\n', log_stream() );
135         n--; p++;
136         pp = NULL;
137         do {
138             /* We don't want any empty lines, so skip them */
139             while( n && *p == '\n' ) {
140                 p++;
141                 n--;
142             }
143             if( n ) {
144                 pp = memchr( p, '\n', n );
145                 nn = pp? pp - p : n;
146                 log_info( _("Revocation comment: ") );
147                 print_string( log_stream(), p, nn, 0 );
148                 putc( '\n', log_stream() );
149                 p += nn; n -= nn;
150             }
151         } while( pp );
152     }
153 }
154
155
156 static void
157 show_revocation_reason( PKT_public_key *pk )
158 {
159     /* Hmmm, this is not so easy becuase we have to duplicate the code
160      * used in the trustbd to calculate the keyflags.  We need to find
161      * a clean way to check revocation certificates on keys and signatures.
162      * And there should be no duplicate code.  Because we enter this function
163      * only when the trustdb toldus, taht we have a revoked key, we could
164      * simplylook for a revocation cert and display this one, when there is
165      * only one. Let's try to do this until we have a better solution.
166      */
167     KBNODE node, keyblock = NULL;
168     byte fingerprint[MAX_FINGERPRINT_LEN];
169     size_t fingerlen;
170     int rc;
171
172     /* get the keyblock */
173     fingerprint_from_pk( pk, fingerprint, &fingerlen );
174     rc = get_keyblock_byfprint( &keyblock, fingerprint, fingerlen );
175     if( rc ) { /* that should never happen */
176         log_debug( "failed to get the keyblock\n");
177         return;
178     }
179
180     for( node=keyblock; node; node = node->next ) {
181         if( ( node->pkt->pkttype == PKT_PUBLIC_KEY
182               || node->pkt->pkttype == PKT_PUBLIC_SUBKEY )
183             && !cmp_public_keys( node->pkt->pkt.public_key, pk ) )
184             break;
185     }
186     if( !node ) {
187         log_debug("Oops, PK not in keyblock\n");
188         release_kbnode( keyblock );
189         return;
190     }
191     /* now find the revocation certificate */
192     for( node = node->next; node ; node = node->next ) {
193         if( node->pkt->pkttype == PKT_PUBLIC_SUBKEY )
194             break;
195         if( node->pkt->pkttype == PKT_SIGNATURE
196             && (node->pkt->pkt.signature->sig_class == 0x20
197                 || node->pkt->pkt.signature->sig_class == 0x28 ) ) {
198                 /* FIXME: we should check the signature here */
199                 do_show_revocation_reason ( node->pkt->pkt.signature );
200         }
201     }
202
203     release_kbnode( keyblock );
204 }
205
206
207 static void
208 show_paths( ulong lid, int only_first )
209 {
210     void *context = NULL;
211     unsigned otrust, validity;
212     int last_level, level;
213
214     last_level = 0;
215     while( (level=enum_cert_paths( &context, &lid, &otrust, &validity)) != -1){
216         char *p;
217         int c, rc;
218         size_t n;
219         u32 keyid[2];
220         PKT_public_key *pk ;
221
222         if( level < last_level && only_first )
223             break;
224         last_level = level;
225
226         rc = keyid_from_lid( lid, keyid );
227         if( rc ) {
228             log_error("ooops: can't get keyid for lid %lu\n", lid);
229             return;
230         }
231
232         pk = gcry_xcalloc( 1, sizeof *pk );
233         rc = get_pubkey( pk, keyid );
234         if( rc ) {
235             log_error("key %08lX: public key not found: %s\n",
236                                     (ulong)keyid[1], gpg_errstr(rc) );
237             return;
238         }
239
240         tty_printf("%*s%4u%c/%08lX.%lu %s \"",
241                   level*2, "",
242                   nbits_from_pk( pk ), pubkey_letter( pk->pubkey_algo ),
243                   (ulong)keyid[1], lid, datestr_from_pk( pk ) );
244
245         c = trust_letter(otrust);
246         if( c )
247             putchar( c );
248         else
249             printf( "%02x", otrust );
250         putchar('/');
251         c = trust_letter(validity);
252         if( c )
253             putchar( c );
254         else
255             printf( "%02x", validity );
256         putchar(' ');
257
258         p = get_user_id( keyid, &n );
259         tty_print_utf8_string( p, n ),
260         gcry_free(p);
261         tty_printf("\"\n");
262         free_public_key( pk );
263     }
264     enum_cert_paths( &context, NULL, NULL, NULL ); /* release context */
265     tty_printf("\n");
266 }
267
268
269
270
271 /****************
272  * Returns true if an ownertrust has changed.
273  */
274 static int
275 do_edit_ownertrust( ulong lid, int mode, unsigned *new_trust, int defer_help )
276 {
277     char *p;
278     int rc;
279     size_t n;
280     u32 keyid[2];
281     PKT_public_key *pk ;
282     int changed=0;
283     int quit=0;
284     int show=0;
285     int did_help=defer_help;
286
287     rc = keyid_from_lid( lid, keyid );
288     if( rc ) {
289         log_error("ooops: can't get keyid for lid %lu\n", lid);
290         return 0;
291     }
292
293     pk = gcry_xcalloc( 1, sizeof *pk );
294     rc = get_pubkey( pk, keyid );
295     if( rc ) {
296         log_error("key %08lX: public key not found: %s\n",
297                                 (ulong)keyid[1], gpg_errstr(rc) );
298         return 0;
299     }
300
301
302     for(;;) {
303         /* a string with valid answers */
304         const char *ans = _("sSmMqQ");
305
306         if( !did_help ) {
307             if( !mode ) {
308                 tty_printf(_("No trust value assigned to %lu:\n"
309                            "%4u%c/%08lX %s \""), lid,
310                           nbits_from_pk( pk ), pubkey_letter( pk->pubkey_algo ),
311                           (ulong)keyid[1], datestr_from_pk( pk ) );
312                 p = get_user_id( keyid, &n );
313                 tty_print_utf8_string( p, n ),
314                 gcry_free(p);
315                 tty_printf("\"\n");
316                 print_fpr( pk );
317                 tty_printf("\n");
318             }
319             tty_printf(_(
320 "Please decide how far you trust this user to correctly\n"
321 "verify other users' keys (by looking at passports,\n"
322 "checking fingerprints from different sources...)?\n\n"
323 " 1 = Don't know\n"
324 " 2 = I do NOT trust\n"
325 " 3 = I trust marginally\n"
326 " 4 = I trust fully\n"
327 " s = please show me more information\n") );
328             if( mode )
329                 tty_printf(_(" m = back to the main menu\n"));
330             else
331                 tty_printf(_(" q = quit\n"));
332             tty_printf("\n");
333             did_help = 1;
334         }
335         if( strlen(ans) != 6 )
336             BUG();
337         p = cpr_get("edit_ownertrust.value",_("Your decision? "));
338         trim_spaces(p);
339         cpr_kill_prompt();
340         if( !*p )
341             did_help = 0;
342         else if( *p && p[1] )
343             ;
344         else if( !p[1] && (*p >= '1' && *p <= '4') ) {
345             unsigned trust;
346             switch( *p ) {
347               case '1': trust = TRUST_UNDEFINED; break;
348               case '2': trust = TRUST_NEVER    ; break;
349               case '3': trust = TRUST_MARGINAL ; break;
350               case '4': trust = TRUST_FULLY    ; break;
351               default: BUG();
352             }
353             *new_trust = trust;
354             changed = 1;
355             break;
356         }
357         else if( *p == ans[0] || *p == ans[1] ) {
358             tty_printf(_(
359                 "Certificates leading to an ultimately trusted key:\n"));
360             show = 1;
361             break;
362         }
363         else if( mode && (*p == ans[2] || *p == ans[3] || *p == CONTROL_D ) ) {
364             break ; /* back to the menu */
365         }
366         else if( !mode && (*p == ans[4] || *p == ans[5] ) ) {
367             quit = 1;
368             break ; /* back to the menu */
369         }
370         gcry_free(p); p = NULL;
371     }
372     gcry_free(p);
373     gcry_free(pk);
374     return show? -2: quit? -1 : changed;
375 }
376
377
378 int
379 edit_ownertrust( ulong lid, int mode )
380 {
381     unsigned int trust;
382     int no_help = 0;
383
384     for(;;) {
385         switch( do_edit_ownertrust( lid, mode, &trust, no_help ) ) {
386           case -1:
387             return 0;
388           case -2:
389             show_paths( lid, 1  );
390             no_help = 1;
391             break;
392           case 1:
393             trust &= ~TRUST_FLAG_DISABLED;
394             trust |= get_ownertrust( lid ) & TRUST_FLAG_DISABLED;
395             if( !update_ownertrust( lid, trust ) )
396                 return 1;
397             return 0;
398           default:
399             return 0;
400         }
401     }
402 }
403
404 static int
405 add_ownertrust_cb( ulong lid )
406 {
407     unsigned trust;
408     int rc = do_edit_ownertrust( lid, 0, &trust, 0 );
409
410     if( rc == 1 )
411         return trust & TRUST_MASK;
412     return rc > 0? 0 : rc;
413 }
414
415 /****************
416  * Try to add some more owner trusts (interactive)
417  * This function presents all the signator in a certificate
418  * chain who have no ownertrust value assigned.
419  * Returns: -1 if no ownertrust were added.
420  */
421 static int
422 add_ownertrust( PKT_public_key *pk, int *quit, unsigned *trustlevel )
423 {
424     int rc;
425     unsigned flags = 0;
426
427     *quit = 0;
428     *trustlevel = 0;
429     tty_printf(
430 _("Could not find a valid trust path to the key.  Let's see whether we\n"
431   "can assign some missing owner trust values.\n\n"));
432
433     rc = check_trust( pk, trustlevel, NULL, add_ownertrust_cb, &flags );
434
435     if( !(flags & 1) )
436         tty_printf(_("No path leading to one of our keys found.\n\n") );
437     else if( !(flags & 2) )
438         tty_printf(_("No certificates with undefined trust found.\n\n") );
439     else if( !(flags & 4) )
440         tty_printf(_("No trust values changed.\n\n") );
441
442     return (flags & 4)? 0:-1;
443 }
444
445 /****************
446  * Check whether we can trust this pk which has a trustlevel of TRUSTLEVEL
447  * Returns: true if we trust. Might change the trustlevel
448  */
449 static int
450 do_we_trust( PKT_public_key *pk, int *trustlevel )
451 {
452     int rc;
453     int did_add = 0;
454     int trustmask = 0;
455
456   retry:
457     if( (*trustlevel & TRUST_FLAG_REVOKED) ) {
458         log_info(_("key %08lX: key has been revoked!\n"),
459                                         (ulong)keyid_from_pk( pk, NULL) );
460         show_revocation_reason( pk );
461         if( opt.batch )
462             return 0;
463
464         if( !cpr_get_answer_is_yes("revoked_key.override",
465                                     _("Use this key anyway? ")) )
466             return 0;
467         trustmask |= TRUST_FLAG_REVOKED;
468     }
469     else if( (*trustlevel & TRUST_FLAG_SUB_REVOKED) ) {
470         log_info(_("key %08lX: subkey has been revoked!\n"),
471                                         (ulong)keyid_from_pk( pk, NULL) );
472         show_revocation_reason( pk );
473         if( opt.batch )
474             return 0;
475
476         if( !cpr_get_answer_is_yes("revoked_key.override",
477                                     _("Use this key anyway? ")) )
478             return 0;
479         trustmask |= TRUST_FLAG_SUB_REVOKED;
480     }
481     *trustlevel &= ~trustmask;
482
483     if( opt.always_trust) {
484         if( opt.verbose )
485             log_info("No trust check due to --always-trust option\n");
486         /* The problem with this, is that EXPIRE can't be checked as
487          * this needs to insert a ne key into the trustdb first and
488          * we don't want that */
489         return 1;
490     }
491
492
493     switch( (*trustlevel & TRUST_MASK) ) {
494       case TRUST_UNKNOWN: /* No pubkey in trustDB: Insert and check again */
495         rc = insert_trust_record_by_pk( pk );
496         if( rc ) {
497             log_error("failed to insert it into the trustdb: %s\n",
498                                                       gpg_errstr(rc) );
499             return 0; /* no */
500         }
501         rc = check_trust( pk, trustlevel, NULL, NULL, NULL );
502         *trustlevel &= ~trustmask;
503         if( rc )
504             log_fatal("trust check after insert failed: %s\n",
505                                                       gpg_errstr(rc) );
506         if( *trustlevel == TRUST_UNKNOWN || *trustlevel == TRUST_EXPIRED ) {
507             log_debug("do_we_trust: oops at %d\n", __LINE__ );
508             return 0;
509         }
510         return do_we_trust( pk, trustlevel );
511
512       case TRUST_EXPIRED:
513         log_info(_("%08lX: key has expired\n"),
514                                     (ulong)keyid_from_pk( pk, NULL) );
515         return 0; /* no */
516
517       case TRUST_UNDEFINED:
518         if( opt.batch || opt.answer_no )
519             log_info(_("%08lX: no info to calculate a trust probability\n"),
520                                         (ulong)keyid_from_pk( pk, NULL) );
521         else {
522             int quit;
523
524             rc = add_ownertrust( pk, &quit, trustlevel );
525             *trustlevel &= ~trustmask;
526             if( !rc && !did_add && !quit ) {
527                 did_add = 1;
528                 goto retry;
529             }
530         }
531         return 0;
532
533       case TRUST_NEVER:
534         log_info(_("%08lX: We do NOT trust this key\n"),
535                                         (ulong)keyid_from_pk( pk, NULL) );
536         return 0; /* no */
537
538       case TRUST_MARGINAL:
539         log_info(
540        _("%08lX: It is not sure that this key really belongs to the owner\n"
541          "but it is accepted anyway\n"), (ulong)keyid_from_pk( pk, NULL) );
542         return 1; /* yes */
543
544       case TRUST_FULLY:
545         if( opt.verbose )
546             log_info(_("This key probably belongs to the owner\n"));
547         return 1; /* yes */
548
549       case TRUST_ULTIMATE:
550         if( opt.verbose )
551             log_info(_("This key belongs to us\n"));
552         return 1; /* yes */
553
554       default: BUG();
555     }
556
557     return 1; /* yes */
558 }
559
560
561
562 /****************
563  * wrapper around do_we_trust, so we can ask whether to use the
564  * key anyway.
565  */
566 static int
567 do_we_trust_pre( PKT_public_key *pk, int trustlevel )
568 {
569     int rc;
570
571     rc = do_we_trust( pk, &trustlevel );
572
573     if( (trustlevel & TRUST_FLAG_REVOKED) && !rc )
574         return 0;
575     if( (trustlevel & TRUST_FLAG_SUB_REVOKED) && !rc )
576         return 0;
577     else if( !opt.batch && !rc ) {
578         char *p;
579         u32 keyid[2];
580         size_t n;
581
582         keyid_from_pk( pk, keyid);
583         tty_printf( "%4u%c/%08lX %s \"",
584                   nbits_from_pk( pk ), pubkey_letter( pk->pubkey_algo ),
585                   (ulong)keyid[1], datestr_from_pk( pk ) );
586         p = get_user_id( keyid, &n );
587         tty_print_utf8_string( p, n ),
588         gcry_free(p);
589         tty_printf("\"\n");
590         print_fpr( pk );
591         tty_printf("\n");
592
593         tty_printf(_(
594 "It is NOT certain that the key belongs to its owner.\n"
595 "If you *really* know what you are doing, you may answer\n"
596 "the next question with yes\n\n") );
597
598         if( cpr_get_answer_is_yes("untrusted_key.override",
599                                   _("Use this key anyway? "))  )
600             rc = 1;
601
602         /* Hmmm: Should we set a flag to tell the user the user about
603          *       his decision the next time he encrypts for this recipient?
604          */
605     }
606     else if( opt.always_trust && !rc ) {
607         if( !opt.quiet )
608             log_info(_("WARNING: Using untrusted key!\n"));
609         rc = 1;
610     }
611     return rc;
612 }
613
614
615
616 /****************
617  * Check whether we can trust this signature.
618  * Returns: Error if we shall not trust this signatures.
619  */
620 int
621 check_signatures_trust( PKT_signature *sig )
622 {
623     PKT_public_key *pk = gcry_xcalloc( 1, sizeof *pk );
624     int trustlevel;
625     int did_add = 0;
626     int rc=0;
627
628
629     if( opt.always_trust ) {
630         if( !opt.quiet )
631             log_info(_("WARNING: Using untrusted key!\n"));
632         return 0;
633     }
634
635
636     rc = get_pubkey( pk, sig->keyid );
637     if( rc ) { /* this should not happen */
638         log_error("Ooops; the key vanished  - can't check the trust\n");
639         rc = GPGERR_NO_PUBKEY;
640         goto leave;
641     }
642
643     rc = check_trust( pk, &trustlevel, NULL, NULL, NULL );
644     if( rc ) {
645         log_error("check trust failed: %s\n", gpg_errstr(rc));
646         goto leave;
647     }
648
649   retry:
650     if( (trustlevel & TRUST_FLAG_REVOKED) ) {
651         write_status( STATUS_KEYREVOKED );
652         log_info(_("WARNING: This key has been revoked by its owner!\n"));
653         log_info(_("         This could mean that the signature is forgery.\n"));
654         show_revocation_reason( pk );
655     }
656     else if( (trustlevel & TRUST_FLAG_SUB_REVOKED) ) {
657         write_status( STATUS_KEYREVOKED );
658         log_info(_("WARNING: This subkey has been revoked by its owner!\n"));
659         show_revocation_reason( pk );
660     }
661
662
663     switch( (trustlevel & TRUST_MASK) ) {
664       case TRUST_UNKNOWN: /* No pubkey in trustDB: Insert and check again */
665         rc = insert_trust_record_by_pk( pk );
666         if( rc ) {
667             log_error("failed to insert it into the trustdb: %s\n",
668                                                       gpg_errstr(rc) );
669             goto leave;
670         }
671         rc = check_trust( pk, &trustlevel, NULL, NULL, NULL );
672         if( rc )
673             log_fatal("trust check after insert failed: %s\n",
674                                                       gpg_errstr(rc) );
675         if( trustlevel == TRUST_UNKNOWN || trustlevel == TRUST_EXPIRED )
676             BUG();
677         goto retry;
678
679       case TRUST_EXPIRED:
680         log_info(_("Note: This key has expired!\n"));
681         fpr_info( pk );
682         break;
683
684       case TRUST_UNDEFINED:
685         if( did_add || opt.batch || opt.answer_no ) {
686             write_status( STATUS_TRUST_UNDEFINED );
687             log_info(_(
688             "WARNING: This key is not certified with a trusted signature!\n"));
689             log_info(_(
690             "         There is no indication that the "
691                                     "signature belongs to the owner.\n" ));
692             fpr_info( pk );
693         }
694         else {
695             int quit;
696             rc = add_ownertrust( pk, &quit, &trustlevel );
697             if( rc || quit ) {
698                 did_add = 1;
699                 rc = 0;
700             }
701             goto retry;
702         }
703         break;
704
705       case TRUST_NEVER:
706         write_status( STATUS_TRUST_NEVER );
707         log_info(_("WARNING: We do NOT trust this key!\n"));
708         log_info(_("         The signature is probably a FORGERY.\n"));
709         rc = GPGERR_BAD_SIGN;
710         break;
711
712       case TRUST_MARGINAL:
713         write_status( STATUS_TRUST_MARGINAL );
714         log_info(_(
715          "WARNING: This key is not certified with sufficiently trusted signatures!\n"
716                 ));
717         log_info(_(
718          "         It is not certain that the signature belongs to the owner.\n"
719                  ));
720         fpr_info( pk );
721         break;
722
723       case TRUST_FULLY:
724         write_status( STATUS_TRUST_FULLY );
725         break;
726
727       case TRUST_ULTIMATE:
728         write_status( STATUS_TRUST_ULTIMATE );
729         break;
730
731       default: BUG();
732     }
733
734
735   leave:
736     free_public_key( pk );
737     return rc;
738 }
739
740
741 void
742 release_pk_list( PK_LIST pk_list )
743 {
744     PK_LIST pk_rover;
745
746     for( ; pk_list; pk_list = pk_rover ) {
747         pk_rover = pk_list->next;
748         free_public_key( pk_list->pk );
749         gcry_free( pk_list );
750     }
751 }
752
753
754 static int
755 key_present_in_pk_list(PK_LIST pk_list, PKT_public_key *pk)
756 {
757     for( ; pk_list; pk_list = pk_list->next)
758         if (cmp_public_keys(pk_list->pk, pk) == 0)
759             return 0;
760
761     return -1;
762 }
763
764
765 /****************
766  * Return a malloced string with a default reciepient if there is any
767  */
768 static char *
769 default_recipient(void)
770 {
771     PKT_secret_key *sk;
772     byte fpr[MAX_FINGERPRINT_LEN+1];
773     size_t n;
774     char *p;
775     int i;
776
777     if( opt.def_recipient )
778         return gcry_xstrdup( opt.def_recipient );
779     if( !opt.def_recipient_self )
780         return NULL;
781     sk = gcry_xcalloc( 1, sizeof *sk );
782     i = get_seckey_byname( sk, NULL, 0 );
783     if( i ) {
784         free_secret_key( sk );
785         return NULL;
786     }
787     n = MAX_FINGERPRINT_LEN;
788     fingerprint_from_sk( sk, fpr, &n );
789     free_secret_key( sk );
790     p = gcry_xmalloc( 2*n+3 );
791     *p++ = '0';
792     *p++ = 'x';
793     for(i=0; i < n; i++ )
794         sprintf( p+2*i, "%02X", fpr[i] );
795     p -= 2;
796     return p;
797 }
798
799
800 int
801 build_pk_list( STRLIST remusr, PK_LIST *ret_pk_list, unsigned use )
802 {
803     PK_LIST pk_list = NULL;
804     PKT_public_key *pk=NULL;
805     int rc=0;
806     int any_recipients=0;
807     STRLIST rov;
808     char *def_rec = NULL;
809
810     /* check whether there are any recipients in the list and build the
811      * list of the encrypt-to ones (we always trust them) */
812     for( rov = remusr; rov; rov = rov->next ) {
813         if( !(rov->flags & 1) )
814             any_recipients = 1;
815         else if( (use & GCRY_PK_USAGE_ENCR) && !opt.no_encrypt_to ) {
816             pk = gcry_xcalloc( 1, sizeof *pk );
817             pk->req_usage = use;
818             if( (rc = get_pubkey_byname( NULL, pk, rov->d, NULL )) ) {
819                 free_public_key( pk ); pk = NULL;
820                 log_error(_("%s: skipped: %s\n"), rov->d, gpg_errstr(rc) );
821             }
822             else if( !(rc=openpgp_pk_test_algo(pk->pubkey_algo, use )) ) {
823                 /* Skip the actual key if the key is already present
824                  * in the list */
825                 if (key_present_in_pk_list(pk_list, pk) == 0) {
826                     free_public_key(pk); pk = NULL;
827                     log_info(_("%s: skipped: public key already present\n"),
828                                                             rov->d);
829                 }
830                 else {
831                     PK_LIST r;
832                     r = gcry_xmalloc( sizeof *r );
833                     r->pk = pk; pk = NULL;
834                     r->next = pk_list;
835                     r->mark = 0;
836                     pk_list = r;
837                 }
838             }
839             else {
840                 free_public_key( pk ); pk = NULL;
841                 log_error(_("%s: skipped: %s\n"), rov->d, gpg_errstr(rc) );
842             }
843         }
844     }
845
846     if( !any_recipients && !opt.batch ) { /* ask */
847         char *answer=NULL;
848         int have_def_rec;
849
850         def_rec = default_recipient();
851         have_def_rec = !!def_rec;
852         if( !have_def_rec )
853             tty_printf(_(
854                 "You did not specify a user ID. (you may use \"-r\")\n\n"));
855         for(;;) {
856             rc = 0;
857             gcry_free(answer);
858             if( have_def_rec ) {
859                 answer = def_rec;
860                 def_rec = NULL;
861             }
862             else {
863                 answer = cpr_get_utf8("pklist.user_id.enter",
864                                        _("Enter the user ID: "));
865                 trim_spaces(answer);
866                 cpr_kill_prompt();
867             }
868             if( !*answer )
869                 break;
870             if( pk )
871                 free_public_key( pk );
872             pk = gcry_xcalloc( 1, sizeof *pk );
873             pk->req_usage = use;
874             rc = get_pubkey_byname( NULL, pk, answer, NULL );
875             if( rc )
876                 tty_printf(_("No such user ID.\n"));
877             else if( !(rc=openpgp_pk_test_algo(pk->pubkey_algo, use)) ) {
878                 if( have_def_rec ) {
879                     if (key_present_in_pk_list(pk_list, pk) == 0) {
880                         free_public_key(pk); pk = NULL;
881                         log_info(_("skipped: public key "
882                                    "already set as default recipient\n") );
883                     }
884                     else {
885                         PK_LIST r = gcry_xmalloc( sizeof *r );
886                         r->pk = pk; pk = NULL;
887                         r->next = pk_list;
888                         r->mark = 0;
889                         pk_list = r;
890                     }
891                     any_recipients = 1;
892                     break;
893                 }
894                 else {
895                     int trustlevel;
896
897                     rc = check_trust( pk, &trustlevel, pk->namehash,
898                                                        NULL, NULL );
899                     if( rc ) {
900                         log_error("error checking pk of `%s': %s\n",
901                                                      answer, gpg_errstr(rc) );
902                     }
903                     else if( (trustlevel & TRUST_FLAG_DISABLED) ) {
904                         tty_printf(_("Public key is disabled.\n") );
905                     }
906                     else if( do_we_trust_pre( pk, trustlevel ) ) {
907                         /* Skip the actual key if the key is already present
908                          * in the list */
909                         if (key_present_in_pk_list(pk_list, pk) == 0) {
910                             free_public_key(pk); pk = NULL;
911                             log_info(_("skipped: public key "
912                                        "already set with --encrypt-to\n") );
913                         }
914                         else {
915                             PK_LIST r;
916
917                             r = gcry_xmalloc( sizeof *r );
918                             r->pk = pk; pk = NULL;
919                             r->next = pk_list;
920                             r->mark = 0;
921                             pk_list = r;
922                         }
923                         any_recipients = 1;
924                         break;
925                     }
926                 }
927             }
928             gcry_free(def_rec); def_rec = NULL;
929             have_def_rec = 0;
930         }
931         gcry_free(answer);
932         if( pk ) {
933             free_public_key( pk );
934             pk = NULL;
935         }
936     }
937     else if( !any_recipients && (def_rec = default_recipient()) ) {
938         pk = gcry_xcalloc( 1, sizeof *pk );
939         pk->req_usage = use;
940         rc = get_pubkey_byname( NULL, pk, def_rec, NULL );
941         if( rc )
942             log_error(_("unknown default recipient `%s'\n"), def_rec );
943         else if( !(rc=openpgp_pk_test_algo(pk->pubkey_algo, use)) ) {
944             PK_LIST r = gcry_xmalloc( sizeof *r );
945             r->pk = pk; pk = NULL;
946             r->next = pk_list;
947             r->mark = 0;
948             pk_list = r;
949             any_recipients = 1;
950         }
951         if( pk ) {
952             free_public_key( pk );
953             pk = NULL;
954         }
955         gcry_free(def_rec); def_rec = NULL;
956     }
957     else {
958         any_recipients = 0;
959         for(; remusr; remusr = remusr->next ) {
960             if( (remusr->flags & 1) )
961                 continue; /* encrypt-to keys are already handled */
962
963             pk = gcry_xcalloc( 1, sizeof *pk );
964             pk->req_usage = use;
965             if( (rc = get_pubkey_byname( NULL, pk, remusr->d, NULL )) ) {
966                 free_public_key( pk ); pk = NULL;
967                 log_error(_("%s: skipped: %s\n"), remusr->d, gpg_errstr(rc) );
968             }
969             else if( !(rc=openpgp_pk_test_algo(pk->pubkey_algo, use )) ) {
970                 int trustlevel;
971
972                 rc = check_trust( pk, &trustlevel, pk->namehash, NULL, NULL );
973                 if( rc ) {
974                     free_public_key( pk ); pk = NULL;
975                     log_error(_("%s: error checking key: %s\n"),
976                                                       remusr->d, gpg_errstr(rc) );
977                 }
978                 else if( (trustlevel & TRUST_FLAG_DISABLED) ) {
979                     free_public_key(pk); pk = NULL;
980                     log_info(_("%s: skipped: public key is disabled\n"),
981                                                                     remusr->d);
982                 }
983                 else if( do_we_trust_pre( pk, trustlevel ) ) {
984                     /* note: do_we_trust may have changed the trustlevel */
985
986                     /* We have at least one valid recipient. It doesn't matters
987                      * if this recipient is already present. */
988                     any_recipients = 1;
989
990                     /* Skip the actual key if the key is already present
991                      * in the list */
992                     if (key_present_in_pk_list(pk_list, pk) == 0) {
993                         free_public_key(pk); pk = NULL;
994                         log_info(_("%s: skipped: public key already present\n"),
995                                                                     remusr->d);
996                     }
997                     else {
998                         PK_LIST r;
999                         r = gcry_xmalloc( sizeof *r );
1000                         r->pk = pk; pk = NULL;
1001                         r->next = pk_list;
1002                         r->mark = 0;
1003                         pk_list = r;
1004                     }
1005                 }
1006                 else { /* we don't trust this pk */
1007                     free_public_key( pk ); pk = NULL;
1008                 }
1009             }
1010             else {
1011                 free_public_key( pk ); pk = NULL;
1012                 log_error(_("%s: skipped: %s\n"), remusr->d, gpg_errstr(rc) );
1013             }
1014         }
1015     }
1016
1017     if( !rc && !any_recipients ) {
1018         log_error(_("no valid addressees\n"));
1019         rc = GPGERR_NO_USER_ID;
1020     }
1021
1022     if( rc )
1023         release_pk_list( pk_list );
1024     else
1025         *ret_pk_list = pk_list;
1026     return rc;
1027 }
1028
1029
1030
1031 static int
1032 algo_available( int preftype, int algo )
1033 {
1034     if( preftype == PREFTYPE_SYM ) {
1035         return algo && !openpgp_cipher_test_algo( algo );
1036     }
1037     else if( preftype == PREFTYPE_HASH ) {
1038         return algo && !openpgp_md_test_algo( algo );
1039     }
1040     else if( preftype == PREFTYPE_COMPR ) {
1041         return !algo || algo == 1 || algo == 2;
1042     }
1043     else
1044         return 0;
1045 }
1046
1047 /****************
1048  * Return -1 if we could not find an algorithm.
1049  */
1050 int
1051 select_algo_from_prefs( PK_LIST pk_list, int preftype )
1052 {
1053     PK_LIST pkr;
1054     u32 bits[8];
1055     byte *pref = NULL;
1056     size_t npref;
1057     int i, j;
1058     int compr_hack=0;
1059     int any;
1060
1061     if( !pk_list )
1062         return -1;
1063
1064     memset( bits, ~0, 8 * sizeof *bits );
1065     for( pkr = pk_list; pkr; pkr = pkr->next ) {
1066         u32 mask[8];
1067
1068         memset( mask, 0, 8 * sizeof *mask );
1069         if( !pkr->pk->local_id ) { /* try to set the local id */
1070             query_trust_info( pkr->pk, NULL );
1071             if( !pkr->pk->local_id ) {
1072                 log_debug("select_algo_from_prefs: can't get LID\n");
1073                 continue;
1074             }
1075         }
1076         if( preftype == PREFTYPE_SYM )
1077             mask[0] |= (1<<2); /* 3DES is implicitly there */
1078         gcry_free(pref);
1079         pref = get_pref_data( pkr->pk->local_id, pkr->pk->namehash, &npref);
1080         any = 0;
1081         if( pref ) {
1082            #if 0
1083             log_hexdump("raw: ", pref, npref );
1084            #endif
1085             for(i=0; i+1 < npref; i+=2 ) {
1086                 if( pref[i] == preftype ) {
1087                     mask[pref[i+1]/32] |= 1 << (pref[i+1]%32);
1088                     any = 1;
1089                 }
1090             }
1091         }
1092         if( (!pref || !any) && preftype == PREFTYPE_COMPR ) {
1093             mask[0] |= 3; /* asume no_compression and old pgp */
1094             compr_hack = 1;
1095         }
1096
1097       #if 0
1098         log_debug("mask=%08lX%08lX%08lX%08lX%08lX%08lX%08lX%08lX\n",
1099                (ulong)mask[7], (ulong)mask[6], (ulong)mask[5], (ulong)mask[4],
1100              (ulong)mask[3], (ulong)mask[2], (ulong)mask[1], (ulong)mask[0]);
1101       #endif
1102         for(i=0; i < 8; i++ )
1103             bits[i] &= mask[i];
1104       #if 0
1105         log_debug("bits=%08lX%08lX%08lX%08lX%08lX%08lX%08lX%08lX\n",
1106                (ulong)bits[7], (ulong)bits[6], (ulong)bits[5], (ulong)bits[4],
1107              (ulong)bits[3], (ulong)bits[2], (ulong)bits[1], (ulong)bits[0]);
1108       #endif
1109     }
1110     /* usable algorithms are now in bits
1111      * We now use the last key from pk_list to select
1112      * the algorithm we want to use. there are no
1113      * preferences for the last key, we select the one
1114      * corresponding to first set bit.
1115      */
1116     i = -1;
1117     any = 0;
1118     if( pref ) {
1119         for(j=0; j+1 < npref; j+=2 ) {
1120             if( pref[j] == preftype ) {
1121                 if( (bits[pref[j+1]/32] & (1<<(pref[j+1]%32))) ) {
1122                     if( algo_available( preftype, pref[j+1] ) ) {
1123                         any = 1;
1124                         i = pref[j+1];
1125                         break;
1126                     }
1127                 }
1128             }
1129         }
1130     }
1131     if( !pref || !any ) {
1132         for(j=0; j < 256; j++ )
1133             if( (bits[j/32] & (1<<(j%32))) ) {
1134                 if( algo_available( preftype, j ) ) {
1135                     i = j;
1136                     break;
1137                 }
1138             }
1139     }
1140   #if 0
1141     log_debug("prefs of type %d: selected %d\n", preftype, i );
1142   #endif
1143     if( compr_hack && !i ) {
1144         /* selected no compression, but we should check whether
1145          * algorithm 1 is also available (the ordering is not relevant
1146          * in this case). */
1147         if( bits[0] & (1<<1) )
1148             i = 1;  /* yep; we can use compression algo 1 */
1149     }
1150
1151     gcry_free(pref);
1152     return i;
1153 }
1154
1155