very first release
[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     char *fname;
62     IOBUF iobuf;
63 };
64 typedef struct resource_table_struct RESTBL;
65
66 #define MAX_RESOURCES 10
67 static RESTBL resource_table[MAX_RESOURCES];
68
69
70 static int keyring_search( PACKET *pkt, KBPOS *kbpos, IOBUF iobuf );
71 static int keyring_read( KBPOS *kbpos, KBNODE *ret_root );
72 static int keyring_insert( KBPOS *kbpos, KBNODE root );
73 static int keyring_delete( KBPOS *kbpos );
74
75
76
77 static RESTBL *
78 check_pos( KBPOS *kbpos )
79 {
80     if( kbpos->resno < 0 || kbpos->resno >= MAX_RESOURCES )
81         return NULL;
82     if( !resource_table[kbpos->resno].used )
83         return NULL;
84     return resource_table + kbpos->resno;
85 }
86
87
88
89 /****************************************************************
90  ****************** public functions ****************************
91  ****************************************************************/
92
93 /****************
94  * Register a resource (which currently may ionly be a keyring file).
95  */
96 int
97 add_keyblock_resource( const char *filename, int force )
98 {
99     IOBUF iobuf;
100     int i;
101
102     for(i=0; i < MAX_RESOURCES; i++ )
103         if( !resource_table[i].used )
104             break;
105     if( i == MAX_RESOURCES )
106         return G10ERR_RESOURCE_LIMIT;
107
108     iobuf = iobuf_open( filename );
109     if( !iobuf && !force )
110         return G10ERR_OPEN_FILE;
111     resource_table[i].used = 1;
112     resource_table[i].fname = m_strdup(filename);
113     resource_table[i].iobuf = iobuf;
114     return 0;
115 }
116
117
118 /****************
119  * Get a keyblock handle KBPOS from a filename. This can be used
120  * to get a handle for insert_keyblock for a new keyblock.
121  */
122 int
123 get_keyblock_handle( const char *filename, KBPOS *kbpos )
124 {
125     int i;
126
127     for(i=0; i < MAX_RESOURCES; i++ )
128         if( resource_table[i].used ) {
129             /* fixme: dos needs case insensitive file compare */
130             if( !strcmp( resource_table[i].fname, filename ) ) {
131                 memset( kbpos, 0, sizeof *kbpos );
132                 kbpos->resno = i;
133                 return 0;
134             }
135         }
136     return -1; /* not found */
137 }
138
139 /****************
140  * Search a keyblock which starts with the given packet and put all
141  * informations into KBPOS, which can be used later to access this key block.
142  * This function looks into all registered keyblock sources.
143  * PACKET must be a packet with either a secret_cert or a public_cert
144  *
145  * This function is intended to check wether a given certificate
146  * is already in a keyring or to prepare it for editing.
147  *
148  * Returns: 0 if found, -1 if not found or an errorcode.
149  */
150 int
151 search_keyblock( PACKET *pkt, KBPOS *kbpos )
152 {
153     int i, rc, last_rc=-1;
154
155     for(i=0; i < MAX_RESOURCES; i++ ) {
156         if( resource_table[i].used ) {
157             /* note: here we have to add different search functions,
158              * depending on the type of the resource */
159             rc = keyring_search( pkt, kbpos, resource_table[i].iobuf );
160             if( !rc ) {
161                 kbpos->resno = i;
162                 return 0;
163             }
164             if( rc != -1 ) {
165                 log_error("error searching resource %d: %s\n",
166                                                   i, g10_errstr(rc));
167                 last_rc = rc;
168             }
169         }
170     }
171     return last_rc;
172 }
173
174
175 /****************
176  * Combined function to search for a username and get the position
177  * of the keyblock.
178  */
179 int
180 search_keyblock_byname( KBPOS *kbpos, const char *username )
181 {
182     PACKET pkt;
183     PKT_public_cert *pkc = m_alloc_clear( sizeof *pkc );
184     int rc;
185
186     rc = get_pubkey_byname( pkc, username );
187     if( rc ) {
188         free_public_cert(pkc);
189         return rc;
190     }
191
192     init_packet( &pkt );
193     pkt.pkttype = PKT_PUBLIC_CERT;
194     pkt.pkt.public_cert = pkc;
195     rc = search_keyblock( &pkt, kbpos );
196     free_public_cert(pkc);
197     return rc;
198 }
199
200
201 /****************
202  * Lock the keyblock; wait until it's available
203  * This function may change the internal data in kbpos, in cases
204  * when the to be locked keyblock has been modified.
205  * fixme: remove this function and add an option to search_keyblock()?
206  */
207 int
208 lock_keyblock( KBPOS *kbpos )
209 {
210     int rc;
211
212     if( !check_pos(kbpos) )
213         return G10ERR_GENERAL;
214     return 0;
215 }
216
217 /****************
218  * Release a lock on a keyblock
219  */
220 void
221 unlock_keyblock( KBPOS *kbpos )
222 {
223     if( !check_pos(kbpos) )
224         log_bug(NULL);
225 }
226
227 /****************
228  * Read a complete keyblock and return the root in ret_root.
229  */
230 int
231 read_keyblock( KBPOS *kbpos, KBNODE *ret_root )
232 {
233     if( !check_pos(kbpos) )
234         return G10ERR_GENERAL;
235     return keyring_read( kbpos, ret_root );
236 }
237
238 /****************
239  * Insert the keyblock described by ROOT into the keyring described
240  * by KBPOS.  This actually appends the data to the keyfile.
241  */
242 int
243 insert_keyblock( KBPOS *kbpos, KBNODE root )
244 {
245     int rc;
246
247     if( !check_pos(kbpos) )
248         return G10ERR_GENERAL;
249
250     rc = keyring_insert( kbpos, root );
251
252     return rc;
253 }
254
255 /****************
256  * Delete the keyblock described by KBPOS.
257  * The current code simply changes the keyblock in the keyring
258  * to packet of type 0 with the correct length.  To help detecting errors,
259  * zero bytes are written.
260  */
261 int
262 delete_keyblock( KBPOS *kbpos )
263 {
264     int rc;
265
266     if( !check_pos(kbpos) )
267         return G10ERR_GENERAL;
268
269     rc = keyring_delete( kbpos );
270
271     return rc;
272 }
273
274
275 /****************
276  * Update the keyblock at KBPOS with the one in ROOT.
277  */
278 int
279 update_keyblock( KBPOS *kbpos, KBNODE root )
280 {
281     int rc;
282     KBPOS kbpos2;
283
284     /* we do it the simple way: */
285     memset( &kbpos2, 0, sizeof kbpos2 );
286     kbpos2.resno = kbpos->resno;
287     rc = insert_keyblock( &kbpos2, root );
288     if( !rc )
289         rc = delete_keyblock( kbpos );
290
291     return rc;
292 }
293
294
295 /****************************************************************
296  ********** Functions which operates on regular keyrings ********
297  ****************************************************************/
298
299
300 /****************
301  * search one keyring, return 0 if found, -1 if not found or an errorcode.
302  */
303 static int
304 keyring_search( PACKET *req, KBPOS *kbpos, IOBUF iobuf )
305 {
306     int rc;
307     PACKET pkt;
308     int save_mode;
309     ulong offset;
310     int pkttype = req->pkttype;
311     PKT_public_cert *req_pkc = req->pkt.public_cert;
312     PKT_secret_cert *req_skc = req->pkt.secret_cert;
313
314     init_packet(&pkt);
315     save_mode = set_packet_list_mode(0);
316
317     if( iobuf_seek( iobuf, 0 ) ) {
318         log_error("can't rewind keyring file: %s\n", g10_errstr(rc));
319         rc = G10ERR_KEYRING_OPEN;
320         goto leave;
321     }
322
323     while( !(rc=search_packet(iobuf, &pkt, pkttype, &offset)) ) {
324         if( pkt.pkttype == PKT_SECRET_CERT ) {
325             PKT_secret_cert *skc = pkt.pkt.secret_cert;
326
327             if(   req_skc->timestamp == skc->timestamp
328                && req_skc->valid_days == skc->valid_days
329                && req_skc->pubkey_algo == skc->pubkey_algo
330                && (   ( skc->pubkey_algo == PUBKEY_ALGO_ELGAMAL
331                         && !mpi_cmp( req_skc->d.elg.p, skc->d.elg.p )
332                         && !mpi_cmp( req_skc->d.elg.g, skc->d.elg.g )
333                         && !mpi_cmp( req_skc->d.elg.y, skc->d.elg.y )
334                         && !mpi_cmp( req_skc->d.elg.x, skc->d.elg.x )
335                       )
336                    || ( skc->pubkey_algo == PUBKEY_ALGO_RSA
337                         && !mpi_cmp( req_skc->d.rsa.rsa_n, skc->d.rsa.rsa_n )
338                         && !mpi_cmp( req_skc->d.rsa.rsa_e, skc->d.rsa.rsa_e )
339                         && !mpi_cmp( req_skc->d.rsa.rsa_d, skc->d.rsa.rsa_d )
340                       )
341                   )
342               )
343                 break; /* found */
344         }
345         else if( pkt.pkttype == PKT_PUBLIC_CERT ) {
346             PKT_public_cert *pkc = pkt.pkt.public_cert;
347
348             if(   req_pkc->timestamp == pkc->timestamp
349                && req_pkc->valid_days == pkc->valid_days
350                && req_pkc->pubkey_algo == pkc->pubkey_algo
351                && (   ( pkc->pubkey_algo == PUBKEY_ALGO_ELGAMAL
352                         && !mpi_cmp( req_pkc->d.elg.p, pkc->d.elg.p )
353                         && !mpi_cmp( req_pkc->d.elg.g, pkc->d.elg.g )
354                         && !mpi_cmp( req_pkc->d.elg.y, pkc->d.elg.y )
355                       )
356                    || ( pkc->pubkey_algo == PUBKEY_ALGO_RSA
357                         && !mpi_cmp( req_pkc->d.rsa.rsa_n, pkc->d.rsa.rsa_n )
358                         && !mpi_cmp( req_pkc->d.rsa.rsa_e, pkc->d.rsa.rsa_e )
359                       )
360                   )
361               )
362                 break; /* found */
363         }
364         else
365             log_bug(NULL);
366         free_packet(&pkt);
367     }
368     if( !rc )
369         kbpos->offset = offset;
370
371   leave:
372     free_packet(&pkt);
373     set_packet_list_mode(save_mode);
374     return rc;
375 }
376
377
378 static int
379 keyring_read( KBPOS *kbpos, KBNODE *ret_root )
380 {
381     PACKET *pkt;
382     int rc;
383     RESTBL *rentry;
384     KBNODE root = NULL;
385     KBNODE node, n1, n2;
386     IOBUF a;
387     u32 offset, last_offset;
388
389     if( !(rentry=check_pos(kbpos)) )
390         return G10ERR_GENERAL;
391
392     a = iobuf_open( rentry->fname );
393     if( !a ) {
394         log_error("can't open '%s'\n", rentry->fname );
395         return G10ERR_OPEN_FILE;
396     }
397
398     if( iobuf_seek( a, kbpos->offset ) ) {
399         log_error("can't seek to %lu: %s\n", kbpos->offset, g10_errstr(rc));
400         iobuf_close(a);
401         return G10ERR_KEYRING_OPEN;
402     }
403
404     pkt = m_alloc( sizeof *pkt );
405     init_packet(pkt);
406     while( (rc=parse_packet(a, pkt)) != -1 ) {
407         if( rc ) {  /* ignore errors */
408             free_packet( pkt );
409             continue;
410         }
411         if( root && ( pkt->pkttype == PKT_PUBLIC_CERT
412                       || pkt->pkttype == PKT_SECRET_CERT ) )
413             goto ready;
414         offset = iobuf_tell(a);
415         switch( pkt->pkttype ) {
416           case PKT_PUBLIC_CERT:
417           case PKT_SECRET_CERT:
418             root = new_kbnode( pkt );
419             pkt = m_alloc( sizeof *pkt );
420             init_packet(pkt);
421             break;
422
423           case PKT_USER_ID:
424             if( !root ) {
425                 log_error("read_keyblock: orphaned user id\n" );
426                 rc = G10ERR_INV_KEYRING; /* or wrong kbpos */
427                 goto ready;
428             }
429             offset = last_offset;
430             /* append the user id */
431             node = new_kbnode( pkt );
432             if( !(n1=root->child) )
433                 root->child = node;
434             else {
435                 for( ; n1->next; n1 = n1->next)
436                     ;
437                 n1->next = node;
438             }
439             pkt = m_alloc( sizeof *pkt );
440             init_packet(pkt);
441             break;
442
443           case PKT_SIGNATURE:
444             if( !root ) {
445                 log_error("read_keyblock: no root for signature\n" );
446                 rc = G10ERR_INV_KEYRING; /* or wrong kbpos */
447                 break;
448             }
449             if( !root->child ) {
450                 log_error("read_keyblock: no userid for signature\n" );
451                 rc = G10ERR_INV_KEYRING;
452                 break;
453             }
454             /* goto the last user id */
455             for(n1=root->child; n1->next; n1 = n1->next )
456                 ;
457             /* append the signature node */
458             node = new_kbnode( pkt );
459             if( !(n2=n1->child) )
460                 n1->child = node;
461             else {
462                 for( ; n2->next; n2 = n2->next)
463                     ;
464                 n2->next = node;
465             }
466             pkt = m_alloc( sizeof *pkt );
467             init_packet(pkt);
468             break;
469
470           default: /* ignore all other packets. FIXME: we should not do this */
471             free_packet( pkt );
472             break;
473         }
474     }
475   ready:
476     kbpos->last_block = rc == -1; /* flag, that this is the last block */
477     if( rc == -1 && root )
478         rc = 0;
479
480     if( rc )
481         release_kbnode( root );
482     else {
483         *ret_root = root;
484         kbpos->length = offset - kbpos->offset;
485     }
486     free_packet( pkt );
487     m_free( pkt );
488     iobuf_close(a);
489     return rc;
490 }
491
492
493 /****************
494  * Insert the keyblock described by ROOT into the keyring described
495  * by KBPOS.  This actually appends the data to the keyfile.
496  */
497 static int
498 keyring_insert( KBPOS *kbpos, KBNODE root )
499 {
500     RESTBL *rentry;
501     IOBUF fp;
502     KBNODE kbctx, node;
503     int rc;
504
505     if( !(rentry = check_pos( kbpos )) )
506         return G10ERR_GENERAL;
507
508     /* FIXME: we must close the file if it's already open, due to
509      *        2 reasons:
510      *         - cannot open the same file twice on DOSish OSes
511      *         - must sync with iobufs somehow
512      */
513     /* open the file for append */
514     fp = iobuf_append( rentry->fname );
515     if( !fp ) {
516         log_error("can't append to '%s'\n", rentry->fname );
517         return G10ERR_OPEN_FILE;
518     }
519
520     kbctx=NULL;
521     while( (node = walk_kbtree( root, &kbctx )) ) {
522         if( (rc = build_packet( fp, node->pkt )) ) {
523             log_error("build_packet(%d) failed: %s\n",
524                         node->pkt->pkttype, g10_errstr(rc) );
525             return G10ERR_WRITE_FILE;
526         }
527     }
528     iobuf_close(fp);
529
530     return 0;
531 }
532
533 static int
534 keyring_delete( KBPOS *kbpos )
535 {
536     RESTBL *rentry;
537     IOBUF fp;
538     KBNODE kbctx, node;
539     int rc;
540     u32 len;
541     int ctb;
542
543     if( !(rentry = check_pos( kbpos )) )
544         return G10ERR_GENERAL;
545
546
547     /* open the file for read/write */
548     fp = iobuf_openrw( rentry->fname );
549     if( !fp ) {
550         log_error("can't open '%s' for writing\n", rentry->fname );
551         return G10ERR_OPEN_FILE;
552     }
553
554     if( iobuf_seek( fp, kbpos->offset ) ) {
555         log_error("can't seek to %lu: %s\n", kbpos->offset, g10_errstr(rc));
556         iobuf_close(fp);
557         return G10ERR_WRITE_FILE;
558     }
559
560     len = kbpos->length;
561     /*log_debug("writing a dummy packet of length %lu\n", (ulong)len);*/
562
563     if( len < 2 )
564         log_bug(NULL);
565
566     if( len < 256 ) {
567         ctb = 0x80;
568         len -= 2;
569     }
570     else if( len < 65536 ) {
571         ctb = 0x81;
572         len -= 3;
573     }
574     else {
575         ctb = 0x82;
576         len -= 5;
577     }
578     iobuf_put(fp, ctb );
579     if( ctb & 2 ) {
580         iobuf_put(fp, len >> 24 );
581         iobuf_put(fp, len >> 16 );
582     }
583     if( ctb & 3 )
584         iobuf_put(fp, len >> 8 );
585     if( iobuf_put(fp, len ) ) {
586         iobuf_close(fp);
587         return G10ERR_WRITE_FILE;
588     }
589     for( ; len; len-- )
590         if( iobuf_put(fp, 0xff ) ) {
591             iobuf_close(fp);
592             return G10ERR_WRITE_FILE;
593         }
594
595     iobuf_close(fp);
596
597     return 0;
598 }
599
600
601 /****************************************************************
602  ********** Functions which operates on databases ***************
603  ****************************************************************/
604