some import functionality
[gnupg.git] / g10 / import.c
1 /* import.c
2  *      Copyright (c) 1998 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 "main.h"
36
37
38 static int read_block( IOBUF a, compress_filter_context_t *cfx,
39                              PACKET **pending_pkt, KBNODE *ret_root );
40 static int import_one( const char *fname, KBNODE keyblock );
41 static int chk_self_sigs( const char *fname, KBNODE keyblock,
42                           PKT_public_cert *pkc, u32 *keyid );
43 static int delete_inv_parts( const char *fname, KBNODE keyblock, u32 *keyid );
44
45
46 /****************
47  * Import the public keys from the given filename. Input may be armored.
48  * This function rejects alls keys which are not valid self signed on at
49  * least one userid. Only user ids which are self signed will be imported.
50  * Other signatures are not not checked.
51  *
52  * Actually this functtion does a merge. It works like this:
53  *   FIXME: add handling for revocation certs
54  *
55  *  - get the keyblock
56  *  - check self-signatures and remove all userids and their signatures
57  *    without/invalid self-signatures.
58  *  - reject the keyblock, if we have no valid userid.
59  *  - See wether we have this key already in one of our pubrings.
60  *    If not, simply add it to the default keyring.
61  *  - Compare the key and the self-signatures of the new and the one in
62  *    our keyring.  If they are differen something weird is going on;
63  *    ask what to do.
64  *  - See wether we have only non-self-signature on one user id; if not
65  *    ask the user what to do.
66  *  - compare the signatures: If we already have this signature, check
67  *    that they compare okay; if not, issue a warning and ask the user.
68  *    (consider to look at the timestamp and use the newest?)
69  *  - Simply add the signature.  Can't verify here because we may not have
70  *    the signatures public key yet; verification is done when putting it
71  *    into the trustdb, which is done automagically as soon as this pubkey
72  *    is used.
73  *  - Proceed with next signature.
74  *
75  */
76 int
77 import_pubkeys( const char *fname )
78 {
79     armor_filter_context_t afx;
80     compress_filter_context_t cfx;
81     PACKET *pending_pkt = NULL;
82     IOBUF inp = NULL;
83     KBNODE keyblock;
84     int rc = 0;
85
86     memset( &afx, 0, sizeof afx);
87     memset( &cfx, 0, sizeof cfx);
88
89     /* open file */
90     inp = iobuf_open(fname);
91     if( !fname )
92         fname = "[stdin]";
93     if( !inp ) {
94         log_error("%s: can't open file: %s\n", fname, strerror(errno) );
95         return G10ERR_OPEN_FILE;
96     }
97
98     if( !opt.no_armor ) /* armored reading is not diabled */
99         iobuf_push_filter( inp, armor_filter, &afx );
100
101     while( !(rc = read_block( inp, &cfx, &pending_pkt, &keyblock) )) {
102         if( keyblock->pkt->pkttype == PKT_PUBLIC_CERT )
103             rc = import_one( fname, keyblock );
104         else
105             log_info("%s: skipping block of type %d\n",
106                                             fname, keyblock->pkt->pkttype );
107         release_kbnode(keyblock);
108         if( rc )
109             break;
110     }
111     if( rc == -1 )
112         rc = 0;
113     else if( rc )
114         log_error("%s: read error: %s\n", fname, g10_errstr(rc));
115
116     iobuf_close(inp);
117     return rc;
118 }
119
120
121 /****************
122  * Read the next keyblock from stream A, CFX is used to handle
123  * compressed keyblocks. PENDING_PKT should be initialzed to NULL
124  * and not chnaged form the caller.
125  * Retunr: 0 = okay, -1 no more blocks or another errorcode.
126  */
127 static int
128 read_block( IOBUF a, compress_filter_context_t *cfx,
129             PACKET **pending_pkt, KBNODE *ret_root )
130 {
131     int rc;
132     PACKET *pkt;
133     KBNODE root = NULL;
134     int in_cert = 0;
135
136     if( *pending_pkt ) {
137         root = new_kbnode( *pending_pkt );
138         *pending_pkt = NULL;
139     }
140     pkt = m_alloc( sizeof *pkt );
141     init_packet(pkt);
142     while( (rc=parse_packet(a, pkt)) != -1 ) {
143         if( rc ) {  /* ignore errors */
144             if( rc != G10ERR_UNKNOWN_PACKET ) {
145                 log_error("read_block: read error: %s\n", g10_errstr(rc) );
146                 rc = G10ERR_INV_KEYRING;
147                 goto ready;
148             }
149             free_packet( pkt );
150             init_packet(pkt);
151             continue;
152         }
153         /* make a linked list of all packets */
154         switch( pkt->pkttype ) {
155           case PKT_COMPRESSED:
156             if( pkt->pkt.compressed->algorithm == 1 )
157                 cfx->pgpmode = 1;
158             else if( pkt->pkt.compressed->algorithm != 2  ){
159                 rc = G10ERR_COMPR_ALGO;
160                 goto ready;
161             }
162             pkt->pkt.compressed->buf = NULL;
163             iobuf_push_filter( a, compress_filter, cfx );
164             free_packet( pkt );
165             init_packet(pkt);
166             break;
167
168           case PKT_PUBLIC_CERT:
169           case PKT_SECRET_CERT:
170             if( in_cert ) { /* store this packet */
171                 *pending_pkt = pkt;
172                 pkt = NULL;
173                 goto ready;
174             }
175             in_cert = 1;
176           default:
177             if( !root )
178                 root = new_kbnode( pkt );
179             else
180                 add_kbnode( root, new_kbnode( pkt ) );
181             pkt = m_alloc( sizeof *pkt );
182             init_packet(pkt);
183             break;
184         }
185     }
186   ready:
187     if( rc == -1 && root )
188         rc = 0;
189
190     if( rc )
191         release_kbnode( root );
192     else
193         *ret_root = root;
194     free_packet( pkt );
195     m_free( pkt );
196     return rc;
197 }
198
199
200 /****************
201  * Try to import one keyblock.  Return an error only in serious cases, but
202  * never for an invalid keyblock.  It uses log_error to increase the
203  * internal errorcount, so that invalid input can be detected by programs
204  * which called g10.
205  */
206 static int
207 import_one( const char *fname, KBNODE keyblock )
208 {
209     PKT_public_cert *pkc;
210     PKT_public_cert *pkc_orig;
211     KBNODE node, uidnode;
212     KBPOS kbpos;
213     u32 keyid[2];
214     int rc = 0;
215
216     /* get the key and print some infos about it */
217     node = find_kbnode( keyblock, PKT_PUBLIC_CERT );
218     if( !node ) {
219         log_error("%s: Oops; public key not found anymore!\n", fname);
220         return G10ERR_GENERAL; /* really serious */
221     }
222
223     pkc = node->pkt->pkt.public_cert;
224     keyid_from_pkc( pkc, keyid );
225     uidnode = find_next_kbnode( keyblock, PKT_USER_ID );
226
227     if( opt.verbose ) {
228         log_info("%s: pub  %4u%c/%08lX %s   ", fname,
229                   nbits_from_pkc( pkc ),
230                   pubkey_letter( pkc->pubkey_algo ),
231                   (ulong)keyid[1], datestr_from_pkc(pkc) );
232         if( uidnode )
233             print_string( stderr, uidnode->pkt->pkt.user_id->name,
234                                   uidnode->pkt->pkt.user_id->len );
235         putc('\n', stderr);
236     }
237     if( !uidnode ) {
238         log_error("%s: No user id for key %08lX\n", fname, (ulong)keyid[1]);
239         return 0;
240     }
241
242     clear_kbnode_flags( keyblock );
243     rc = chk_self_sigs( fname, keyblock , pkc, keyid );
244     if( rc )
245         return rc== -1? 0:rc;
246     if( !delete_inv_parts( fname, keyblock, keyid ) ) {
247         log_info("%s: key %08lX, no valid user ids left over\n",
248                                                     fname, (ulong)keyid[1]);
249         return 0;
250     }
251
252     /* do we have this key already in one of our pubrings ? */
253     pkc_orig = m_alloc( sizeof *pkc_orig );
254     rc = get_pubkey( pkc_orig, keyid );
255     if( rc && rc != G10ERR_NO_PUBKEY ) {
256         log_error("%s: key %08lX, public key not found: %s\n",
257                                 fname, (ulong)keyid[1], g10_errstr(rc));
258     }
259     else if( rc ) { /* inset this key */
260         /* get default resource */
261         if( get_keyblock_handle( NULL, 0, &kbpos ) ) {
262             log_error("no default public keyring\n");
263             return G10ERR_GENERAL;
264         }
265         if( opt.verbose > 1 )
266             log_info("%s: writing to '%s'\n",
267                                 fname, keyblock_resource_name(&kbpos) );
268         if( (rc=lock_keyblock( &kbpos )) )
269             log_error("can't lock public keyring '%s': %s\n",
270                              keyblock_resource_name(&kbpos), g10_errstr(rc) );
271         else if( (rc=insert_keyblock( &kbpos, keyblock )) )
272             log_error("%s: can't write to '%s': %s\n", fname,
273                              keyblock_resource_name(&kbpos), g10_errstr(rc) );
274         unlock_keyblock( &kbpos );
275         /* we are ready */
276         if( opt.verbose )
277             log_info("%s: key %08lX imported\n", fname, (ulong)keyid[1]);
278     }
279     else {
280        /* merge
281         * o Compare the key and the self-signatures of the new and the one in
282         *   our keyring.  If they are different something weird is going on;
283         *   ask what to do.
284         * o See wether we have only non-self-signature on one user id; if not
285         *   ask the user what to do.
286         * o compare the signatures: If we already have this signature, check
287         *   that they compare okay; if not, issue a warning and ask the user.
288         *   (consider to look at the timestamp and use the newest?)
289         * o Simply add the signature.  Can't verify here because we may not have
290         *   the signatures public key yet; verification is done when putting it
291         *   into the trustdb, which is done automagically as soon as this pubkey
292         *   is used.
293         */
294         log_error("nyi\n");
295     }
296
297     free_public_cert( pkc_orig );
298     return rc;
299 }
300
301 /****************
302  * loop over the keyblock an check all self signatures.
303  * Mark all user-ids with a self-signature by setting flag bit 0.
304  * Mark all user-ids with an invalid self-signature by setting bit 1.
305  */
306 static int
307 chk_self_sigs( const char *fname, KBNODE keyblock,
308                PKT_public_cert *pkc, u32 *keyid )
309 {
310     KBNODE n, unode;
311     PKT_signature *sig;
312     int rc;
313
314     for( n=keyblock; (n = find_next_kbnode(n, 0)); ) {
315         if( n->pkt->pkttype != PKT_SIGNATURE )
316             continue;
317         sig = n->pkt->pkt.signature;
318         if( keyid[0] == sig->keyid[0] && keyid[1] == sig->keyid[1] ) {
319             unode = find_prev_kbnode( keyblock, n, PKT_USER_ID );
320             if( !unode )  {
321                 log_error("%s: key %08lX, no user-id for signature\n",
322                                         fname, (ulong)keyid[1]);
323                 return -1;  /* the complete keyblock is invalid */
324             }
325             rc = check_key_signature( keyblock, n, NULL);
326             if( rc ) {
327                 log_error("%s: key %08lX, invalid self-signature\n",
328                                         fname, (ulong)keyid[1]);
329                 unode->flag |= 2; /* mark as invalid */
330             }
331             unode->flag |= 1; /* mark that user-id checked */
332         }
333     }
334     return 0;
335 }
336
337 /****************
338  * delete all parts which are invalid.
339  * returns: true if at least one valid user-id is left over.
340  */
341 static int
342 delete_inv_parts( const char *fname, KBNODE keyblock, u32 *keyid )
343 {
344     KBNODE node;
345     int nvalid=0;
346
347     for(node=keyblock->next; node; node = node->next ) {
348         if( node->pkt->pkttype == PKT_USER_ID ) {
349             if( (node->flag & 2) || !(node->flag & 1) ) {
350                 log_info("%s: key %08lX, removed userid '",
351                                                   fname, (ulong)keyid[1]);
352                 print_string( stderr, node->pkt->pkt.user_id->name,
353                                       node->pkt->pkt.user_id->len );
354                 fputs("'\n", stderr );
355                 delete_kbnode( node ); /* the user-id */
356                 /* and all following packets up to the next user-id */
357                 while( node->next && node->next->pkt->pkttype != PKT_USER_ID ){
358                     delete_kbnode( node->next );
359                     node = node->next;
360                 }
361             }
362             else
363                 nvalid++;
364         }
365     }
366
367     /* note: because keyblock is the public key, ist is never marked
368      * for deletion and so the keyblock cannot chnage */
369     commit_kbnode( &keyblock );
370     return nvalid;
371 }