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