See ChangeLog: Fri Nov 27 12:39:29 CET 1998 Werner Koch
[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 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         p = get_user_id( keyid, &n );
81         tty_print_string( p, n ),
82         m_free(p);
83         tty_printf("\"\n");
84         free_public_key( pk );
85     }
86     enum_cert_paths( &context, NULL, NULL, NULL ); /* release context */
87     tty_printf("\n");
88 }
89
90
91
92
93 /****************
94  * Returns true if an ownertrust has changed.
95  */
96 int
97 edit_ownertrust( ulong lid, int mode )
98 {
99     char *p;
100     int rc;
101     size_t n;
102     u32 keyid[2];
103     PKT_public_key *pk ;
104     int changed=0;
105
106     rc = keyid_from_lid( lid, keyid );
107     if( rc ) {
108         log_error("ooops: can't get keyid for lid %lu\n", lid);
109         return 0;
110     }
111
112     pk = m_alloc_clear( sizeof *pk );
113     rc = get_pubkey( pk, keyid );
114     if( rc ) {
115         log_error("key %08lX: public key not found: %s\n",
116                                 (ulong)keyid[1], g10_errstr(rc) );
117         return 0;
118     }
119
120     if( !mode ) {
121         tty_printf(_("No trust value assigned to %lu:\n"
122                    "%4u%c/%08lX %s \""), lid,
123                   nbits_from_pk( pk ), pubkey_letter( pk->pubkey_algo ),
124                   (ulong)keyid[1], datestr_from_pk( pk ) );
125         p = get_user_id( keyid, &n );
126         tty_print_string( p, n ),
127         m_free(p);
128         tty_printf("\"\n\n");
129     }
130     tty_printf(_(
131 "Please decide how far you trust this user to correctly\n"
132 "verify other users' keys (by looking at passports,\n"
133 "checking fingerprints from different sources...)?\n\n"
134 " 1 = Don't know\n"
135 " 2 = I do NOT trust\n"
136 " 3 = I trust marginally\n"
137 " 4 = I trust fully\n"
138 " s = please show me more information\n") );
139     if( mode )
140         tty_printf(_(" m = back to the main menu\n"));
141     tty_printf("\n");
142
143     for(;;) {
144         /* a string with valid answers */
145         char *ans = _("sSmM");
146
147         if( strlen(ans) != 4 )
148             BUG();
149         p = cpr_get("edit_ownertrust.value",_("Your decision? "));
150         trim_spaces(p);
151         cpr_kill_prompt();
152         if( *p && p[1] )
153             ;
154         else if( !p[1] && (*p >= '1' && *p <= '4') ) {
155             unsigned trust;
156             switch( *p ) {
157               case '1': trust = TRUST_UNDEFINED; break;
158               case '2': trust = TRUST_NEVER    ; break;
159               case '3': trust = TRUST_MARGINAL ; break;
160               case '4': trust = TRUST_FULLY    ; break;
161               default: BUG();
162             }
163             if( !update_ownertrust( lid, trust ) )
164                 changed++;
165             break;
166         }
167         else if( *p == ans[0] || *p == ans[1] ) {
168             tty_printf(_(
169                 "Certificates leading to an ultimately trusted key:\n"));
170             show_paths( lid, 1  );
171         }
172         else if( mode && (*p == ans[2] || *p == ans[3] || *p == CONTROL_D ) ) {
173             break ; /* back to the menu */
174         }
175         m_free(p); p = NULL;
176     }
177     m_free(p);
178     m_free(pk);
179     return changed;
180 }
181
182
183 /****************
184  * Try to add some more owner trusts (interactive)
185  * Returns: -1 if no ownertrust were added.
186  */
187 static int
188 add_ownertrust( PKT_public_key *pk )
189 {
190     int rc;
191     void *context = NULL;
192     ulong lid;
193     unsigned otrust, validity;
194     int any=0, changed=0, any_undefined=0;
195
196     tty_printf(
197 _("Could not find a valid trust path to the key.  Let's see whether we\n"
198   "can assign some missing owner trust values.\n\n"));
199
200     rc = query_trust_record( pk );
201     if( rc ) {
202         log_error("Ooops: not in trustdb\n");
203         return -1;
204     }
205
206     lid = pk->local_id;
207     while( enum_cert_paths( &context, &lid, &otrust, &validity ) != -1 ) {
208         any=1;
209         if( otrust == TRUST_UNDEFINED || otrust == TRUST_EXPIRED ||
210             otrust == TRUST_UNKNOWN ) {
211             any_undefined=1;
212             if( edit_ownertrust( lid, 0 ) )
213                 changed=1;
214         }
215     }
216     enum_cert_paths( &context, NULL, NULL, NULL ); /* release context */
217
218     if( !any )
219         tty_printf(_("No path leading to one of our keys found.\n\n") );
220     else if( !any_undefined )
221         tty_printf(_("No certificates with undefined trust found.\n\n") );
222     else if( !changed )
223         tty_printf(_("No trust values changed.\n\n") );
224
225     return any? 0:-1;
226 }
227
228 /****************
229  * Check whether we can trust this pk which has a trustlevel of TRUSTLEVEL
230  * Returns: true if we trust.
231  */
232 static int
233 do_we_trust( PKT_public_key *pk, int trustlevel )
234 {
235     int rc;
236
237     if( (trustlevel & TRUST_FLAG_REVOKED) ) {
238         log_info(_("key %08lX: key has been revoked!\n"),
239                                         (ulong)keyid_from_pk( pk, NULL) );
240         if( opt.batch )
241             return 0;
242
243         if( !cpr_get_answer_is_yes("revoked_key.override",
244                                     _("Use this key anyway? ")) )
245             return 0;
246     }
247
248
249     switch( (trustlevel & TRUST_MASK) ) {
250       case TRUST_UNKNOWN: /* No pubkey in trustDB: Insert and check again */
251         rc = insert_trust_record( pk );
252         if( rc ) {
253             log_error("failed to insert it into the trustdb: %s\n",
254                                                       g10_errstr(rc) );
255             return 0; /* no */
256         }
257         rc = check_trust( pk, &trustlevel );
258         if( rc )
259             log_fatal("trust check after insert failed: %s\n",
260                                                       g10_errstr(rc) );
261         if( trustlevel == TRUST_UNKNOWN || trustlevel == TRUST_EXPIRED )
262             BUG();
263         return do_we_trust( pk, trustlevel );
264
265       case TRUST_EXPIRED:
266         log_info(_("%08lX: key has expired\n"),
267                                     (ulong)keyid_from_pk( pk, NULL) );
268         return 0; /* no */
269
270       case TRUST_UNDEFINED:
271         if( opt.batch || opt.answer_no )
272             log_info(_("%08lX: no info to calculate a trust probability\n"),
273                                         (ulong)keyid_from_pk( pk, NULL) );
274         else {
275             rc = add_ownertrust( pk );
276             if( !rc ) {
277                 rc = check_trust( pk, &trustlevel );
278                 if( rc )
279                     log_fatal("trust check after add_ownertrust failed: %s\n",
280                                                               g10_errstr(rc) );
281                 /* fixme: this is recursive; we should unroll it */
282                 return do_we_trust( pk, trustlevel );
283             }
284         }
285         return 0;
286
287       case TRUST_NEVER:
288         log_info(_("%08lX: We do NOT trust this key\n"),
289                                         (ulong)keyid_from_pk( pk, NULL) );
290         return 0; /* no */
291
292       case TRUST_MARGINAL:
293         log_info(
294        _("%08lX: It is not sure that this key really belongs to the owner\n"
295          "but it is accepted anyway\n"), (ulong)keyid_from_pk( pk, NULL) );
296         return 1; /* yes */
297
298       case TRUST_FULLY:
299         if( opt.verbose )
300             log_info(_("This key probably belongs to the owner\n"));
301         return 1; /* yes */
302
303       case TRUST_ULTIMATE:
304         if( opt.verbose )
305             log_info(_("This key belongs to us (we have the secret key)\n"));
306         return 1; /* yes */
307
308       default: BUG();
309     }
310
311
312     /* Eventuell fragen falls der trustlevel nicht ausreichend ist */
313
314
315     return 1; /* yes */
316 }
317
318
319 /****************
320  * wrapper around do_we_trust, so we can ask whether to use the
321  * key anyway.
322  */
323 static int
324 do_we_trust_pre( PKT_public_key *pk, int trustlevel )
325 {
326     int rc = do_we_trust( pk, trustlevel );
327
328     if( !opt.batch && !rc ) {
329         tty_printf(_(
330 "It is NOT certain that the key belongs to its owner.\n"
331 "If you *really* know what you are doing, you may answer\n"
332 "the next question with yes\n\n") );
333
334         if( cpr_get_answer_is_yes("untrusted_key.override",
335                                   _("Use this key anyway? "))  )
336             rc = 1;
337     }
338     else if( opt.always_trust && !rc ) {
339         log_info(_("WARNING: Using untrusted key!\n"));
340         rc = 1;
341     }
342     return rc;
343 }
344
345
346
347 /****************
348  * Check whether we can trust this signature.
349  * Returns: Error if we shall not trust this signatures.
350  */
351 int
352 check_signatures_trust( PKT_signature *sig )
353 {
354     PKT_public_key *pk = m_alloc_clear( sizeof *pk );
355     int trustlevel;
356     int dont_try = 0;
357     int rc=0;
358
359     rc = get_pubkey( pk, sig->keyid );
360     if( rc ) { /* this should not happen */
361         log_error("Ooops; the key vanished  - can't check the trust\n");
362         rc = G10ERR_NO_PUBKEY;
363         goto leave;
364     }
365
366   retry:
367     rc = check_trust( pk, &trustlevel );
368     if( rc ) {
369         log_error("check trust failed: %s\n", g10_errstr(rc));
370         goto leave;
371     }
372
373     if( (trustlevel & TRUST_FLAG_REVOKED) ) {
374         write_status( STATUS_KEYREVOKED );
375         log_info(_("WARNING: This key has been revoked by its owner!\n"));
376         log_info(_("         This could mean that the signature is forgery.\n"));
377     }
378
379
380     switch( (trustlevel & TRUST_MASK) ) {
381       case TRUST_UNKNOWN: /* No pubkey in trustDB: Insert and check again */
382         rc = insert_trust_record( pk );
383         if( rc ) {
384             log_error("failed to insert it into the trustdb: %s\n",
385                                                       g10_errstr(rc) );
386             goto leave;
387         }
388         rc = check_trust( pk, &trustlevel );
389         if( rc )
390             log_fatal("trust check after insert failed: %s\n",
391                                                       g10_errstr(rc) );
392         if( trustlevel == TRUST_UNKNOWN || trustlevel == TRUST_EXPIRED )
393             BUG();
394         goto retry;
395
396       case TRUST_EXPIRED:
397         log_info(_("Note: This key has expired!\n"));
398         break;
399
400       case TRUST_UNDEFINED:
401         if( dont_try || opt.batch || opt.answer_no ) {
402             write_status( STATUS_TRUST_UNDEFINED );
403             log_info(_(
404             "WARNING: This key is not certified with a trusted signature!\n"));
405             log_info(_(
406             "         There is no indication that the "
407                                     "signature belongs to the owner.\n" ));
408         }
409         else {
410             rc = add_ownertrust( pk );
411             if( rc ) {
412                 dont_try = 1;
413                 rc = 0;
414             }
415             goto retry;
416         }
417         break;
418
419       case TRUST_NEVER:
420         write_status( STATUS_TRUST_NEVER );
421         log_info(_("WARNING: We do NOT trust this key!\n"));
422         log_info(_("         The signature is probably a FORGERY.\n"));
423         rc = G10ERR_BAD_SIGN;
424         break;
425
426       case TRUST_MARGINAL:
427         write_status( STATUS_TRUST_MARGINAL );
428         log_info(_(
429          "WARNING: This key is not certified with sufficiently trusted signatures!\n"
430                 ));
431         log_info(_(
432          "         It is not certain that the signature belongs to the owner.\n"
433                  ));
434         break;
435
436       case TRUST_FULLY:
437         write_status( STATUS_TRUST_FULLY );
438         break;
439
440       case TRUST_ULTIMATE:
441         write_status( STATUS_TRUST_ULTIMATE );
442         break;
443
444       default: BUG();
445     }
446
447
448   leave:
449     free_public_key( pk );
450     return rc;
451 }
452
453
454 void
455 release_pk_list( PK_LIST pk_list )
456 {
457     PK_LIST pk_rover;
458
459     for( ; pk_list; pk_list = pk_rover ) {
460         pk_rover = pk_list->next;
461         free_public_key( pk_list->pk );
462         m_free( pk_list );
463     }
464 }
465
466 int
467 build_pk_list( STRLIST remusr, PK_LIST *ret_pk_list, unsigned usage )
468 {
469     PK_LIST pk_list = NULL;
470     PKT_public_key *pk=NULL;
471     int rc=0;
472
473     if( !remusr && !opt.batch ) { /* ask */
474         char *answer=NULL;
475
476         tty_printf(_(
477                 "You did not specify a user ID. (you may use \"-r\")\n\n"));
478         for(;;) {
479             rc = 0;
480             m_free(answer);
481             answer = cpr_get_utf8("pklist.user_id.enter",
482                                    _("Enter the user ID: "));
483             trim_spaces(answer);
484             cpr_kill_prompt();
485             if( !*answer )
486                 break;
487             if( pk )
488                 free_public_key( pk );
489             pk = m_alloc_clear( sizeof *pk );
490             pk->pubkey_usage = usage;
491             rc = get_pubkey_byname( NULL, pk, answer, NULL );
492             if( rc )
493                 tty_printf(_("No such user ID.\n"));
494             else if( !(rc=check_pubkey_algo2(pk->pubkey_algo, usage)) ) {
495                 int trustlevel;
496
497                 rc = check_trust( pk, &trustlevel );
498                 if( rc ) {
499                     log_error("error checking pk of '%s': %s\n",
500                                                       answer, g10_errstr(rc) );
501                 }
502                 else if( do_we_trust_pre( pk, trustlevel ) ) {
503                     PK_LIST r;
504
505                     r = m_alloc( sizeof *r );
506                     r->pk = pk; pk = NULL;
507                     r->next = pk_list;
508                     r->mark = 0;
509                     pk_list = r;
510                     break;
511                 }
512             }
513         }
514         m_free(answer);
515         if( pk ) {
516             free_public_key( pk );
517             pk = NULL;
518         }
519     }
520     else {
521         for(; remusr; remusr = remusr->next ) {
522
523             pk = m_alloc_clear( sizeof *pk );
524             pk->pubkey_usage = usage;
525             if( (rc = get_pubkey_byname( NULL, pk, remusr->d, NULL )) ) {
526                 free_public_key( pk ); pk = NULL;
527                 log_error(_("%s: skipped: %s\n"), remusr->d, g10_errstr(rc) );
528             }
529             else if( !(rc=check_pubkey_algo2(pk->pubkey_algo, usage )) ) {
530                 int trustlevel;
531
532                 rc = check_trust( pk, &trustlevel );
533                 if( rc ) {
534                     free_public_key( pk ); pk = NULL;
535                     log_error(_("%s: error checking key: %s\n"),
536                                                       remusr->d, g10_errstr(rc) );
537                 }
538                 else if( do_we_trust_pre( pk, trustlevel ) ) {
539                     /* note: do_we_trust may have changed the trustlevel */
540                     PK_LIST r;
541
542                     r = m_alloc( sizeof *r );
543                     r->pk = pk; pk = NULL;
544                     r->next = pk_list;
545                     r->mark = 0;
546                     pk_list = r;
547                 }
548                 else { /* we don't trust this pk */
549                     free_public_key( pk ); pk = NULL;
550                 }
551             }
552             else {
553                 free_public_key( pk ); pk = NULL;
554                 log_error(_("%s: skipped: %s\n"), remusr->d, g10_errstr(rc) );
555             }
556         }
557     }
558
559
560     if( !rc && !pk_list ) {
561         log_error(_("no valid addressees\n"));
562         rc = G10ERR_NO_USER_ID;
563     }
564
565     if( rc )
566         release_pk_list( pk_list );
567     else
568         *ret_pk_list = pk_list;
569     return rc;
570 }
571
572
573 /****************
574  * Return -1 if we could not find an algorithm.
575  */
576 int
577 select_algo_from_prefs( PK_LIST pk_list, int preftype )
578 {
579     PK_LIST pkr;
580     u32 bits[8];
581     byte *pref = NULL;
582     size_t npref;
583     int i, j;
584     int compr_hack=0;
585     int any;
586
587     if( !pk_list )
588         return -1;
589
590     memset( bits, ~0, 8 * sizeof *bits );
591     for( pkr = pk_list; pkr; pkr = pkr->next ) {
592         u32 mask[8];
593
594         memset( mask, 0, 8 * sizeof *mask );
595         if( !pkr->pk->local_id )
596             BUG(); /* if this occurs, we can use get_ownertrust to set it */
597         if( preftype == PREFTYPE_SYM )
598             bits[0] = (1<<2); /* 3DES is implicitly there */
599         m_free(pref);
600         pref = get_pref_data( pkr->pk->local_id, pkr->pk->namehash, &npref);
601         any = 0;
602         if( pref ) {
603             /*log_hexdump("raw: ", pref, npref );*/
604             for(i=0; i+1 < npref; i+=2 ) {
605                 if( pref[i] == preftype ) {
606                     mask[pref[i+1]/32] |= 1 << (pref[i+1]%32);
607                     any = 1;
608                 }
609             }
610         }
611         if( (!pref || !any) && preftype == PREFTYPE_COMPR ) {
612             mask[0] |= 3; /* asume no_compression and old pgp */
613             compr_hack = 1;
614         }
615
616         /*log_debug("mask=%08lX%08lX%08lX%08lX%08lX%08lX%08lX%08lX\n",
617                (ulong)mask[7], (ulong)mask[6], (ulong)mask[5], (ulong)mask[4],
618              (ulong)mask[3], (ulong)mask[2], (ulong)mask[1], (ulong)mask[0]);*/
619         for(i=0; i < 8; i++ )
620             bits[i] &= mask[i];
621         /*log_debug("bits=%08lX%08lX%08lX%08lX%08lX%08lX%08lX%08lX\n",
622                (ulong)bits[7], (ulong)bits[6], (ulong)bits[5], (ulong)bits[4],
623              (ulong)bits[3], (ulong)bits[2], (ulong)bits[1], (ulong)bits[0]);*/
624     }
625     /* usable algorithms are now in bits
626      * We now use the last key from pk_list to select
627      * the algorithm we want to use. there are no
628      * preferences for the last key, we select the one
629      * corresponding to first set bit.
630      */
631     i = -1;
632     any = 0;
633     if( pref ) {
634         for(j=0; j+1 < npref; j+=2 ) {
635             if( pref[j] == preftype ) {
636                 any = 1;
637                 if( (bits[pref[j+1]/32] & (1<<(pref[j+1]%32))) ) {
638                     i = pref[j+1];
639                     break;
640                 }
641             }
642         }
643     }
644     if( !pref || !any ) {
645         for(j=0; j < 256; j++ )
646             if( (bits[j/32] & (1<<(j%32))) ) {
647                 i = j;
648                 break;
649             }
650     }
651     /*log_debug("prefs of type %d: selected %d\n", preftype, i );*/
652     if( compr_hack && !i ) {
653         /* selected no compression, but we should check whether
654          * algorithm 1 is also available (the ordering is not relevant
655          * in this case). */
656         if( bits[0] & (1<<1) )
657             i = 1;  /* yep; we can use compression algo 1 */
658     }
659
660     m_free(pref);
661     return i;
662 }
663
664