bd871a9dfc585b019c7fc584c18fae01a7837b0a
[gnupg.git] / g10 / pkclist.c
1 /* pkclist.c
2  *      Copyright (c) 1997 by Werner Koch (dd9jn)
3  *
4  * This file is part of G10.
5  *
6  * G10 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  * G10 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
37 static int
38 query_ownertrust( PKT_public_cert *pkc )
39 {
40     char *p;
41     size_t n;
42     u32 keyid[2];
43
44     keyid_from_pkc( pkc, keyid );
45     tty_printf("No ownertrust specified for:\n"
46                "%4u%c/%08lX %s \"",
47               nbits_from_pkc( pkc ), pubkey_letter( pkc->pubkey_algo ),
48               (ulong)keyid[1], datestr_from_pkc( pkc ) );
49     p = get_user_id( keyid, &n );
50     tty_print_string( p, n ),
51     m_free(p);
52     tty_printf("\"\n\n"
53 "Please decide in how far do you trust this user to\n"
54 "correctly sign other users keys (looking at his passport,\n"
55 "checking the fingerprints from different sources ...)?\n\n"
56 " 1 = Don't know\n"
57 " 2 = I do NOT trust\n"
58 " 3 = I trust marginally\n"
59 " 4 = I trust fully\n"
60 " s = please show me more informations\n\n" );
61
62     for(;;) {
63         p = tty_get("Your decision? ");
64         trim_spaces(p);
65         tty_kill_prompt();
66         if( *p && p[1] )
67             ;
68         else if( *p == '?' ) {
69             tty_printf(
70 "It's up to you to assign a value here; this value will never be exported\n"
71 "to any 3rd party.  We need it to implement the web-of-trust; it has nothing\n"
72 "to do with the (implicitly created) web-of-certificates.\n");
73         }
74         else if( !p[1] && (*p >= '1' && *p <= '4') ) {
75             /* okay */
76             break;
77         }
78         else if( *p == 's' || *p == 'S' ) {
79             tty_printf("You will see a list of signators etc. here\n");
80         }
81         m_free(p); p = NULL;
82     }
83     m_free(p);
84     return 0;
85 }
86
87
88
89 /****************
90  * Check wether we can trust this pkc which has a trustlevel of TRUSTLEVEL
91  * Returns: true if we trust.
92  */
93 static int
94 do_we_trust( PKT_public_cert *pkc, int trustlevel )
95 {
96     int rc;
97
98     switch( trustlevel ) {
99       case TRUST_UNKNOWN: /* No pubkey in trustDB: Insert and check again */
100         rc = insert_trust_record( pkc );
101         if( rc ) {
102             log_error("failed to insert it into the trustdb: %s\n",
103                                                       g10_errstr(rc) );
104             return 0; /* no */
105         }
106         rc = check_trust( pkc, &trustlevel );
107         if( rc )
108             log_fatal("trust check after insert failed: %s\n",
109                                                       g10_errstr(rc) );
110         if( trustlevel == TRUST_UNKNOWN || trustlevel == TRUST_EXPIRED )
111             BUG();
112         return do_we_trust( pkc, trustlevel );
113
114       case TRUST_EXPIRED:
115         log_error("trust has expired: NOT yet implemented\n");
116         return 0; /* no */
117
118       case TRUST_UNDEFINED:
119         if( opt.batch || opt.answer_no )
120             log_info("no info to calculate a trust probability\n");
121         else {
122             query_ownertrust( pkc );
123         }
124         return 0; /* no */
125
126       case TRUST_NEVER:
127         log_info("We do NOT trust this key\n");
128         return 0; /* no */
129
130       case TRUST_MARGINAL:
131         log_info("I'm not sure wether this keys really belongs to the owner\n"
132                  "but I proceed anyway\n");
133         return 1; /* yes */
134
135       case TRUST_FULLY:
136         log_info("This key probably belongs to the owner\n");
137         return 1; /* yes */
138
139       case TRUST_ULTIMATE:
140         log_info("Our own key is always good.\n");
141         return 1; /* yes */
142
143       default: BUG();
144     }
145
146
147     /* Eventuell fragen falls der trustlevel nicht ausreichend ist */
148
149
150     return 1; /* yes */
151 }
152
153
154
155 void
156 release_pkc_list( PKC_LIST pkc_list )
157 {
158     PKC_LIST pkc_rover;
159
160     for( ; pkc_list; pkc_list = pkc_rover ) {
161         pkc_rover = pkc_list->next;
162         free_public_cert( pkc_list->pkc );
163         m_free( pkc_list );
164     }
165 }
166
167 int
168 build_pkc_list( STRLIST remusr, PKC_LIST *ret_pkc_list )
169 {
170     PKC_LIST pkc_list = NULL;
171     int rc;
172
173     if( !remusr ) { /* ask!!! */
174         log_bug("ask for public key nyi\n");
175     }
176     else {
177         for(; remusr; remusr = remusr->next ) {
178             PKT_public_cert *pkc;
179
180             pkc = m_alloc_clear( sizeof *pkc );
181             if( (rc = get_pubkey_byname( pkc, remusr->d )) ) {
182                 free_public_cert( pkc ); pkc = NULL;
183                 log_error("skipped '%s': %s\n", remusr->d, g10_errstr(rc) );
184             }
185             else if( !(rc=check_pubkey_algo(pkc->pubkey_algo)) ) {
186                 int trustlevel;
187
188                 rc = check_trust( pkc, &trustlevel );
189                 if( rc ) {
190                     free_public_cert( pkc ); pkc = NULL;
191                     log_error("error checking pkc of '%s': %s\n",
192                                                       remusr->d, g10_errstr(rc) );
193                 }
194                 else if( do_we_trust( pkc, trustlevel ) ) {
195                     /* note: do_we_trust may have changed the trustlevel */
196                     PKC_LIST r;
197
198                     r = m_alloc( sizeof *r );
199                     r->pkc = pkc; pkc = NULL;
200                     r->next = pkc_list;
201                     r->mark = 0;
202                     pkc_list = r;
203                 }
204                 else { /* we don't trust this pkc */
205                     free_public_cert( pkc ); pkc = NULL;
206                 }
207             }
208             else {
209                 free_public_cert( pkc ); pkc = NULL;
210                 log_error("skipped '%s': %s\n", remusr->d, g10_errstr(rc) );
211             }
212         }
213     }
214
215
216     if( !rc && !pkc_list ) {
217         log_error("no valid addressees\n");
218         rc = G10ERR_NO_USER_ID;
219     }
220
221     if( rc )
222         release_pkc_list( pkc_list );
223     else
224         *ret_pkc_list = pkc_list;
225     return rc;
226 }
227
228