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