import works
[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 static int merge_blocks( const char *fname, KBNODE keyblock_orig,
45                        KBNODE keyblock, u32 *keyid, int *n_uids, int *n_sigs );
46 static int append_uid( KBNODE keyblock, KBNODE node, int *n_sigs,
47                              const char *fname, u32 *keyid );
48 static int merge_sigs( KBNODE dst, KBNODE src, int *n_sigs,
49                              const char *fname, u32 *keyid );
50
51
52 /****************
53  * Import the public keys from the given filename. Input may be armored.
54  * This function rejects alls keys which are not valid self signed on at
55  * least one userid. Only user ids which are self signed will be imported.
56  * Other signatures are not not checked.
57  *
58  * Actually this functtion does a merge. It works like this:
59  *   FIXME: add handling for revocation certs
60  *
61  *  - get the keyblock
62  *  - check self-signatures and remove all userids and their signatures
63  *    without/invalid self-signatures.
64  *  - reject the keyblock, if we have no valid userid.
65  *  - See wether we have this key already in one of our pubrings.
66  *    If not, simply add it to the default keyring.
67  *  - Compare the key and the self-signatures of the new and the one in
68  *    our keyring.  If they are differen something weird is going on;
69  *    ask what to do.
70  *  - See wether we have only non-self-signature on one user id; if not
71  *    ask the user what to do.
72  *  - compare the signatures: If we already have this signature, check
73  *    that they compare okay; if not, issue a warning and ask the user.
74  *    (consider to look at the timestamp and use the newest?)
75  *  - Simply add the signature.  Can't verify here because we may not have
76  *    the signatures public key yet; verification is done when putting it
77  *    into the trustdb, which is done automagically as soon as this pubkey
78  *    is used.
79  *  - Proceed with next signature.
80  *
81  */
82 int
83 import_pubkeys( const char *fname )
84 {
85     armor_filter_context_t afx;
86     compress_filter_context_t cfx;
87     PACKET *pending_pkt = NULL;
88     IOBUF inp = NULL;
89     KBNODE keyblock;
90     int rc = 0;
91
92     memset( &afx, 0, sizeof afx);
93     memset( &cfx, 0, sizeof cfx);
94
95     /* open file */
96     inp = iobuf_open(fname);
97     if( !fname )
98         fname = "[stdin]";
99     if( !inp ) {
100         log_error("%s: can't open file: %s\n", fname, strerror(errno) );
101         return G10ERR_OPEN_FILE;
102     }
103
104     if( !opt.no_armor ) /* armored reading is not diabled */
105         iobuf_push_filter( inp, armor_filter, &afx );
106
107     while( !(rc = read_block( inp, &cfx, &pending_pkt, &keyblock) )) {
108         if( keyblock->pkt->pkttype == PKT_PUBLIC_CERT )
109             rc = import_one( fname, keyblock );
110         else
111             log_info("%s: skipping block of type %d\n",
112                                             fname, keyblock->pkt->pkttype );
113         release_kbnode(keyblock);
114         if( rc )
115             break;
116     }
117     if( rc == -1 )
118         rc = 0;
119     else if( rc )
120         log_error("%s: read error: %s\n", fname, g10_errstr(rc));
121
122     iobuf_close(inp);
123     return rc;
124 }
125
126
127 /****************
128  * Read the next keyblock from stream A, CFX is used to handle
129  * compressed keyblocks. PENDING_PKT should be initialzed to NULL
130  * and not chnaged form the caller.
131  * Retunr: 0 = okay, -1 no more blocks or another errorcode.
132  */
133 static int
134 read_block( IOBUF a, compress_filter_context_t *cfx,
135             PACKET **pending_pkt, KBNODE *ret_root )
136 {
137     int rc;
138     PACKET *pkt;
139     KBNODE root = NULL;
140     int in_cert;
141
142     if( *pending_pkt ) {
143         root = new_kbnode( *pending_pkt );
144         *pending_pkt = NULL;
145         in_cert = 1;
146     }
147     else
148         in_cert = 0;
149     pkt = m_alloc( sizeof *pkt );
150     init_packet(pkt);
151     while( (rc=parse_packet(a, pkt)) != -1 ) {
152         if( rc ) {  /* ignore errors */
153             if( rc != G10ERR_UNKNOWN_PACKET ) {
154                 log_error("read_block: read error: %s\n", g10_errstr(rc) );
155                 rc = G10ERR_INV_KEYRING;
156                 goto ready;
157             }
158             free_packet( pkt );
159             init_packet(pkt);
160             continue;
161         }
162         /* make a linked list of all packets */
163         switch( pkt->pkttype ) {
164           case PKT_COMPRESSED:
165             if( pkt->pkt.compressed->algorithm == 1 )
166                 cfx->pgpmode = 1;
167             else if( pkt->pkt.compressed->algorithm != 2  ){
168                 rc = G10ERR_COMPR_ALGO;
169                 goto ready;
170             }
171             pkt->pkt.compressed->buf = NULL;
172             iobuf_push_filter( a, compress_filter, cfx );
173             free_packet( pkt );
174             init_packet(pkt);
175             break;
176
177
178           case PKT_PUBLIC_CERT:
179           case PKT_SECRET_CERT:
180             if( in_cert ) { /* store this packet */
181                 *pending_pkt = pkt;
182                 pkt = NULL;
183                 goto ready;
184             }
185             in_cert = 1;
186           default:
187             if( in_cert ) {
188                 if( !root )
189                     root = new_kbnode( pkt );
190                 else
191                     add_kbnode( root, new_kbnode( pkt ) );
192                 pkt = m_alloc( sizeof *pkt );
193             }
194             init_packet(pkt);
195             break;
196         }
197     }
198   ready:
199     if( rc == -1 && root )
200         rc = 0;
201
202     if( rc )
203         release_kbnode( root );
204     else
205         *ret_root = root;
206     free_packet( pkt );
207     m_free( pkt );
208     return rc;
209 }
210
211
212 /****************
213  * Try to import one keyblock.  Return an error only in serious cases, but
214  * never for an invalid keyblock.  It uses log_error to increase the
215  * internal errorcount, so that invalid input can be detected by programs
216  * which called g10.
217  */
218 static int
219 import_one( const char *fname, KBNODE keyblock )
220 {
221     PKT_public_cert *pkc;
222     PKT_public_cert *pkc_orig;
223     KBNODE node, uidnode;
224     KBNODE keyblock_orig = NULL;
225     KBPOS kbpos;
226     u32 keyid[2];
227     int rc = 0;
228
229     /* get the key and print some infos about it */
230     node = find_kbnode( keyblock, PKT_PUBLIC_CERT );
231     if( !node ) {
232         log_error("%s: Oops; public key not found anymore!\n", fname);
233         return G10ERR_GENERAL; /* really serious */
234     }
235
236     pkc = node->pkt->pkt.public_cert;
237     keyid_from_pkc( pkc, keyid );
238     uidnode = find_next_kbnode( keyblock, PKT_USER_ID );
239
240     if( opt.verbose ) {
241         log_info("%s: pub  %4u%c/%08lX %s   ", fname,
242                   nbits_from_pkc( pkc ),
243                   pubkey_letter( pkc->pubkey_algo ),
244                   (ulong)keyid[1], datestr_from_pkc(pkc) );
245         if( uidnode )
246             print_string( stderr, uidnode->pkt->pkt.user_id->name,
247                                   uidnode->pkt->pkt.user_id->len );
248         putc('\n', stderr);
249     }
250     if( !uidnode ) {
251         log_error("%s: No user id for key %08lX\n", fname, (ulong)keyid[1]);
252         return 0;
253     }
254
255     clear_kbnode_flags( keyblock );
256     rc = chk_self_sigs( fname, keyblock , pkc, keyid );
257     if( rc )
258         return rc== -1? 0:rc;
259
260     if( !delete_inv_parts( fname, keyblock, keyid ) ) {
261         log_info("%s: key %08lX, no valid user ids\n",
262                                                     fname, (ulong)keyid[1]);
263         return 0;
264     }
265
266     /* do we have this key already in one of our pubrings ? */
267     pkc_orig = m_alloc_clear( sizeof *pkc_orig );
268     rc = get_pubkey( pkc_orig, keyid );
269     if( rc && rc != G10ERR_NO_PUBKEY ) {
270         log_error("%s: key %08lX, public key not found: %s\n",
271                                 fname, (ulong)keyid[1], g10_errstr(rc));
272     }
273     else if( rc ) { /* insert this key */
274         /* get default resource */
275         if( get_keyblock_handle( NULL, 0, &kbpos ) ) {
276             log_error("no default public keyring\n");
277             return G10ERR_GENERAL;
278         }
279         if( opt.verbose > 1 )
280             log_info("%s: writing to '%s'\n",
281                                 fname, keyblock_resource_name(&kbpos) );
282         if( (rc=lock_keyblock( &kbpos )) )
283             log_error("can't lock public keyring '%s': %s\n",
284                              keyblock_resource_name(&kbpos), g10_errstr(rc) );
285         else if( (rc=insert_keyblock( &kbpos, keyblock )) )
286             log_error("%s: can't write to '%s': %s\n", fname,
287                              keyblock_resource_name(&kbpos), g10_errstr(rc) );
288         unlock_keyblock( &kbpos );
289         /* we are ready */
290         log_info("%s: key %08lX imported\n", fname, (ulong)keyid[1]);
291     }
292     else { /* merge */
293         int n_uids, n_sigs;
294
295         /* Compare the original against the new key; just to be sure nothing
296          * weird is going on */
297         if( cmp_public_certs( pkc_orig, pkc ) ) {
298             log_error("%s: key %08lX, doesn't match our copy\n",
299                                                     fname, (ulong)keyid[1]);
300             rc = G10ERR_GENERAL;
301             goto leave;
302         }
303
304         /* See wether we have only non-self-signature on one user id; if not
305          * ask the user what to do. <--- fixme */
306
307         /* now read the original keyblock */
308         rc = find_keyblock_bypkc( &kbpos, pkc_orig );
309         if( rc ) {
310             log_error("%s: key %08lX, can't locate original keyblock: %s\n",
311                                      fname, (ulong)keyid[1], g10_errstr(rc));
312             goto leave;
313         }
314         rc = read_keyblock( &kbpos, &keyblock_orig );
315         if( rc ) {
316             log_error("%s: key %08lX, can't read original keyblock: %s\n",
317                                      fname, (ulong)keyid[1], g10_errstr(rc));
318             goto leave;
319         }
320         /* and try to merge the block */
321         clear_kbnode_flags( keyblock_orig );
322         clear_kbnode_flags( keyblock );
323         n_uids = n_sigs = 0;
324         rc = merge_blocks( fname, keyblock_orig, keyblock,
325                                 keyid, &n_uids, &n_sigs );
326         if( rc )
327             goto leave;
328         if( n_uids || n_sigs ) { /* keyblock_orig has been updated; write */
329             if( opt.verbose > 1 )
330                 log_info("%s: writing to '%s'\n",
331                                     fname, keyblock_resource_name(&kbpos) );
332             if( (rc=lock_keyblock( &kbpos )) )
333                 log_error("can't lock public keyring '%s': %s\n",
334                                  keyblock_resource_name(&kbpos), g10_errstr(rc) );
335             else if( (rc=insert_keyblock( &kbpos, keyblock )) )
336                 log_error("%s: can't write to '%s': %s\n", fname,
337                                  keyblock_resource_name(&kbpos), g10_errstr(rc) );
338             unlock_keyblock( &kbpos );
339             /* we are ready */
340             if( n_uids == 1 )
341                 log_info("%s: key %08lX, 1 new user-id\n",
342                                          fname, (ulong)keyid[1]);
343             else if( n_uids )
344                 log_info("%s: key %08lX, %d new user-ids\n",
345                                          fname, (ulong)keyid[1], n_uids );
346             if( n_sigs == 1 )
347                 log_info("%s: key %08lX, 1 new signature\n",
348                                          fname, (ulong)keyid[1]);
349             else if( n_sigs )
350                 log_info("%s: key %08lX, %d new signatures\n",
351                                          fname, (ulong)keyid[1], n_sigs );
352         }
353         else
354             log_info("%s: key %08lX, not changed\n", fname, (ulong)keyid[1] );
355     }
356
357   leave:
358     release_kbnode( keyblock_orig );
359     free_public_cert( pkc_orig );
360     return rc;
361 }
362
363
364 /****************
365  * loop over the keyblock an check all self signatures.
366  * Mark all user-ids with a self-signature by setting flag bit 0.
367  * Mark all user-ids with an invalid self-signature by setting bit 1.
368  */
369 static int
370 chk_self_sigs( const char *fname, KBNODE keyblock,
371                PKT_public_cert *pkc, u32 *keyid )
372 {
373     KBNODE n, unode;
374     PKT_signature *sig;
375     int rc;
376
377     for( n=keyblock; (n = find_next_kbnode(n, 0)); ) {
378         if( n->pkt->pkttype != PKT_SIGNATURE )
379             continue;
380         sig = n->pkt->pkt.signature;
381         if( keyid[0] == sig->keyid[0] && keyid[1] == sig->keyid[1] ) {
382             unode = find_prev_kbnode( keyblock, n, PKT_USER_ID );
383             if( !unode )  {
384                 log_error("%s: key %08lX, no user-id for signature\n",
385                                         fname, (ulong)keyid[1]);
386                 return -1;  /* the complete keyblock is invalid */
387             }
388             rc = check_key_signature( keyblock, n, NULL);
389             if( rc ) {
390                 log_error("%s: key %08lX, invalid self-signature\n",
391                                         fname, (ulong)keyid[1]);
392                 unode->flag |= 2; /* mark as invalid */
393             }
394             unode->flag |= 1; /* mark that user-id checked */
395         }
396     }
397     return 0;
398 }
399
400 /****************
401  * delete all parts which are invalidand those signatures whos
402  * public key algorithm is not availabe in this implemenation;
403  * but consider RSA as valid, because parse/build_packets knows
404  * about it.
405  * returns: true if at least one valid user-id is left over.
406  */
407 static int
408 delete_inv_parts( const char *fname, KBNODE keyblock, u32 *keyid )
409 {
410     KBNODE node;
411     int nvalid=0;
412
413     for(node=keyblock->next; node; node = node->next ) {
414         if( node->pkt->pkttype == PKT_USER_ID ) {
415             if( (node->flag & 2) || !(node->flag & 1) ) {
416                 if( opt.verbose ) {
417                     log_info("%s: key %08lX, removed userid '",
418                                                   fname, (ulong)keyid[1]);
419                     print_string( stderr, node->pkt->pkt.user_id->name,
420                                       node->pkt->pkt.user_id->len );
421                     fputs("'\n", stderr );
422                 }
423                 delete_kbnode( node ); /* the user-id */
424                 /* and all following packets up to the next user-id */
425                 while( node->next && node->next->pkt->pkttype != PKT_USER_ID ){
426                     delete_kbnode( node->next );
427                     node = node->next;
428                 }
429             }
430             else
431                 nvalid++;
432         }
433         else if( node->pkt->pkttype == PKT_SIGNATURE
434                  && check_pubkey_algo( node->pkt->pkt.signature->pubkey_algo)
435                  && node->pkt->pkt.signature->pubkey_algo != PUBKEY_ALGO_RSA )
436             delete_kbnode( node ); /* build_packet() can't handle this */
437     }
438
439     /* note: because keyblock is the public key, it is never marked
440      * for deletion and so keyblock cannot change */
441     commit_kbnode( &keyblock );
442     return nvalid;
443 }
444
445
446 /****************
447  * compare and merge the blocks
448  *
449  * o compare the signatures: If we already have this signature, check
450  *   that they compare okay; if not, issue a warning and ask the user.
451  *   FIXME: add the check, that we don` have duplicate signatures and the
452  *   warning in cases that the old/new signatures don't match.
453  * o Simply add the signature.  Can't verify here because we may not have
454  *   the signatures public key yet; verification is done when putting it
455  *   into the trustdb, which is done automagically as soon as this pubkey
456  *   is used.
457  * Note: We indicate newly inserted packets with flag bit 0
458  */
459 static int
460 merge_blocks( const char *fname, KBNODE keyblock_orig, KBNODE keyblock,
461                                    u32 *keyid, int *n_uids, int *n_sigs )
462 {
463     KBNODE node_orig, node;
464     int rc;
465
466     /* first, try to merge new ones in */
467     for(node_orig=keyblock_orig->next; node_orig; node_orig=node_orig->next ) {
468         if( !(node_orig->flag & 1) && node_orig->pkt->pkttype == PKT_USER_ID) {
469             /* find the user id in the imported keyblock */
470             for(node=keyblock->next; node; node=node->next )
471                 if( !(node->flag & 1)
472                     && node->pkt->pkttype == PKT_USER_ID
473                     && !cmp_user_ids( node_orig->pkt->pkt.user_id,
474                                           node->pkt->pkt.user_id ) )
475                     break;
476             if( node ) { /* found: merge */
477                 rc = merge_sigs( node_orig, node, n_sigs, fname, keyid );
478                 if( rc )
479                     return rc;
480             }
481         }
482     }
483
484     /* second, add new user-ids */
485     for(node=keyblock->next; node; node=node->next ) {
486         if( !(node->flag & 1) && node->pkt->pkttype == PKT_USER_ID) {
487             /* do we have this in the original keyblock */
488             for(node_orig=keyblock_orig->next; node_orig;
489                                                 node_orig=node_orig->next )
490                 if( !(node_orig->flag & 1)
491                     && node_orig->pkt->pkttype == PKT_USER_ID
492                     && cmp_user_ids( node_orig->pkt->pkt.user_id,
493                                      node->pkt->pkt.user_id ) )
494                     break;
495             if( !node ) { /* this is a new user id: append */
496                 rc = append_uid( keyblock_orig, node, n_sigs, fname, keyid);
497                 if( rc )
498                     return rc;
499                 ++*n_uids;
500             }
501         }
502     }
503
504     return 0;
505 }
506
507
508 /****************
509  * append the userid starting with NODE and all signatures to KEYBLOCK.
510  * Mark all new and copied packets by setting flag bit 0.
511  */
512 static int
513 append_uid( KBNODE keyblock, KBNODE node, int *n_sigs,
514                                           const char *fname, u32 *keyid )
515 {
516     KBNODE n;
517
518     assert(node->pkt->pkttype == PKT_USER_ID );
519     /* at lease a self signature comes next to the user-id */
520     if( node->next->pkt->pkttype == PKT_USER_ID ) {
521         log_error("%s: key %08lX, our copy has no self-signature\n",
522                                                   fname, (ulong)keyid[1]);
523         return G10ERR_GENERAL;
524     }
525
526     for( ;node && node->pkt->pkttype != PKT_USER_ID; node = node->next ) {
527         /* we add a clone to the original keyblock, because this
528          * one is released first */
529         n = clone_kbnode(node);
530         add_kbnode( keyblock, n );
531         node->flag |= 1;
532         n->flag |= 1;
533         if( n->pkt->pkttype == PKT_SIGNATURE )
534             ++*n_sigs;
535     }
536
537     return 0;
538 }
539
540
541 /****************
542  * Merge the sigs from SRC onto DST. SRC and DST are both a PKT_USER_ID.
543  * (how should we handle comment packets here?)
544  */
545 static int
546 merge_sigs( KBNODE dst, KBNODE src, int *n_sigs,
547                                     const char *fname, u32 *keyid )
548 {
549     KBNODE n, n2;
550     int found=0;
551
552     assert(dst->pkt->pkttype == PKT_USER_ID );
553     assert(src->pkt->pkttype == PKT_USER_ID );
554     /* at least a self signature comes next to the user-ids */
555     assert(src->next->pkt->pkttype != PKT_USER_ID );
556     if( dst->next->pkt->pkttype == PKT_USER_ID ) {
557         log_error("%s: key %08lX, our copy has no self-signature\n",
558                                                   fname, (ulong)keyid[1]);
559         return 0;
560     }
561
562
563     for(n=src->next; n && n->pkt->pkttype != PKT_USER_ID; n = n->next ) {
564         if( n->pkt->pkttype != PKT_SIGNATURE )
565             continue;
566         found = 0;
567         for(n2=dst->next; n2 && n2->pkt->pkttype != PKT_USER_ID; n2 = n2->next)
568             if( n2->pkt->pkttype == PKT_SIGNATURE
569                 && n->pkt->pkt.signature->keyid[0]
570                    == n2->pkt->pkt.signature->keyid[0]
571                 && n->pkt->pkt.signature->keyid[1]
572                    == n2->pkt->pkt.signature->keyid[1] ) {
573             found++;
574             break;
575         }
576
577         if( found ) { /* we already have this signature */
578             /* Hmmm: should we compare the timestamp etc?
579              * but then we have first to see wether this signature is valid
580              * - or - simply add it in such a case and let trustdb logic
581              * decide wether to remove the old one
582              */
583             continue;
584         }
585
586         /* This signature is new, append N to DST it.
587          * We add a clone to the original keyblock, because this
588          * one is released first */
589         n2 = clone_kbnode(n);
590         insert_kbnode( dst, n2, PKT_USER_ID );
591         n2->flag |= 1;
592         n->flag |= 1;
593         ++*n_sigs;
594     }
595
596     return 0;
597 }
598