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