Fixed a few bugs
[gnupg.git] / g10 / ringedit.c
1 /* ringedit.c -  Function for key ring editing
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
22 /****************
23  * This module supplies function for:
24  *
25  *  - Search for a key block (pubkey and all other stuff) and return a
26  *    handle for it.
27  *
28  *  - Lock/Unlock a key block
29  *
30  *  - Read a key block into a tree
31  *
32  *  - Update a key block
33  *
34  *  - Insert a new key block
35  *
36  *  - Delete a key block
37  *
38  * FIXME:  Add backup stuff
39  * FIXME:  Keep track of all nodes, so that a change is propagated
40  *         to all nodes. (or use shallow copies and ref-counting?)
41  */
42
43
44
45 #include <config.h>
46 #include <stdio.h>
47 #include <stdlib.h>
48 #include <string.h>
49 #include <assert.h>
50 #include "util.h"
51 #include "packet.h"
52 #include "memory.h"
53 #include "mpi.h"
54 #include "iobuf.h"
55 #include "keydb.h"
56 #include <unistd.h> /* for truncate */
57
58
59 struct resource_table_struct {
60     int used;
61     int secret; /* this is a secret keyring */
62     char *fname;
63     IOBUF iobuf;
64 };
65 typedef struct resource_table_struct RESTBL;
66
67 #define MAX_RESOURCES 10
68 static RESTBL resource_table[MAX_RESOURCES];
69
70
71 static int search( PACKET *pkt, KBPOS *kbpos, int secret );
72
73
74 static int keyring_search( PACKET *pkt, KBPOS *kbpos, IOBUF iobuf );
75 static int keyring_search2( PUBKEY_FIND_INFO info, KBPOS *kbpos,
76                                                    const char *fname);
77 static int keyring_read( KBPOS *kbpos, KBNODE *ret_root );
78 static int keyring_insert( KBPOS *kbpos, KBNODE root );
79 static int keyring_delete( KBPOS *kbpos );
80
81
82
83 static RESTBL *
84 check_pos( KBPOS *kbpos )
85 {
86     if( kbpos->resno < 0 || kbpos->resno >= MAX_RESOURCES )
87         return NULL;
88     if( !resource_table[kbpos->resno].used )
89         return NULL;
90     return resource_table + kbpos->resno;
91 }
92
93
94
95 /****************************************************************
96  ****************** public functions ****************************
97  ****************************************************************/
98
99 /****************
100  * Register a resource (which currently may ionly be a keyring file).
101  */
102 int
103 add_keyblock_resource( const char *filename, int force, int secret )
104 {
105     IOBUF iobuf;
106     int i;
107
108     for(i=0; i < MAX_RESOURCES; i++ )
109         if( !resource_table[i].used )
110             break;
111     if( i == MAX_RESOURCES )
112         return G10ERR_RESOURCE_LIMIT;
113
114     iobuf = iobuf_open( filename );
115     if( !iobuf && !force )
116         return G10ERR_OPEN_FILE;
117     resource_table[i].used = 1;
118     resource_table[i].secret = !!secret;
119     resource_table[i].fname = m_strdup(filename);
120     resource_table[i].iobuf = iobuf;
121     return 0;
122 }
123
124
125 /****************
126  * Get a keyblock handle KBPOS from a filename. This can be used
127  * to get a handle for insert_keyblock for a new keyblock.
128  */
129 int
130 get_keyblock_handle( const char *filename, int secret, KBPOS *kbpos )
131 {
132     int i;
133
134     for(i=0; i < MAX_RESOURCES; i++ )
135         if( resource_table[i].used && !resource_table[i].secret == !secret ) {
136             /* fixme: dos needs case insensitive file compare */
137             if( !strcmp( resource_table[i].fname, filename ) ) {
138                 memset( kbpos, 0, sizeof *kbpos );
139                 kbpos->resno = i;
140                 return 0;
141             }
142         }
143     return -1; /* not found */
144 }
145
146
147 /****************
148  * Find a keyblock from the informations provided in INFO
149  * This can only be used fro public keys
150  */
151 int
152 find_keyblock( PUBKEY_FIND_INFO info, KBPOS *kbpos )
153 {
154     int i, rc, last_rc=-1;
155
156     for(i=0; i < MAX_RESOURCES; i++ ) {
157         if( resource_table[i].used && !resource_table[i].secret ) {
158             /* note: here we have to add different search functions,
159              * depending on the type of the resource */
160             rc = keyring_search2( info, kbpos, resource_table[i].fname );
161             if( !rc ) {
162                 kbpos->resno = i;
163                 return 0;
164             }
165             if( rc != -1 ) {
166                 log_error("error searching resource %d: %s\n",
167                                                   i, g10_errstr(rc));
168                 last_rc = rc;
169             }
170         }
171     }
172     return last_rc;
173 }
174
175
176
177 /****************
178  * Search a keyblock which starts with the given packet and put all
179  * informations into KBPOS, which can be used later to access this key block.
180  * This function looks into all registered keyblock sources.
181  * PACKET must be a packet with either a secret_cert or a public_cert
182  *
183  * This function is intended to check wether a given certificate
184  * is already in a keyring or to prepare it for editing.
185  *
186  * Returns: 0 if found, -1 if not found or an errorcode.
187  */
188 static int
189 search( PACKET *pkt, KBPOS *kbpos, int secret )
190 {
191     int i, rc, last_rc=-1;
192
193     for(i=0; i < MAX_RESOURCES; i++ ) {
194         if( resource_table[i].used && !resource_table[i].secret == !secret ) {
195             /* note: here we have to add different search functions,
196              * depending on the type of the resource */
197             rc = keyring_search( pkt, kbpos, resource_table[i].iobuf );
198             if( !rc ) {
199                 kbpos->resno = i;
200                 return 0;
201             }
202             if( rc != -1 ) {
203                 log_error("error searching resource %d: %s\n",
204                                                   i, g10_errstr(rc));
205                 last_rc = rc;
206             }
207         }
208     }
209     return last_rc;
210 }
211
212
213 /****************
214  * Combined function to search for a username and get the position
215  * of the keyblock.
216  */
217 int
218 find_keyblock_byname( KBPOS *kbpos, const char *username )
219 {
220     PACKET pkt;
221     PKT_public_cert *pkc = m_alloc_clear( sizeof *pkc );
222     int rc;
223
224     rc = get_pubkey_byname( pkc, username );
225     if( rc ) {
226         free_public_cert(pkc);
227         return rc;
228     }
229
230     init_packet( &pkt );
231     pkt.pkttype = PKT_PUBLIC_CERT;
232     pkt.pkt.public_cert = pkc;
233     rc = search( &pkt, kbpos, 0 );
234     free_public_cert(pkc);
235     return rc;
236 }
237
238 /****************
239  * Combined function to search for a username and get the position
240  * of the keyblock. This function does not unprotect the secret key.
241  */
242 int
243 find_secret_keyblock_byname( KBPOS *kbpos, const char *username )
244 {
245     PACKET pkt;
246     PKT_secret_cert *skc = m_alloc_clear( sizeof *skc );
247     int rc;
248
249     rc = get_seckey_byname( skc, username, 0 );
250     if( rc ) {
251         free_secret_cert(skc);
252         return rc;
253     }
254
255     init_packet( &pkt );
256     pkt.pkttype = PKT_SECRET_CERT;
257     pkt.pkt.secret_cert = skc;
258     rc = search( &pkt, kbpos, 1 );
259     free_secret_cert(skc);
260     return rc;
261 }
262
263
264 /****************
265  * Lock the keyblock; wait until it's available
266  * This function may change the internal data in kbpos, in cases
267  * when the to be locked keyblock has been modified.
268  * fixme: remove this function and add an option to search()?
269  */
270 int
271 lock_keyblock( KBPOS *kbpos )
272 {
273     if( !check_pos(kbpos) )
274         return G10ERR_GENERAL;
275     return 0;
276 }
277
278 /****************
279  * Release a lock on a keyblock
280  */
281 void
282 unlock_keyblock( KBPOS *kbpos )
283 {
284     if( !check_pos(kbpos) )
285         BUG();
286 }
287
288 /****************
289  * Read a complete keyblock and return the root in ret_root.
290  */
291 int
292 read_keyblock( KBPOS *kbpos, KBNODE *ret_root )
293 {
294     if( !check_pos(kbpos) )
295         return G10ERR_GENERAL;
296     return keyring_read( kbpos, ret_root );
297 }
298
299 /****************
300  * Insert the keyblock described by ROOT into the keyring described
301  * by KBPOS.  This actually appends the data to the keyfile.
302  */
303 int
304 insert_keyblock( KBPOS *kbpos, KBNODE root )
305 {
306     int rc;
307
308     if( !check_pos(kbpos) )
309         return G10ERR_GENERAL;
310
311     rc = keyring_insert( kbpos, root );
312
313     return rc;
314 }
315
316 /****************
317  * Delete the keyblock described by KBPOS.
318  * The current code simply changes the keyblock in the keyring
319  * to packet of type 0 with the correct length.  To help detecting errors,
320  * zero bytes are written.
321  */
322 int
323 delete_keyblock( KBPOS *kbpos )
324 {
325     int rc;
326
327     if( !check_pos(kbpos) )
328         return G10ERR_GENERAL;
329
330     rc = keyring_delete( kbpos );
331
332     return rc;
333 }
334
335
336 /****************
337  * Update the keyblock at KBPOS with the one in ROOT.
338  */
339 int
340 update_keyblock( KBPOS *kbpos, KBNODE root )
341 {
342     int rc;
343     KBPOS kbpos2;
344
345     /* we do it the simple way: */
346     memset( &kbpos2, 0, sizeof kbpos2 );
347     kbpos2.resno = kbpos->resno;
348     rc = insert_keyblock( &kbpos2, root );
349     if( !rc )
350         rc = delete_keyblock( kbpos );
351
352     return rc;
353 }
354
355
356 /****************************************************************
357  ********** Functions which operates on regular keyrings ********
358  ****************************************************************/
359
360
361 /****************
362  * search one keyring, return 0 if found, -1 if not found or an errorcode.
363  */
364 static int
365 keyring_search( PACKET *req, KBPOS *kbpos, IOBUF iobuf )
366 {
367     int rc;
368     PACKET pkt;
369     int save_mode;
370     ulong offset;
371     int pkttype = req->pkttype;
372     PKT_public_cert *req_pkc = req->pkt.public_cert;
373     PKT_secret_cert *req_skc = req->pkt.secret_cert;
374
375     init_packet(&pkt);
376     save_mode = set_packet_list_mode(0);
377
378     if( iobuf_seek( iobuf, 0 ) ) {
379         log_error("can't rewind keyring file: %s\n", g10_errstr(rc));
380         rc = G10ERR_KEYRING_OPEN;
381         goto leave;
382     }
383
384     while( !(rc=search_packet(iobuf, &pkt, pkttype, &offset)) ) {
385         if( pkt.pkttype == PKT_SECRET_CERT ) {
386             PKT_secret_cert *skc = pkt.pkt.secret_cert;
387
388             if(   req_skc->timestamp == skc->timestamp
389                && req_skc->valid_days == skc->valid_days
390                && req_skc->pubkey_algo == skc->pubkey_algo
391                && (   ( skc->pubkey_algo == PUBKEY_ALGO_ELGAMAL
392                         && !mpi_cmp( req_skc->d.elg.p, skc->d.elg.p )
393                         && !mpi_cmp( req_skc->d.elg.g, skc->d.elg.g )
394                         && !mpi_cmp( req_skc->d.elg.y, skc->d.elg.y )
395                         && !mpi_cmp( req_skc->d.elg.x, skc->d.elg.x )
396                       )
397                    || ( skc->pubkey_algo == PUBKEY_ALGO_RSA
398                         && !mpi_cmp( req_skc->d.rsa.rsa_n, skc->d.rsa.rsa_n )
399                         && !mpi_cmp( req_skc->d.rsa.rsa_e, skc->d.rsa.rsa_e )
400                         && !mpi_cmp( req_skc->d.rsa.rsa_d, skc->d.rsa.rsa_d )
401                       )
402                   )
403               )
404                 break; /* found */
405         }
406         else if( pkt.pkttype == PKT_PUBLIC_CERT ) {
407             PKT_public_cert *pkc = pkt.pkt.public_cert;
408
409             if(   req_pkc->timestamp == pkc->timestamp
410                && req_pkc->valid_days == pkc->valid_days
411                && req_pkc->pubkey_algo == pkc->pubkey_algo
412                && (   ( pkc->pubkey_algo == PUBKEY_ALGO_ELGAMAL
413                         && !mpi_cmp( req_pkc->d.elg.p, pkc->d.elg.p )
414                         && !mpi_cmp( req_pkc->d.elg.g, pkc->d.elg.g )
415                         && !mpi_cmp( req_pkc->d.elg.y, pkc->d.elg.y )
416                       )
417                    || ( pkc->pubkey_algo == PUBKEY_ALGO_RSA
418                         && !mpi_cmp( req_pkc->d.rsa.rsa_n, pkc->d.rsa.rsa_n )
419                         && !mpi_cmp( req_pkc->d.rsa.rsa_e, pkc->d.rsa.rsa_e )
420                       )
421                   )
422               )
423                 break; /* found */
424         }
425         else
426             BUG();
427         free_packet(&pkt);
428     }
429     if( !rc )
430         kbpos->offset = offset;
431
432   leave:
433     free_packet(&pkt);
434     set_packet_list_mode(save_mode);
435     return rc;
436 }
437
438 /****************
439  * search one keyring, return 0 if found, -1 if not found or an errorcode.
440  * this version uses the finger print and other informations
441  */
442 static int
443 keyring_search2( PUBKEY_FIND_INFO info, KBPOS *kbpos, const char *fname )
444 {
445     int rc;
446     PACKET pkt;
447     int save_mode;
448     ulong offset;
449     IOBUF iobuf;
450
451     init_packet(&pkt);
452     save_mode = set_packet_list_mode(0);
453
454   #if 0
455     if( iobuf_seek( iobuf, 0 ) ) {
456         log_error("can't rewind keyring file: %s\n", g10_errstr(rc));
457         rc = G10ERR_KEYRING_OPEN;
458         goto leave;
459     }
460   #else
461     iobuf = iobuf_open( fname );
462     if( !iobuf ) {
463         log_error("can't open '%s'\n", fname );
464         rc = G10ERR_OPEN_FILE;
465         goto leave;
466     }
467   #endif
468
469     while( !(rc=search_packet(iobuf, &pkt, PKT_PUBLIC_CERT, &offset)) ) {
470         PKT_public_cert *pkc = pkt.pkt.public_cert;
471         u32 keyid[2];
472
473         assert( pkt.pkttype == PKT_PUBLIC_CERT );
474         keyid_from_pkc( pkc, keyid );
475         if( keyid[0] == info->keyid[0] && keyid[1] == info->keyid[1]
476             && pkc->pubkey_algo == info->pubkey_algo ) {
477             /* fixme: shall we check nbits too? (good for rsa keys) */
478             /* fixme: check userid???? */
479             size_t len;
480             byte *fp = fingerprint_from_pkc( pkc, &len );
481
482             if( !memcmp( fp, info->fingerprint, len ) ) {
483                 m_free(fp);
484                 break; /* found */
485             }
486             m_free(fp);
487         }
488         free_packet(&pkt);
489     }
490     if( !rc )
491         kbpos->offset = offset;
492
493   leave:
494     iobuf_close(iobuf);
495     free_packet(&pkt);
496     set_packet_list_mode(save_mode);
497     return rc;
498 }
499
500
501 static int
502 keyring_read( KBPOS *kbpos, KBNODE *ret_root )
503 {
504     PACKET *pkt;
505     int rc;
506     RESTBL *rentry;
507     KBNODE root = NULL;
508     KBNODE node, n1, n2;
509     IOBUF a;
510     u32 offset, last_offset;
511
512     if( !(rentry=check_pos(kbpos)) )
513         return G10ERR_GENERAL;
514
515     a = iobuf_open( rentry->fname );
516     if( !a ) {
517         log_error("can't open '%s'\n", rentry->fname );
518         return G10ERR_OPEN_FILE;
519     }
520
521     if( iobuf_seek( a, kbpos->offset ) ) {
522         log_error("can't seek to %lu: %s\n", kbpos->offset, g10_errstr(rc));
523         iobuf_close(a);
524         return G10ERR_KEYRING_OPEN;
525     }
526
527     pkt = m_alloc( sizeof *pkt );
528     init_packet(pkt);
529     while( (rc=parse_packet(a, pkt)) != -1 ) {
530         if( rc ) {  /* ignore errors */
531             free_packet( pkt );
532             continue;
533         }
534         if( root && ( pkt->pkttype == PKT_PUBLIC_CERT
535                       || pkt->pkttype == PKT_SECRET_CERT ) )
536             goto ready;
537         offset = iobuf_tell(a);
538         switch( pkt->pkttype ) {
539           case PKT_PUBLIC_CERT:
540           case PKT_SECRET_CERT:
541             root = new_kbnode( pkt );
542             pkt = m_alloc( sizeof *pkt );
543             init_packet(pkt);
544             break;
545
546           case PKT_USER_ID:
547             if( !root ) {
548                 log_error("read_keyblock: orphaned user id\n" );
549                 rc = G10ERR_INV_KEYRING; /* or wrong kbpos */
550                 goto ready;
551             }
552             offset = last_offset;
553             /* append the user id */
554             node = new_kbnode( pkt );
555             if( !(n1=root->child) )
556                 root->child = node;
557             else {
558                 for( ; n1->next; n1 = n1->next)
559                     ;
560                 n1->next = node;
561             }
562             pkt = m_alloc( sizeof *pkt );
563             init_packet(pkt);
564             break;
565
566           case PKT_SIGNATURE:
567             if( !root ) {
568                 log_error("read_keyblock: no root for signature\n" );
569                 rc = G10ERR_INV_KEYRING; /* or wrong kbpos */
570                 break;
571             }
572             if( !root->child ) {
573                 log_error("read_keyblock: no userid for signature\n" );
574                 rc = G10ERR_INV_KEYRING;
575                 break;
576             }
577             /* goto the last user id */
578             for(n1=root->child; n1->next; n1 = n1->next )
579                 ;
580             /* append the signature node */
581             node = new_kbnode( pkt );
582             if( !(n2=n1->child) )
583                 n1->child = node;
584             else {
585                 for( ; n2->next; n2 = n2->next)
586                     ;
587                 n2->next = node;
588             }
589             pkt = m_alloc( sizeof *pkt );
590             init_packet(pkt);
591             break;
592
593           default: /* ignore all other packets. FIXME: we should not do this */
594             free_packet( pkt );
595             break;
596         }
597     }
598   ready:
599     kbpos->last_block = rc == -1; /* flag, that this is the last block */
600     if( rc == -1 && root )
601         rc = 0;
602
603     if( rc )
604         release_kbnode( root );
605     else {
606         *ret_root = root;
607         kbpos->length = offset - kbpos->offset;
608     }
609     free_packet( pkt );
610     m_free( pkt );
611     iobuf_close(a);
612     return rc;
613 }
614
615
616 /****************
617  * Insert the keyblock described by ROOT into the keyring described
618  * by KBPOS.  This actually appends the data to the keyfile.
619  */
620 static int
621 keyring_insert( KBPOS *kbpos, KBNODE root )
622 {
623     RESTBL *rentry;
624     IOBUF fp;
625     KBNODE kbctx, node;
626     int rc;
627
628     if( !(rentry = check_pos( kbpos )) )
629         return G10ERR_GENERAL;
630
631     /* FIXME: we must close the file if it's already open, due to
632      *        2 reasons:
633      *         - cannot open the same file twice on DOSish OSes
634      *         - must sync with iobufs somehow
635      */
636     /* open the file for append */
637     fp = iobuf_append( rentry->fname );
638     if( !fp ) {
639         log_error("can't append to '%s'\n", rentry->fname );
640         return G10ERR_OPEN_FILE;
641     }
642
643     kbctx=NULL;
644     while( (node = walk_kbtree( root, &kbctx )) ) {
645         if( (rc = build_packet( fp, node->pkt )) ) {
646             log_error("build_packet(%d) failed: %s\n",
647                         node->pkt->pkttype, g10_errstr(rc) );
648             return G10ERR_WRITE_FILE;
649         }
650     }
651     iobuf_close(fp);
652
653     return 0;
654 }
655
656 static int
657 keyring_delete( KBPOS *kbpos )
658 {
659     RESTBL *rentry;
660     IOBUF fp;
661     int rc;
662     u32 len;
663     int ctb;
664
665     if( !(rentry = check_pos( kbpos )) )
666         return G10ERR_GENERAL;
667
668
669     /* open the file for read/write */
670     fp = iobuf_openrw( rentry->fname );
671     if( !fp ) {
672         log_error("can't open '%s' for writing\n", rentry->fname );
673         return G10ERR_OPEN_FILE;
674     }
675
676     if( iobuf_seek( fp, kbpos->offset ) ) {
677         log_error("can't seek to %lu: %s\n", kbpos->offset, g10_errstr(rc));
678         iobuf_close(fp);
679         return G10ERR_WRITE_FILE;
680     }
681
682     len = kbpos->length;
683     assert( len < 100000 ); /* there is a bug somewhere */
684     /*log_debug("writing a dummy packet of length %lu\n", (ulong)len);*/
685
686     if( len < 2 )
687         BUG();
688
689     if( len < 256 ) {
690         ctb = 0x80;
691         len -= 2;
692     }
693     else if( len < 65536 ) {
694         ctb = 0x81;
695         len -= 3;
696     }
697     else {
698         ctb = 0x82;
699         len -= 5;
700     }
701     iobuf_put(fp, ctb );
702     if( ctb & 2 ) {
703         iobuf_put(fp, len >> 24 );
704         iobuf_put(fp, len >> 16 );
705     }
706     if( ctb & 3 )
707         iobuf_put(fp, len >> 8 );
708     if( iobuf_put(fp, len ) ) {
709         iobuf_close(fp);
710         return G10ERR_WRITE_FILE;
711     }
712     for( ; len; len-- )
713         if( iobuf_put(fp, 0xff ) ) {
714             iobuf_close(fp);
715             return G10ERR_WRITE_FILE;
716         }
717
718     iobuf_close(fp);
719
720     return 0;
721 }
722
723
724 /****************************************************************
725  ********** Functions which operates on databases ***************
726  ****************************************************************/
727