01d12babbb3f2322e62bf21ab54a4451e593d507
[gnupg.git] / g10 / pkclist.c
1 /* pkclist.c
2  *      Copyright (C) 1998 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 "options.h"
29 #include "packet.h"
30 #include "errors.h"
31 #include "keydb.h"
32 #include "memory.h"
33 #include "util.h"
34 #include "trustdb.h"
35 #include "ttyio.h"
36 #include "status.h"
37 #include "i18n.h"
38
39
40 #define CONTROL_D ('D' - 'A' + 1)
41
42
43 static void
44 show_paths( ulong lid, int only_first )
45 {
46     void *context = NULL;
47     unsigned otrust, validity;
48     int last_level, level;
49
50     last_level = 0;
51     while( (level=enum_cert_paths( &context, &lid, &otrust, &validity)) != -1){
52         char *p;
53         int c, rc;
54         size_t n;
55         u32 keyid[2];
56         PKT_public_key *pk ;
57
58         if( level < last_level && only_first )
59             break;
60         last_level = level;
61
62         rc = keyid_from_lid( lid, keyid );
63         if( rc ) {
64             log_error("ooops: can't get keyid for lid %lu\n", lid);
65             return;
66         }
67
68         pk = m_alloc_clear( sizeof *pk );
69         rc = get_pubkey( pk, keyid );
70         if( rc ) {
71             log_error("key %08lX: public key not found: %s\n",
72                                     (ulong)keyid[1], g10_errstr(rc) );
73             return;
74         }
75
76         tty_printf("%*s%4u%c/%08lX.%lu %s \"",
77                   level*2, "",
78                   nbits_from_pk( pk ), pubkey_letter( pk->pubkey_algo ),
79                   (ulong)keyid[1], lid, datestr_from_pk( pk ) );
80
81         c = trust_letter(otrust);
82         if( c )
83             putchar( c );
84         else
85             printf( "%02x", otrust );
86         putchar('/');
87         c = trust_letter(validity);
88         if( c )
89             putchar( c );
90         else
91             printf( "%02x", validity );
92         putchar(' ');
93
94         p = get_user_id( keyid, &n );
95         tty_print_string( p, n ),
96         m_free(p);
97         tty_printf("\"\n");
98         free_public_key( pk );
99     }
100     enum_cert_paths( &context, NULL, NULL, NULL ); /* release context */
101     tty_printf("\n");
102 }
103
104
105
106
107 /****************
108  * Returns true if an ownertrust has changed.
109  */
110 static int
111 do_edit_ownertrust( ulong lid, int mode, unsigned *new_trust, int defer_help )
112 {
113     char *p;
114     int rc;
115     size_t n;
116     u32 keyid[2];
117     PKT_public_key *pk ;
118     int changed=0;
119     int quit=0;
120     int show=0;
121     int did_help=defer_help;
122
123     rc = keyid_from_lid( lid, keyid );
124     if( rc ) {
125         log_error("ooops: can't get keyid for lid %lu\n", lid);
126         return 0;
127     }
128
129     pk = m_alloc_clear( sizeof *pk );
130     rc = get_pubkey( pk, keyid );
131     if( rc ) {
132         log_error("key %08lX: public key not found: %s\n",
133                                 (ulong)keyid[1], g10_errstr(rc) );
134         return 0;
135     }
136
137
138     for(;;) {
139         /* a string with valid answers */
140         char *ans = _("sSmMqQ");
141
142         if( !did_help ) {
143             if( !mode ) {
144                 tty_printf(_("No trust value assigned to %lu:\n"
145                            "%4u%c/%08lX %s \""), lid,
146                           nbits_from_pk( pk ), pubkey_letter( pk->pubkey_algo ),
147                           (ulong)keyid[1], datestr_from_pk( pk ) );
148                 p = get_user_id( keyid, &n );
149                 tty_print_string( p, n ),
150                 m_free(p);
151                 tty_printf("\"\n\n");
152             }
153             tty_printf(_(
154 "Please decide how far you trust this user to correctly\n"
155 "verify other users' keys (by looking at passports,\n"
156 "checking fingerprints from different sources...)?\n\n"
157 " 1 = Don't know\n"
158 " 2 = I do NOT trust\n"
159 " 3 = I trust marginally\n"
160 " 4 = I trust fully\n"
161 " s = please show me more information\n") );
162             if( mode )
163                 tty_printf(_(" m = back to the main menu\n"));
164             else
165                 tty_printf(_(" q = quit\n"));
166             tty_printf("\n");
167             did_help = 1;
168         }
169         if( strlen(ans) != 6 )
170             BUG();
171         p = cpr_get("edit_ownertrust.value",_("Your decision? "));
172         trim_spaces(p);
173         cpr_kill_prompt();
174         if( !*p )
175             did_help = 0;
176         else if( *p && p[1] )
177             ;
178         else if( !p[1] && (*p >= '1' && *p <= '4') ) {
179             unsigned trust;
180             switch( *p ) {
181               case '1': trust = TRUST_UNDEFINED; break;
182               case '2': trust = TRUST_NEVER    ; break;
183               case '3': trust = TRUST_MARGINAL ; break;
184               case '4': trust = TRUST_FULLY    ; break;
185               default: BUG();
186             }
187             *new_trust = trust;
188             changed = 1;
189             break;
190         }
191         else if( *p == ans[0] || *p == ans[1] ) {
192             tty_printf(_(
193                 "Certificates leading to an ultimately trusted key:\n"));
194             show = 1;
195             break;
196         }
197         else if( mode && (*p == ans[2] || *p == ans[3] || *p == CONTROL_D ) ) {
198             break ; /* back to the menu */
199         }
200         else if( !mode && (*p == ans[4] || *p == ans[5] ) ) {
201             quit = 1;
202             break ; /* back to the menu */
203         }
204         m_free(p); p = NULL;
205     }
206     m_free(p);
207     m_free(pk);
208     return show? -2: quit? -1 : changed;
209 }
210
211
212 int
213 edit_ownertrust( ulong lid, int mode )
214 {
215     unsigned int trust;
216     int no_help = 0;
217
218     for(;;) {
219         switch( do_edit_ownertrust( lid, mode, &trust, no_help ) ) {
220           case -1:
221             return 0;
222           case -2:
223             show_paths( lid, 1  );
224             no_help = 1;
225             break;
226           case 1:
227             trust &= ~TRUST_FLAG_DISABLED;
228             trust |= get_ownertrust( lid ) & TRUST_FLAG_DISABLED;
229             if( !update_ownertrust( lid, trust ) )
230                 return 1;
231             return 0;
232           default:
233             return 0;
234         }
235     }
236 }
237
238 static int
239 add_ownertrust_cb( ulong lid )
240 {
241     unsigned trust;
242     int rc = do_edit_ownertrust( lid, 0, &trust, 0 );
243
244     if( rc == 1 )
245         return trust & TRUST_MASK;
246     return rc > 0? 0 : rc;
247 }
248
249 /****************
250  * Try to add some more owner trusts (interactive)
251  * This function presents all the signator in a certificate
252  * chain who have no ownertrust value assigned.
253  * Returns: -1 if no ownertrust were added.
254  */
255 static int
256 add_ownertrust( PKT_public_key *pk, int *quit, unsigned *trustlevel )
257 {
258     int rc;
259     unsigned flags = 0;
260
261     *quit = 0;
262     *trustlevel = 0;
263     tty_printf(
264 _("Could not find a valid trust path to the key.  Let's see whether we\n"
265   "can assign some missing owner trust values.\n\n"));
266
267     rc = check_trust( pk, trustlevel, NULL, add_ownertrust_cb, &flags );
268
269     if( !(flags & 1) )
270         tty_printf(_("No path leading to one of our keys found.\n\n") );
271     else if( !(flags & 2) )
272         tty_printf(_("No certificates with undefined trust found.\n\n") );
273     else if( !(flags & 4) )
274         tty_printf(_("No trust values changed.\n\n") );
275
276     return (flags & 4)? 0:-1;
277 }
278
279 /****************
280  * Check whether we can trust this pk which has a trustlevel of TRUSTLEVEL
281  * Returns: true if we trust.
282  */
283 static int
284 do_we_trust( PKT_public_key *pk, int trustlevel )
285 {
286     int rc;
287     int did_add = 0;
288
289   retry:
290     if( (trustlevel & TRUST_FLAG_REVOKED) ) {
291         log_info(_("key %08lX: key has been revoked!\n"),
292                                         (ulong)keyid_from_pk( pk, NULL) );
293         if( opt.batch )
294             return 0;
295
296         if( !cpr_get_answer_is_yes("revoked_key.override",
297                                     _("Use this key anyway? ")) )
298             return 0;
299     }
300     else if( (trustlevel & TRUST_FLAG_SUB_REVOKED) ) {
301         log_info(_("key %08lX: subkey has been revoked!\n"),
302                                         (ulong)keyid_from_pk( pk, NULL) );
303         if( opt.batch )
304             return 0;
305
306         if( !cpr_get_answer_is_yes("revoked_key.override",
307                                     _("Use this key anyway? ")) )
308             return 0;
309     }
310
311
312     switch( (trustlevel & TRUST_MASK) ) {
313       case TRUST_UNKNOWN: /* No pubkey in trustDB: Insert and check again */
314         rc = insert_trust_record_by_pk( pk );
315         if( rc ) {
316             log_error("failed to insert it into the trustdb: %s\n",
317                                                       g10_errstr(rc) );
318             return 0; /* no */
319         }
320         rc = check_trust( pk, &trustlevel, NULL, NULL, NULL );
321         if( rc )
322             log_fatal("trust check after insert failed: %s\n",
323                                                       g10_errstr(rc) );
324         if( trustlevel == TRUST_UNKNOWN || trustlevel == TRUST_EXPIRED ) {
325             log_debug("do_we_trust: oops at %d\n", __LINE__ );
326             return 0;
327         }
328         return do_we_trust( pk, trustlevel );
329
330       case TRUST_EXPIRED:
331         log_info(_("%08lX: key has expired\n"),
332                                     (ulong)keyid_from_pk( pk, NULL) );
333         return 0; /* no */
334
335       case TRUST_UNDEFINED:
336         if( opt.batch || opt.answer_no )
337             log_info(_("%08lX: no info to calculate a trust probability\n"),
338                                         (ulong)keyid_from_pk( pk, NULL) );
339         else {
340             int quit;
341
342             rc = add_ownertrust( pk, &quit, &trustlevel );
343             if( !rc && !did_add && !quit ) {
344                 did_add = 1;
345                 goto retry;
346             }
347         }
348         return 0;
349
350       case TRUST_NEVER:
351         log_info(_("%08lX: We do NOT trust this key\n"),
352                                         (ulong)keyid_from_pk( pk, NULL) );
353         return 0; /* no */
354
355       case TRUST_MARGINAL:
356         log_info(
357        _("%08lX: It is not sure that this key really belongs to the owner\n"
358          "but it is accepted anyway\n"), (ulong)keyid_from_pk( pk, NULL) );
359         return 1; /* yes */
360
361       case TRUST_FULLY:
362         if( opt.verbose )
363             log_info(_("This key probably belongs to the owner\n"));
364         return 1; /* yes */
365
366       case TRUST_ULTIMATE:
367         if( opt.verbose )
368             log_info(_("This key belongs to us\n"));
369         return 1; /* yes */
370
371       default: BUG();
372     }
373
374     return 1; /* yes */
375 }
376
377
378 /****************
379  * wrapper around do_we_trust, so we can ask whether to use the
380  * key anyway.
381  */
382 static int
383 do_we_trust_pre( PKT_public_key *pk, int trustlevel )
384 {
385     int rc;
386
387     rc = do_we_trust( pk, trustlevel );
388
389     if( (trustlevel & TRUST_FLAG_REVOKED) && !rc )
390         return 0;
391     if( (trustlevel & TRUST_FLAG_SUB_REVOKED) && !rc )
392         return 0;
393     else if( !opt.batch && !rc ) {
394         char *p;
395         u32 keyid[2];
396         size_t n;
397
398         keyid_from_pk( pk, keyid);
399         tty_printf( "%4u%c/%08lX %s \"",
400                   nbits_from_pk( pk ), pubkey_letter( pk->pubkey_algo ),
401                   (ulong)keyid[1], datestr_from_pk( pk ) );
402         p = get_user_id( keyid, &n );
403         tty_print_string( p, n ),
404         m_free(p);
405         tty_printf("\"\n\n");
406
407         tty_printf(_(
408 "It is NOT certain that the key belongs to its owner.\n"
409 "If you *really* know what you are doing, you may answer\n"
410 "the next question with yes\n\n") );
411
412         if( cpr_get_answer_is_yes("untrusted_key.override",
413                                   _("Use this key anyway? "))  )
414             rc = 1;
415
416         /* Hmmm: Should we set a flag to tell the user the user about
417          *       his decision the next time he encrypts for this recipient?
418          */
419     }
420     else if( opt.always_trust && !rc ) {
421         log_info(_("WARNING: Using untrusted key!\n"));
422         rc = 1;
423     }
424     return rc;
425 }
426
427
428
429 /****************
430  * Check whether we can trust this signature.
431  * Returns: Error if we shall not trust this signatures.
432  */
433 int
434 check_signatures_trust( PKT_signature *sig )
435 {
436     PKT_public_key *pk = m_alloc_clear( sizeof *pk );
437     int trustlevel;
438     int did_add = 0;
439     int rc=0;
440
441
442     if( opt.always_trust ) {
443         log_info(_("WARNING: Using untrusted key!\n"));
444         return 0;
445     }
446
447
448     rc = get_pubkey( pk, sig->keyid );
449     if( rc ) { /* this should not happen */
450         log_error("Ooops; the key vanished  - can't check the trust\n");
451         rc = G10ERR_NO_PUBKEY;
452         goto leave;
453     }
454
455     rc = check_trust( pk, &trustlevel, NULL, NULL, NULL );
456     if( rc ) {
457         log_error("check trust failed: %s\n", g10_errstr(rc));
458         goto leave;
459     }
460
461   retry:
462     if( (trustlevel & TRUST_FLAG_REVOKED) ) {
463         write_status( STATUS_KEYREVOKED );
464         log_info(_("WARNING: This key has been revoked by its owner!\n"));
465         log_info(_("         This could mean that the signature is forgery.\n"));
466     }
467     else if( (trustlevel & TRUST_FLAG_SUB_REVOKED) ) {
468         write_status( STATUS_KEYREVOKED );
469         log_info(_("WARNING: This subkey has been revoked by its owner!\n"));
470     }
471
472
473     switch( (trustlevel & TRUST_MASK) ) {
474       case TRUST_UNKNOWN: /* No pubkey in trustDB: Insert and check again */
475         rc = insert_trust_record_by_pk( pk );
476         if( rc ) {
477             log_error("failed to insert it into the trustdb: %s\n",
478                                                       g10_errstr(rc) );
479             goto leave;
480         }
481         rc = check_trust( pk, &trustlevel, NULL, NULL, NULL );
482         if( rc )
483             log_fatal("trust check after insert failed: %s\n",
484                                                       g10_errstr(rc) );
485         if( trustlevel == TRUST_UNKNOWN || trustlevel == TRUST_EXPIRED )
486             BUG();
487         goto retry;
488
489       case TRUST_EXPIRED:
490         log_info(_("Note: This key has expired!\n"));
491         break;
492
493       case TRUST_UNDEFINED:
494         if( did_add || opt.batch || opt.answer_no ) {
495             write_status( STATUS_TRUST_UNDEFINED );
496             log_info(_(
497             "WARNING: This key is not certified with a trusted signature!\n"));
498             log_info(_(
499             "         There is no indication that the "
500                                     "signature belongs to the owner.\n" ));
501         }
502         else {
503             int quit;
504             rc = add_ownertrust( pk, &quit, &trustlevel );
505             if( rc || quit ) {
506                 did_add = 1;
507                 rc = 0;
508             }
509             goto retry;
510         }
511         break;
512
513       case TRUST_NEVER:
514         write_status( STATUS_TRUST_NEVER );
515         log_info(_("WARNING: We do NOT trust this key!\n"));
516         log_info(_("         The signature is probably a FORGERY.\n"));
517         rc = G10ERR_BAD_SIGN;
518         break;
519
520       case TRUST_MARGINAL:
521         write_status( STATUS_TRUST_MARGINAL );
522         log_info(_(
523          "WARNING: This key is not certified with sufficiently trusted signatures!\n"
524                 ));
525         log_info(_(
526          "         It is not certain that the signature belongs to the owner.\n"
527                  ));
528         break;
529
530       case TRUST_FULLY:
531         write_status( STATUS_TRUST_FULLY );
532         break;
533
534       case TRUST_ULTIMATE:
535         write_status( STATUS_TRUST_ULTIMATE );
536         break;
537
538       default: BUG();
539     }
540
541
542   leave:
543     free_public_key( pk );
544     return rc;
545 }
546
547
548 void
549 release_pk_list( PK_LIST pk_list )
550 {
551     PK_LIST pk_rover;
552
553     for( ; pk_list; pk_list = pk_rover ) {
554         pk_rover = pk_list->next;
555         free_public_key( pk_list->pk );
556         m_free( pk_list );
557     }
558 }
559
560
561 static int
562 key_present_in_pk_list(PK_LIST pk_list, PKT_public_key *pk)
563 {
564     for( ; pk_list; pk_list = pk_list->next)
565         if (cmp_public_keys(pk_list->pk, pk) == 0)
566             return 0;
567
568     return -1;
569 }
570
571
572 /****************
573  * Return a malloced string with a default reciepient if there is any
574  */
575 static char *
576 default_recipient(void)
577 {
578     PKT_secret_key *sk;
579     byte fpr[MAX_FINGERPRINT_LEN+1];
580     size_t n;
581     char *p;
582     int i;
583
584     if( opt.def_recipient )
585         return m_strdup( opt.def_recipient );
586     if( !opt.def_recipient_self )
587         return NULL;
588     sk = m_alloc_clear( sizeof *sk );
589     i = get_seckey_byname( sk, NULL, 0 );
590     if( i ) {
591         free_secret_key( sk );
592         return NULL;
593     }
594     n = MAX_FINGERPRINT_LEN;
595     fingerprint_from_sk( sk, fpr, &n );
596     free_secret_key( sk );
597     p = m_alloc( 2*n+3 );
598     *p++ = '0';
599     *p++ = 'x';
600     for(i=0; i < n; i++ )
601         sprintf( p+2*i, "%02X", fpr[i] );
602     p -= 2;
603     return p;
604 }
605
606
607 int
608 build_pk_list( STRLIST remusr, PK_LIST *ret_pk_list, unsigned use )
609 {
610     PK_LIST pk_list = NULL;
611     PKT_public_key *pk=NULL;
612     int rc=0;
613     int any_recipients=0;
614     STRLIST rov;
615     char *def_rec = NULL;
616
617     /* check whether there are any recipients in the list and build the
618      * list of the encrypt-to ones (we always trust them) */
619     for( rov = remusr; rov; rov = rov->next ) {
620         if( !(rov->flags & 1) )
621             any_recipients = 1;
622         else if( (use & PUBKEY_USAGE_ENC) && !opt.no_encrypt_to ) {
623             pk = m_alloc_clear( sizeof *pk );
624             pk->pubkey_usage = use;
625             if( (rc = get_pubkey_byname( NULL, pk, rov->d, NULL )) ) {
626                 free_public_key( pk ); pk = NULL;
627                 log_error(_("%s: skipped: %s\n"), rov->d, g10_errstr(rc) );
628             }
629             else if( !(rc=check_pubkey_algo2(pk->pubkey_algo, use )) ) {
630
631                 /* Skip the actual key if the key is already present
632                  * in the list */
633                 if (key_present_in_pk_list(pk_list, pk) == 0) {
634                     free_public_key(pk); pk = NULL;
635                     log_info(_("%s: skipped: public key already present\n"),
636                                                             rov->d);
637                 }
638                 else {
639                     PK_LIST r;
640                     r = m_alloc( sizeof *r );
641                     r->pk = pk; pk = NULL;
642                     r->next = pk_list;
643                     r->mark = 0;
644                     pk_list = r;
645                 }
646             }
647             else {
648                 free_public_key( pk ); pk = NULL;
649                 log_error(_("%s: skipped: %s\n"), rov->d, g10_errstr(rc) );
650             }
651         }
652     }
653
654     if( !any_recipients && !opt.batch ) { /* ask */
655         char *answer=NULL;
656         int have_def_rec;
657
658         def_rec = default_recipient();
659         have_def_rec = !!def_rec;
660         if( !have_def_rec )
661             tty_printf(_(
662                 "You did not specify a user ID. (you may use \"-r\")\n\n"));
663         for(;;) {
664             rc = 0;
665             m_free(answer);
666             if( have_def_rec ) {
667                 answer = def_rec;
668                 def_rec = NULL;
669             }
670             else {
671                 answer = cpr_get_utf8("pklist.user_id.enter",
672                                        _("Enter the user ID: "));
673                 trim_spaces(answer);
674                 cpr_kill_prompt();
675             }
676             if( !*answer )
677                 break;
678             if( pk )
679                 free_public_key( pk );
680             pk = m_alloc_clear( sizeof *pk );
681             pk->pubkey_usage = use;
682             rc = get_pubkey_byname( NULL, pk, answer, NULL );
683             if( rc )
684                 tty_printf(_("No such user ID.\n"));
685             else if( !(rc=check_pubkey_algo2(pk->pubkey_algo, use)) ) {
686                 if( have_def_rec ) {
687                     PK_LIST r = m_alloc( sizeof *r );
688                     r->pk = pk; pk = NULL;
689                     r->next = pk_list;
690                     r->mark = 0;
691                     pk_list = r;
692                     any_recipients = 1;
693                     break;
694                 }
695                 else {
696                     int trustlevel;
697
698                     rc = check_trust( pk, &trustlevel, NULL, NULL, NULL );
699                     if( rc ) {
700                         log_error("error checking pk of `%s': %s\n",
701                                                      answer, g10_errstr(rc) );
702                     }
703                     else if( (trustlevel & TRUST_FLAG_DISABLED) ) {
704                         tty_printf(_("Public key is disabled.\n") );
705                     }
706                     else if( do_we_trust_pre( pk, trustlevel ) ) {
707                         PK_LIST r;
708
709                         r = m_alloc( sizeof *r );
710                         r->pk = pk; pk = NULL;
711                         r->next = pk_list;
712                         r->mark = 0;
713                         pk_list = r;
714                         any_recipients = 1;
715                         break;
716                     }
717                 }
718             }
719             m_free(def_rec); def_rec = NULL;
720             have_def_rec = 0;
721         }
722         m_free(answer);
723         if( pk ) {
724             free_public_key( pk );
725             pk = NULL;
726         }
727     }
728     else if( !any_recipients && (def_rec = default_recipient()) ) {
729         pk = m_alloc_clear( sizeof *pk );
730         pk->pubkey_usage = use;
731         rc = get_pubkey_byname( NULL, pk, def_rec, NULL );
732         if( rc )
733             log_error(_("unknown default recipient `s'\n"), def_rec );
734         else if( !(rc=check_pubkey_algo2(pk->pubkey_algo, use)) ) {
735             PK_LIST r = m_alloc( sizeof *r );
736             r->pk = pk; pk = NULL;
737             r->next = pk_list;
738             r->mark = 0;
739             pk_list = r;
740             any_recipients = 1;
741         }
742         if( pk ) {
743             free_public_key( pk );
744             pk = NULL;
745         }
746         m_free(def_rec); def_rec = NULL;
747     }
748     else {
749         any_recipients = 0;
750         for(; remusr; remusr = remusr->next ) {
751             if( (remusr->flags & 1) )
752                 continue; /* encrypt-to keys are already handled */
753
754             pk = m_alloc_clear( sizeof *pk );
755             pk->pubkey_usage = use;
756             if( (rc = get_pubkey_byname( NULL, pk, remusr->d, NULL )) ) {
757                 free_public_key( pk ); pk = NULL;
758                 log_error(_("%s: skipped: %s\n"), remusr->d, g10_errstr(rc) );
759             }
760             else if( !(rc=check_pubkey_algo2(pk->pubkey_algo, use )) ) {
761                 int trustlevel;
762
763                 rc = check_trust( pk, &trustlevel, NULL, NULL, NULL );
764                 if( rc ) {
765                     free_public_key( pk ); pk = NULL;
766                     log_error(_("%s: error checking key: %s\n"),
767                                                       remusr->d, g10_errstr(rc) );
768                 }
769                 else if( (trustlevel & TRUST_FLAG_DISABLED) ) {
770                     free_public_key(pk); pk = NULL;
771                     log_info(_("%s: skipped: public key is disabled\n"),
772                                                                     remusr->d);
773                 }
774                 else if( do_we_trust_pre( pk, trustlevel ) ) {
775                     /* note: do_we_trust may have changed the trustlevel */
776
777                     /* We have at least one valid recipient. It doesn't matters
778                      * if this recipient is already present. */
779                     any_recipients = 1;
780
781                     /* Skip the actual key if the key is already present
782                      * in the list */
783                     if (key_present_in_pk_list(pk_list, pk) == 0) {
784                         free_public_key(pk); pk = NULL;
785                         log_info(_("%s: skipped: public key already present\n"),
786                                                                     remusr->d);
787                     }
788                     else {
789                         PK_LIST r;
790                         r = m_alloc( sizeof *r );
791                         r->pk = pk; pk = NULL;
792                         r->next = pk_list;
793                         r->mark = 0;
794                         pk_list = r;
795                     }
796                 }
797                 else { /* we don't trust this pk */
798                     free_public_key( pk ); pk = NULL;
799                 }
800             }
801             else {
802                 free_public_key( pk ); pk = NULL;
803                 log_error(_("%s: skipped: %s\n"), remusr->d, g10_errstr(rc) );
804             }
805         }
806     }
807
808     if( !rc && !any_recipients ) {
809         log_error(_("no valid addressees\n"));
810         rc = G10ERR_NO_USER_ID;
811     }
812
813     if( rc )
814         release_pk_list( pk_list );
815     else
816         *ret_pk_list = pk_list;
817     return rc;
818 }
819
820
821
822 static int
823 algo_available( int preftype, int algo )
824 {
825     if( preftype == PREFTYPE_SYM ) {
826         if( algo == CIPHER_ALGO_TWOFISH )
827             return 0;  /* we don't want to generate Twofish messages for now*/
828         return algo && !check_cipher_algo( algo );
829     }
830     else if( preftype == PREFTYPE_HASH ) {
831         return algo && !check_digest_algo( algo );
832     }
833     else if( preftype == PREFTYPE_COMPR ) {
834         return !algo || algo == 1 || algo == 2;
835     }
836     else
837         return 0;
838 }
839
840 /****************
841  * Return -1 if we could not find an algorithm.
842  */
843 int
844 select_algo_from_prefs( PK_LIST pk_list, int preftype )
845 {
846     PK_LIST pkr;
847     u32 bits[8];
848     byte *pref = NULL;
849     size_t npref;
850     int i, j;
851     int compr_hack=0;
852     int any;
853
854     if( !pk_list )
855         return -1;
856
857     memset( bits, ~0, 8 * sizeof *bits );
858     for( pkr = pk_list; pkr; pkr = pkr->next ) {
859         u32 mask[8];
860
861         memset( mask, 0, 8 * sizeof *mask );
862         if( !pkr->pk->local_id ) { /* try to set the local id */
863             query_trust_info( pkr->pk, NULL );
864             if( !pkr->pk->local_id ) {
865                 log_debug("select_algo_from_prefs: can't get LID\n");
866                 continue;
867             }
868         }
869         if( preftype == PREFTYPE_SYM )
870             mask[0] |= (1<<2); /* 3DES is implicitly there */
871         m_free(pref);
872         pref = get_pref_data( pkr->pk->local_id, pkr->pk->namehash, &npref);
873         any = 0;
874         if( pref ) {
875            #if 0
876             log_hexdump("raw: ", pref, npref );
877            #endif
878             for(i=0; i+1 < npref; i+=2 ) {
879                 if( pref[i] == preftype ) {
880                     mask[pref[i+1]/32] |= 1 << (pref[i+1]%32);
881                     any = 1;
882                 }
883             }
884         }
885         if( (!pref || !any) && preftype == PREFTYPE_COMPR ) {
886             mask[0] |= 3; /* asume no_compression and old pgp */
887             compr_hack = 1;
888         }
889
890       #if 0
891         log_debug("mask=%08lX%08lX%08lX%08lX%08lX%08lX%08lX%08lX\n",
892                (ulong)mask[7], (ulong)mask[6], (ulong)mask[5], (ulong)mask[4],
893              (ulong)mask[3], (ulong)mask[2], (ulong)mask[1], (ulong)mask[0]);
894       #endif
895         for(i=0; i < 8; i++ )
896             bits[i] &= mask[i];
897       #if 0
898         log_debug("bits=%08lX%08lX%08lX%08lX%08lX%08lX%08lX%08lX\n",
899                (ulong)bits[7], (ulong)bits[6], (ulong)bits[5], (ulong)bits[4],
900              (ulong)bits[3], (ulong)bits[2], (ulong)bits[1], (ulong)bits[0]);
901       #endif
902     }
903     /* usable algorithms are now in bits
904      * We now use the last key from pk_list to select
905      * the algorithm we want to use. there are no
906      * preferences for the last key, we select the one
907      * corresponding to first set bit.
908      */
909     i = -1;
910     any = 0;
911     if( pref ) {
912         for(j=0; j+1 < npref; j+=2 ) {
913             if( pref[j] == preftype ) {
914                 if( (bits[pref[j+1]/32] & (1<<(pref[j+1]%32))) ) {
915                     if( algo_available( preftype, pref[j+1] ) ) {
916                         any = 1;
917                         i = pref[j+1];
918                         break;
919                     }
920                 }
921             }
922         }
923     }
924     if( !pref || !any ) {
925         for(j=0; j < 256; j++ )
926             if( (bits[j/32] & (1<<(j%32))) ) {
927                 if( algo_available( preftype, j ) ) {
928                     i = j;
929                     break;
930                 }
931             }
932     }
933   #if 0
934     log_debug("prefs of type %d: selected %d\n", preftype, i );
935   #endif
936     if( compr_hack && !i ) {
937         /* selected no compression, but we should check whether
938          * algorithm 1 is also available (the ordering is not relevant
939          * in this case). */
940         if( bits[0] & (1<<1) )
941             i = 1;  /* yep; we can use compression algo 1 */
942     }
943
944     m_free(pref);
945     return i;
946 }
947
948