See ChangeLog ;-). Key validation should now be faster
[gnupg.git] / g10 / trustdb.c
1 /* trustdb.c
2  *      Copyright (C) 1998 Free Software Foundation, Inc.
3  *
4  * This file is part of GNUPG.
5  *
6  * GNUPG 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  * GNUPG 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 <ctype.h>
27 #include <assert.h>
28 #include <sys/types.h>
29 #include <sys/stat.h>
30 #include <fcntl.h>
31 #include <unistd.h>
32
33 #include "errors.h"
34 #include "iobuf.h"
35 #include "keydb.h"
36 #include "memory.h"
37 #include "util.h"
38 #include "trustdb.h"
39 #include "options.h"
40 #include "packet.h"
41 #include "main.h"
42 #include "i18n.h"
43 #include "tdbio.h"
44
45 #if MAX_FINGERPRINT_LEN > 20
46   #error Must change structure of trustdb
47 #endif
48
49 struct local_id_item {
50     struct local_id_item *next;
51     ulong lid;
52     unsigned flag;
53 };
54
55 struct local_id_table {
56     struct local_id_table *next; /* only used to keep a list of unused tables */
57     struct local_id_item *items[16];
58 };
59
60
61 typedef struct local_id_table *LOCAL_ID_TABLE;
62
63
64 typedef struct trust_info TRUST_INFO;
65 struct trust_info {
66     ulong    lid;
67     byte     otrust; /* ownertrust (assigned trust) */
68     byte     trust;  /* calculated trust (validity) */
69 };
70
71 typedef struct trust_seg_list *TRUST_SEG_LIST;
72 struct trust_seg_list {
73     TRUST_SEG_LIST next;
74     int  pathlen;
75     TRUST_INFO path[1];
76 };
77
78
79
80 struct recno_list_struct {
81     struct recno_list_struct *next;
82     ulong recno;
83     int type;
84 };
85 typedef struct recno_list_struct *RECNO_LIST;
86
87
88 static int walk_sigrecs( SIGREC_CONTEXT *c );
89
90 static LOCAL_ID_TABLE new_lid_table(void);
91 static void release_lid_table( LOCAL_ID_TABLE tbl );
92 static int ins_lid_table_item( LOCAL_ID_TABLE tbl, ulong lid, unsigned flag );
93 static int qry_lid_table_flag( LOCAL_ID_TABLE tbl, ulong lid, unsigned *flag );
94
95 static void print_user_id( const char *text, u32 *keyid );
96 static int list_sigs( ulong pubkey_id );
97 static int do_check( TRUSTREC *drec, unsigned *trustlevel );
98 static int get_dir_record( PKT_public_key *pk, TRUSTREC *rec );
99
100 static void upd_pref_record( TRUSTREC *urec, u32 *keyid, PKT_signature *sig );
101 static void upd_cert_record( KBNODE keyblock, KBNODE signode, u32 *keyid,
102                  TRUSTREC *drec, RECNO_LIST *recno_list, int recheck,
103                  TRUSTREC *urec, const byte *uidhash, int revoke );
104
105
106 /* a table used to keep track of ultimately trusted keys
107  * which are the ones from our secrings */
108 static LOCAL_ID_TABLE ultikey_table;
109
110 /* list of unused lid items and tables */
111 static LOCAL_ID_TABLE unused_lid_tables;
112 static struct local_id_item *unused_lid_items;
113
114
115 #define HEXTOBIN(a) ( (a) >= '0' && (a) <= '9' ? ((a)-'0') : \
116                       (a) >= 'A' && (a) <= 'F' ? ((a)-'A'+10) : ((a)-'a'+10))
117
118
119 \f
120 /**********************************************
121  ***********  record read write  **************
122  **********************************************/
123
124 static void
125 die_invalid_db()
126 {
127     log_error(_(
128         "The trust DB is corrupted; please run \"gpgm --fix-trust-db\".\n") );
129     g10_exit(2);
130 }
131
132 /****************
133  * Read a record but die if it does not exist
134  */
135 static void
136 read_record( ulong recno, TRUSTREC *rec, int rectype )
137 {
138     int rc = tdbio_read_record( recno, rec, rectype );
139     if( !rc )
140         return;
141     log_error(_("trust record %lu, req type %d: read failed: %s\n"),
142                                     recno, rectype,  g10_errstr(rc) );
143     die_invalid_db();
144 }
145
146
147 /****************
148  * Wirte a record but die on error
149  */
150 static void
151 write_record( TRUSTREC *rec )
152 {
153     int rc = tdbio_write_record( rec );
154     if( !rc )
155         return;
156     log_error(_("trust record %lu, type %d: write failed: %s\n"),
157                             rec->recnum, rec->rectype, g10_errstr(rc) );
158     die_invalid_db();
159 }
160
161 /****************
162  * Delete a record but die on error
163  */
164 static void
165 delete_record( ulong recno )
166 {
167     int rc = tdbio_delete_record( recno );
168     if( !rc )
169         return;
170     log_error(_("trust record %lu: delete failed: %s\n"),
171                                               recno, g10_errstr(rc) );
172     die_invalid_db();
173 }
174
175 /****************
176  * sync the db
177  */
178 static void
179 do_sync( )
180 {
181     int rc = tdbio_sync();
182     if( !rc )
183         return;
184     log_error(_("trust db: sync failed: %s\n"), g10_errstr(rc) );
185     g10_exit(2);
186 }
187
188
189 \f
190 /**********************************************
191  ************* list helpers *******************
192  **********************************************/
193
194 /****************
195  * Insert a new item into a recno list
196  */
197 static void
198 ins_recno_list( RECNO_LIST *head, ulong recno, int type )
199 {
200     RECNO_LIST item = m_alloc( sizeof *item );
201
202     item->recno = recno;
203     item->type = type;
204     item->next = *head;
205     *head = item;
206 }
207
208 static RECNO_LIST
209 qry_recno_list( RECNO_LIST list, ulong recno, int type  )
210 {
211     for( ; list; list = list->next ) {
212         if( list->recno == recno && (!type || list->type == type) )
213             return list;
214     }
215     return NULL;
216 }
217
218
219 static void
220 rel_recno_list( RECNO_LIST *head )
221 {
222     RECNO_LIST r, r2;
223
224     for(r = *head; r; r = r2 ) {
225         r2 = r->next;
226         m_free(r);
227     }
228     *head = NULL;
229 }
230
231 static LOCAL_ID_TABLE
232 new_lid_table(void)
233 {
234     LOCAL_ID_TABLE a;
235
236     a = unused_lid_tables;
237     if( a ) {
238         unused_lid_tables = a->next;
239         memset( a, 0, sizeof *a );
240     }
241     else
242         a = m_alloc_clear( sizeof *a );
243     return a;
244 }
245
246 static void
247 release_lid_table( LOCAL_ID_TABLE tbl )
248 {
249     struct local_id_item *a, *a2;
250     int i;
251
252     for(i=0; i < 16; i++ ) {
253         for(a=tbl->items[i]; a; a = a2 ) {
254             a2 = a->next;
255             a->next = unused_lid_items;
256             unused_lid_items = a;
257         }
258     }
259     tbl->next = unused_lid_tables;
260     unused_lid_tables = tbl;
261 }
262
263 /****************
264  * Add a new item to the table or return 1 if we already have this item
265  */
266 static int
267 ins_lid_table_item( LOCAL_ID_TABLE tbl, ulong lid, unsigned flag )
268 {
269     struct local_id_item *a;
270
271     for( a = tbl->items[lid & 0x0f]; a; a = a->next )
272         if( a->lid == lid )
273             return 1;
274     a = unused_lid_items;
275     if( a )
276         unused_lid_items = a->next;
277     else
278         a = m_alloc( sizeof *a );
279     a->lid = lid;
280     a->flag = flag;
281     a->next = tbl->items[lid & 0x0f];
282     tbl->items[lid & 0x0f] = a;
283     return 0;
284 }
285
286 static int
287 qry_lid_table_flag( LOCAL_ID_TABLE tbl, ulong lid, unsigned *flag )
288 {
289     struct local_id_item *a;
290
291     for( a = tbl->items[lid & 0x0f]; a; a = a->next )
292         if( a->lid == lid ) {
293             if( flag )
294                 *flag = a->flag;
295             return 0;
296         }
297     return -1;
298 }
299
300
301
302 /****************
303  * Return the keyid from the primary key identified by LID.
304  */
305 int
306 keyid_from_lid( ulong lid, u32 *keyid )
307 {
308     TRUSTREC rec;
309     int rc;
310
311     rc = tdbio_read_record( lid, &rec, 0 );
312     if( rc ) {
313         log_error(_("error reading dir record for LID %lu: %s\n"),
314                                                     lid, g10_errstr(rc));
315         return G10ERR_TRUSTDB;
316     }
317     if( rec.rectype == RECTYPE_SDIR )
318         return 0;
319     if( rec.rectype != RECTYPE_DIR ) {
320         log_error(_("lid %lu: expected dir record, got type %d\n"),
321                                                     lid, rec.rectype );
322         return G10ERR_TRUSTDB;
323     }
324     if( !rec.r.dir.keylist ) {
325         log_error(_("no primary key for LID %lu\n"), lid );
326         return G10ERR_TRUSTDB;
327     }
328     rc = tdbio_read_record( rec.r.dir.keylist, &rec, RECTYPE_KEY );
329     if( rc ) {
330         log_error(_("error reading primary key for LID %lu: %s\n"),
331                                                     lid, g10_errstr(rc));
332         return G10ERR_TRUSTDB;
333     }
334     keyid_from_fingerprint( rec.r.key.fingerprint, rec.r.key.fingerprint_len,
335                             keyid );
336
337     return 0;
338 }
339
340
341 ulong
342 lid_from_keyblock( KBNODE keyblock )
343 {
344     KBNODE node = find_kbnode( keyblock, PKT_PUBLIC_KEY );
345     PKT_public_key *pk;
346     if( !node )
347         BUG();
348     pk = node->pkt->pkt.public_key;
349     if( !pk->local_id ) {
350         TRUSTREC rec;
351
352         get_dir_record( pk, &rec );
353     }
354     return pk->local_id;
355 }
356
357
358 \f
359 /****************
360  * Walk through the signatures of a public key.
361  * The caller must provide a context structure, with all fields set
362  * to zero, but the local_id field set to the requested key;
363  * This function does not change this field.  On return the context
364  * is filled with the local-id of the signature and the signature flag.
365  * No fields should be changed (clearing all fields and setting
366  * pubkeyid is okay to continue with an other pubkey)
367  * Returns: 0 - okay, -1 for eof (no more sigs) or any other errorcode
368  */
369 static int
370 walk_sigrecs( SIGREC_CONTEXT *c )
371 {
372     TRUSTREC *r;
373     ulong rnum;
374
375     if( c->ctl.eof )
376         return -1;
377     r = &c->ctl.rec;
378     if( !c->ctl.init_done ) {
379         c->ctl.init_done = 1;
380         read_record( c->lid, r, 0 );
381         if( r->rectype != RECTYPE_DIR ) {
382             c->ctl.eof = 1;
383             return -1;  /* return eof */
384         }
385         c->ctl.nextuid = r->r.dir.uidlist;
386         /* force a read */
387         c->ctl.index = SIGS_PER_RECORD;
388         r->r.sig.next = 0;
389     }
390
391     /* need a loop to skip over deleted sigs */
392     do {
393         if( c->ctl.index >= SIGS_PER_RECORD ) { /* read the record */
394             rnum = r->r.sig.next;
395             if( !rnum && c->ctl.nextuid ) { /* read next uid record */
396                 read_record( c->ctl.nextuid, r, RECTYPE_UID );
397                 c->ctl.nextuid = r->r.uid.next;
398                 rnum = r->r.uid.siglist;
399             }
400             if( !rnum ) {
401                 c->ctl.eof = 1;
402                 return -1;  /* return eof */
403             }
404             read_record( rnum, r, RECTYPE_SIG );
405             if( r->r.sig.lid != c->lid ) {
406                 log_error(_("chained sigrec %lu has a wrong owner\n"), rnum );
407                 c->ctl.eof = 1;
408                 die_invalid_db();
409             }
410             c->ctl.index = 0;
411         }
412     } while( !r->r.sig.sig[c->ctl.index++].lid );
413
414     c->sig_lid = r->r.sig.sig[c->ctl.index-1].lid;
415     c->sig_flag = r->r.sig.sig[c->ctl.index-1].flag;
416     return 0;
417 }
418
419
420
421 \f
422 /***********************************************
423  *************  Trust  stuff  ******************
424  ***********************************************/
425
426
427 /****************
428  * Verify that all our public keys are in the trustDB.
429  */
430 static int
431 verify_own_keys()
432 {
433     int rc;
434     void *enum_context = NULL;
435     PKT_secret_key *sk = m_alloc_clear( sizeof *sk );
436     PKT_public_key *pk = m_alloc_clear( sizeof *pk );
437     u32 keyid[2];
438
439     while( !(rc=enum_secret_keys( &enum_context, sk, 0 ) ) ) {
440         keyid_from_sk( sk, keyid );
441
442         if( DBG_TRUST )
443             log_debug("key %08lX: checking secret key\n", (ulong)keyid[1] );
444
445         if( is_secret_key_protected( sk ) < 1 )
446             log_info(_("NOTE: secret key %08lX is NOT protected.\n"),
447                                                             (ulong)keyid[1] );
448
449         /* see whether we can access the public key of this secret key */
450         memset( pk, 0, sizeof *pk );
451         rc = get_pubkey( pk, keyid );
452         if( rc ) {
453             log_info(_("key %08lX: secret key without public key - skipped\n"),
454                                                             (ulong)keyid[1] );
455             goto skip;
456         }
457
458         if( cmp_public_secret_key( pk, sk ) ) {
459             log_info(_("key %08lX: secret and public key don't match\n"),
460                                                             (ulong)keyid[1] );
461             goto skip;
462         }
463
464         /* make sure that the pubkey is in the trustdb */
465         rc = query_trust_record( pk );
466         if( rc == -1 ) { /* put it into the trustdb */
467             rc = insert_trust_record( pk );
468             if( rc ) {
469                 log_error(_("key %08lX: can't put it into the trustdb\n"),
470                                                             (ulong)keyid[1] );
471                 goto skip;
472             }
473         }
474         else if( rc ) {
475             log_error(_("key %08lX: query record failed\n"), (ulong)keyid[1] );
476             goto skip;
477
478         }
479
480         if( DBG_TRUST )
481             log_debug("key %08lX.%lu: stored into ultikey_table\n",
482                                     (ulong)keyid[1], pk->local_id );
483         if( ins_lid_table_item( ultikey_table, pk->local_id, 0 ) )
484             log_error(_("key %08lX: already in secret key table\n"),
485                                                         (ulong)keyid[1]);
486         else if( opt.verbose > 1 )
487             log_info(_("key %08lX: accepted as secret key.\n"),
488                                                         (ulong)keyid[1]);
489       skip:
490         release_secret_key_parts( sk );
491         release_public_key_parts( pk );
492     }
493     if( rc != -1 )
494         log_error(_("enumerate secret keys failed: %s\n"), g10_errstr(rc) );
495     else
496         rc = 0;
497
498     enum_secret_keys( &enum_context, NULL, 0 ); /* free context */
499     free_secret_key( sk );
500     free_public_key( pk );
501     return rc;
502 }
503
504
505 static void
506 print_user_id( const char *text, u32 *keyid )
507 {
508     char *p;
509     size_t n;
510
511     p = get_user_id( keyid, &n );
512     if( *text ) {
513         fputs( text, stdout);
514         putchar(' ');
515     }
516     putchar('\"');
517     print_string( stdout, p, n, 0 );
518     putchar('\"');
519     putchar('\n');
520     m_free(p);
521 }
522
523 #if 0
524 static int
525 print_keyid( FILE *fp, ulong lid )
526 {
527     u32 ki[2];
528     if( keyid_from_lid( lid, ki ) )
529         return fprintf(fp, "????????.%lu", lid );
530     else
531         return fprintf(fp, "%08lX.%lu", (ulong)ki[1], lid );
532 }
533
534 static int
535 print_trust( FILE *fp, unsigned trust )
536 {
537     int c;
538     switch( trust ) {
539       case TRUST_UNKNOWN:   c = 'o'; break;
540       case TRUST_EXPIRED:   c = 'e'; break;
541       case TRUST_UNDEFINED: c = 'q'; break;
542       case TRUST_NEVER:     c = 'n'; break;
543       case TRUST_MARGINAL:  c = 'm'; break;
544       case TRUST_FULLY:     c = 'f'; break;
545       case TRUST_ULTIMATE:  c = 'u'; break;
546       default: fprintf(fp, "%02x", trust ); return 2;
547     }
548     putc(c, fp);
549     return 1;
550 }
551 #endif
552
553 static int
554 print_sigflags( FILE *fp, unsigned flags )
555 {
556     if( flags & SIGF_CHECKED ) {
557         fprintf(fp,"%c%c%c",
558            (flags & SIGF_VALID)   ? 'V':'-',
559            (flags & SIGF_EXPIRED) ? 'E':'-',
560            (flags & SIGF_REVOKED) ? 'R':'-');
561     }
562     else if( flags & SIGF_NOPUBKEY)
563         fputs("?--", fp);
564     else
565         fputs("---", fp);
566     return 3;
567 }
568
569 /* (a non-recursive algorithm would be easier) */
570 static int
571 do_list_sigs( ulong root, ulong pk_lid, int depth,
572               LOCAL_ID_TABLE lids, unsigned *lineno )
573 {
574     SIGREC_CONTEXT sx;
575     int rc;
576     u32 keyid[2];
577
578     memset( &sx, 0, sizeof sx );
579     sx.lid = pk_lid;
580     for(;;) {
581         rc = walk_sigrecs( &sx ); /* should we replace it and use */
582         if( rc )                  /* use a loop like in collect_paths ??*/
583             break;
584         rc = keyid_from_lid( sx.sig_lid, keyid );
585         if( rc ) {
586             printf("%6u: %*s????????.%lu:", *lineno, depth*4, "", sx.sig_lid );
587             print_sigflags( stdout, sx.sig_flag );
588             putchar('\n');
589             ++*lineno;
590         }
591         else {
592             printf("%6u: %*s%08lX.%lu:", *lineno, depth*4, "",
593                               (ulong)keyid[1], sx.sig_lid );
594             print_sigflags( stdout, sx.sig_flag );
595             putchar(' ');
596             /* check whether we already checked this pk_lid */
597             if( !qry_lid_table_flag( ultikey_table, sx.sig_lid, NULL ) ) {
598                 print_user_id("[ultimately trusted]", keyid);
599                 ++*lineno;
600             }
601             else if( sx.sig_lid == pk_lid ) {
602                 printf("[self-signature]\n");
603                 ++*lineno;
604             }
605             else if( sx.sig_lid == root ) {
606                 printf("[closed]\n");
607                 ++*lineno;
608             }
609             else if( ins_lid_table_item( lids, sx.sig_lid, *lineno ) ) {
610                 unsigned refline;
611                 qry_lid_table_flag( lids, sx.sig_lid, &refline );
612                 printf("[see line %u]\n", refline);
613                 ++*lineno;
614             }
615             else if( depth+1 >= MAX_LIST_SIGS_DEPTH  ) {
616                 print_user_id( "[too deeply nested]", keyid );
617                 ++*lineno;
618             }
619             else {
620                 print_user_id( "", keyid );
621                 ++*lineno;
622                 rc = do_list_sigs( root, sx.sig_lid, depth+1, lids, lineno );
623                 if( rc )
624                     break;
625             }
626         }
627     }
628     return rc==-1? 0 : rc;
629 }
630
631 /****************
632  * List all signatures of a public key
633  */
634 static int
635 list_sigs( ulong pubkey_id )
636 {
637     int rc;
638     u32 keyid[2];
639     LOCAL_ID_TABLE lids;
640     unsigned lineno = 1;
641
642     rc = keyid_from_lid( pubkey_id, keyid );
643     if( rc )
644         return rc;
645     printf("Signatures of %08lX.%lu ", (ulong)keyid[1], pubkey_id );
646     print_user_id("", keyid);
647     printf("----------------------\n");
648
649     lids = new_lid_table();
650     rc = do_list_sigs( pubkey_id, pubkey_id, 0, lids, &lineno );
651     putchar('\n');
652     release_lid_table(lids);
653     return rc;
654 }
655
656 /****************
657  * List all records of a public key
658  */
659 static int
660 list_records( ulong lid )
661 {
662     int rc;
663     TRUSTREC dr, ur, rec;
664     ulong recno;
665
666     rc = tdbio_read_record( lid, &dr, RECTYPE_DIR );
667     if( rc ) {
668         log_error(_("lid %lu: read dir record failed: %s\n"),
669                                                 lid, g10_errstr(rc));
670         return rc;
671     }
672     tdbio_dump_record( &dr, stdout );
673
674     for( recno=dr.r.dir.keylist; recno; recno = rec.r.key.next ) {
675         rc = tdbio_read_record( recno, &rec, 0 );
676         if( rc ) {
677             log_error(_("lid %lu: read key record failed: %s\n"),
678                                                 lid, g10_errstr(rc));
679             return rc;
680         }
681         tdbio_dump_record( &rec, stdout );
682     }
683
684     for( recno=dr.r.dir.uidlist; recno; recno = ur.r.uid.next ) {
685         rc = tdbio_read_record( recno, &ur, RECTYPE_UID );
686         if( rc ) {
687             log_error(_("lid %lu: read uid record failed: %s\n"),
688                                                 lid, g10_errstr(rc));
689             return rc;
690         }
691         tdbio_dump_record( &ur, stdout );
692         /* preference records */
693         for(recno=ur.r.uid.prefrec; recno; recno = rec.r.pref.next ) {
694             rc = tdbio_read_record( recno, &rec, RECTYPE_PREF );
695             if( rc ) {
696                 log_error(_("lid %lu: read pref record failed: %s\n"),
697                                                     lid, g10_errstr(rc));
698                 return rc;
699             }
700             tdbio_dump_record( &rec, stdout );
701         }
702         /* sig records */
703         for(recno=ur.r.uid.siglist; recno; recno = rec.r.sig.next ) {
704             rc = tdbio_read_record( recno, &rec, RECTYPE_SIG );
705             if( rc ) {
706                 log_error(_("lid %lu: read sig record failed: %s\n"),
707                                                     lid, g10_errstr(rc));
708                 return rc;
709             }
710             tdbio_dump_record( &rec, stdout );
711         }
712     }
713
714     /* add cache record dump here */
715
716
717
718     return rc;
719 }
720
721
722
723
724 /****************
725  * stack is an array of (max_path+1) elements. If trust_seg_head is not
726  * NULL it is a pointer to a variable which will receive a linked list
727  * of trust paths - The caller has to free the memory.
728  */
729 static int
730 collect_paths( int depth, int max_depth, int all, TRUSTREC *drec,
731                TRUST_INFO *stack, TRUST_SEG_LIST *trust_seg_head )
732 {
733     ulong rn, uidrn;
734     int marginal=0;
735     int fully=0;
736     LOCAL_ID_TABLE sigs_seen = NULL;
737
738     if( depth >= max_depth )  /* max cert_depth reached */
739         return TRUST_UNDEFINED;
740     {   int i;
741
742         for(i=0; i < depth; i++ )
743             if( stack[i].lid == drec->r.dir.lid )
744                 return TRUST_UNDEFINED; /* closed (we already visited this lid) */
745     }
746
747     stack[depth].lid = drec->r.dir.lid;
748     stack[depth].otrust = drec->r.dir.ownertrust;
749     stack[depth].trust = 0;
750     if( !qry_lid_table_flag( ultikey_table, drec->r.dir.lid, NULL ) ) {
751         /* we are at the end of a path */
752         TRUST_SEG_LIST tsl;
753         int i;
754
755         stack[depth].trust = TRUST_ULTIMATE;
756         if( trust_seg_head ) {
757             /* we can now put copy our current stack to the trust_seg_list */
758             tsl = m_alloc( sizeof *tsl + (depth+1)*sizeof( TRUST_INFO ) );
759             for(i=0; i <= depth; i++ )
760                 tsl->path[i] = stack[i];
761             tsl->pathlen = i;
762             tsl->next = *trust_seg_head;
763             *trust_seg_head = tsl;
764         }
765         return TRUST_ULTIMATE;
766     }
767
768     /* loop over all user-ids */
769     if( !all )
770         sigs_seen = new_lid_table();
771     for( rn = drec->r.dir.uidlist; rn; rn = uidrn ) {
772         TRUSTREC rec;  /* used for uids and sigs */
773         ulong sigrn;
774
775         read_record( rn, &rec, RECTYPE_UID );
776         uidrn = rec.r.uid.next;
777         if( !(rec.r.uid.uidflags & UIDF_CHECKED) )
778             continue; /* user id has not been checked */
779         if( !(rec.r.uid.uidflags & UIDF_VALID) )
780             continue; /* user id is not valid */
781         if( (rec.r.uid.uidflags & UIDF_REVOKED) )
782             continue; /* user id has been revoked */
783
784         /* loop over all signature records */
785         for( rn = rec.r.uid.siglist; rn; rn = sigrn ) {
786             int i;
787
788             read_record( rn, &rec, RECTYPE_SIG );
789             sigrn = rec.r.sig.next;
790
791             for(i=0; i < SIGS_PER_RECORD; i++ ) {
792                 TRUSTREC tmp;
793                 int ot, nt;
794
795                 if( !rec.r.sig.sig[i].lid )
796                     continue; /* skip deleted sigs */
797                 if( !(rec.r.sig.sig[i].flag & SIGF_CHECKED) )
798                     continue; /* skip unchecked signatures */
799                 if( !(rec.r.sig.sig[i].flag & SIGF_VALID) )
800                     continue; /* skip invalid signatures */
801                 if( (rec.r.sig.sig[i].flag & SIGF_EXPIRED) )
802                     continue; /* skip expired signatures */
803                 if( (rec.r.sig.sig[i].flag & SIGF_REVOKED) )
804                     continue; /* skip revoked signatures */
805
806                 /* visit every signer only once (a signer may have
807                  * signed more than one user ID) */
808                 if( sigs_seen && ins_lid_table_item( sigs_seen,
809                                                      rec.r.sig.sig[i].lid, 0) )
810                     continue; /* we already have this one */
811
812                 read_record( rec.r.sig.sig[i].lid, &tmp, 0 );
813                 if( tmp.rectype != RECTYPE_DIR ) {
814                     if( tmp.rectype != RECTYPE_SDIR )
815                         log_info("oops: lid %lu: sig %lu has rectype %d"
816                              " - skipped\n",
817                             drec->r.dir.lid, tmp.recnum, tmp.rectype );
818                     continue;
819                 }
820                 ot = tmp.r.dir.ownertrust & TRUST_MASK;
821                 if( ot >= TRUST_FULLY )
822                     ot = TRUST_FULLY;  /* just in case */
823                 nt = collect_paths( depth+1, max_depth, all, &tmp, stack,
824                                                         trust_seg_head );
825                 nt &= TRUST_MASK;
826
827                 if( nt < TRUST_MARGINAL ) {
828                     continue;
829                 }
830
831                 if( nt == TRUST_ULTIMATE ) {
832                     /* we have signed this key and only in this special case
833                      * we assume that this one is fully trusted */
834                     if( !all ) {
835                         if( sigs_seen )
836                             release_lid_table( sigs_seen );
837                         return (stack[depth].trust = TRUST_FULLY);
838                     }
839                 }
840
841                 if( nt >= TRUST_FULLY )
842                     fully++;
843                 if( nt >= TRUST_MARGINAL )
844                     marginal++;
845
846                 if( fully >= opt.completes_needed
847                     || marginal >= opt.marginals_needed ) {
848                     if( !all ) {
849                         if( sigs_seen )
850                             release_lid_table( sigs_seen );
851                         return (stack[depth].trust = TRUST_FULLY);
852                     }
853                 }
854             }
855         }
856     }
857     if( sigs_seen )
858         release_lid_table( sigs_seen );
859     if( all && ( fully >= opt.completes_needed
860                  || marginal >= opt.marginals_needed ) ) {
861         return (stack[depth].trust = TRUST_FULLY );
862     }
863     if( marginal ) {
864         return (stack[depth].trust = TRUST_MARGINAL);
865     }
866     return (stack[depth].trust=TRUST_UNDEFINED);
867 }
868
869
870 /****************
871  * Given the directory record of a key, check whether we can
872  * find a path to an ultimately trusted key.  We do this by
873  * checking all key signatures up to a some depth.
874  */
875 static int
876 verify_key( int max_depth, TRUSTREC *drec )
877 {
878     TRUST_INFO *tmppath = m_alloc_clear( (max_depth+1)* sizeof *tmppath );
879     int tr;
880
881     tr = collect_paths( 0, max_depth, 0, drec, tmppath, NULL );
882     m_free( tmppath );
883     return tr;
884 }
885
886
887
888
889 /****************
890  * we have the pubkey record and all needed informations are in the trustdb
891  * but nothing more is known.
892  */
893 static int
894 do_check( TRUSTREC *dr, unsigned *validity )
895 {
896     if( !dr->r.dir.keylist ) {
897         log_error(_("Ooops, no keys\n"));
898         return G10ERR_TRUSTDB;
899     }
900     if( !dr->r.dir.uidlist ) {
901         log_error(_("Ooops, no user ids\n"));
902         return G10ERR_TRUSTDB;
903     }
904
905     if( tdbio_db_matches_options()
906         && (dr->r.dir.dirflags & DIRF_VALVALID)
907         && dr->r.dir.validity )
908         *validity = dr->r.dir.validity;
909     else {
910         *validity = verify_key( opt.max_cert_depth, dr );
911         if( (*validity & TRUST_MASK) >= TRUST_UNDEFINED
912             && tdbio_db_matches_options() ) {
913             /* update the cached validity value */
914             dr->r.dir.validity = (*validity & TRUST_MASK);
915             dr->r.dir.dirflags |= DIRF_VALVALID;
916             write_record( dr );
917         }
918     }
919
920     if( dr->r.dir.dirflags & DIRF_REVOKED )
921         *validity |= TRUST_FLAG_REVOKED;
922
923     return 0;
924 }
925
926 \f
927 /****************
928  * Perform some checks over the trustdb
929  *  level 0: only open the db
930  *        1: used for initial program startup
931  */
932 int
933 init_trustdb( int level, const char *dbname )
934 {
935     int rc=0;
936
937     if( !ultikey_table )
938         ultikey_table = new_lid_table();
939
940     if( !level || level==1 ) {
941         rc = tdbio_set_dbname( dbname, !!level );
942         if( rc )
943             return rc;
944         if( !level )
945             return 0;
946
947         /* verify that our own keys are in the trustDB
948          * or move them to the trustdb. */
949         rc = verify_own_keys();
950
951         /* should we check whether there is no other ultimately trusted
952          * key in the database? */
953
954     }
955     else
956         BUG();
957
958     return rc;
959 }
960
961
962 void
963 list_trustdb( const char *username )
964 {
965     TRUSTREC rec;
966
967     if( username && *username == '#' ) {
968         int rc;
969         ulong lid = atoi(username+1);
970
971         if( (rc = list_records( lid)) )
972             log_error(_("user '%s' read problem: %s\n"),
973                                             username, g10_errstr(rc));
974         else if( (rc = list_sigs( lid )) )
975             log_error(_("user '%s' list problem: %s\n"),
976                                             username, g10_errstr(rc));
977     }
978     else if( username ) {
979         PKT_public_key *pk = m_alloc_clear( sizeof *pk );
980         int rc;
981
982         if( (rc = get_pubkey_byname( NULL, pk, username, NULL )) )
983             log_error(_("user '%s' not found: %s\n"), username, g10_errstr(rc) );
984         else if( (rc=tdbio_search_dir_bypk( pk, &rec )) && rc != -1 )
985             log_error(_("problem finding '%s' in trustdb: %s\n"),
986                                                 username, g10_errstr(rc));
987         else if( rc == -1 )
988             log_error(_("user '%s' not in trustdb\n"), username);
989         else if( (rc = list_records( pk->local_id)) )
990             log_error(_("user '%s' read problem: %s\n"),
991                                                 username, g10_errstr(rc));
992         else if( (rc = list_sigs( pk->local_id )) )
993             log_error(_("user '%s' list problem: %s\n"),
994                                                 username, g10_errstr(rc));
995         free_public_key( pk );
996     }
997     else {
998         ulong recnum;
999         int i;
1000
1001         printf("TrustDB: %s\n", tdbio_get_dbname() );
1002         for(i=9+strlen(tdbio_get_dbname()); i > 0; i-- )
1003             putchar('-');
1004         putchar('\n');
1005         for(recnum=0; !tdbio_read_record( recnum, &rec, 0); recnum++ )
1006             tdbio_dump_record( &rec, stdout );
1007     }
1008 }
1009
1010 /****************
1011  * Print a list of all defined owner trust value.
1012  */
1013 void
1014 export_ownertrust()
1015 {
1016     TRUSTREC rec;
1017     TRUSTREC rec2;
1018     ulong recnum;
1019     int i;
1020     byte *p;
1021     int rc;
1022
1023     printf(_("# List of assigned trustvalues, created %s\n"
1024              "# (Use \"gpgm --import-ownertrust\" to restore them)\n"),
1025            asctimestamp( make_timestamp() ) );
1026     for(recnum=0; !tdbio_read_record( recnum, &rec, 0); recnum++ ) {
1027         if( rec.rectype == RECTYPE_DIR ) {
1028             if( !rec.r.dir.keylist ) {
1029                 log_error(_("directory record w/o primary key\n"));
1030                 continue;
1031             }
1032             if( !rec.r.dir.ownertrust )
1033                 continue;
1034             rc = tdbio_read_record( rec.r.dir.keylist, &rec2, RECTYPE_KEY);
1035             if( rc ) {
1036                 log_error(_("error reading key record: %s\n"), g10_errstr(rc));
1037                 continue;
1038             }
1039             p = rec2.r.key.fingerprint;
1040             for(i=0; i < rec2.r.key.fingerprint_len; i++, p++ )
1041                 printf("%02X", *p );
1042             printf(":%u:\n", (unsigned)rec.r.dir.ownertrust );
1043         }
1044     }
1045 }
1046
1047
1048 void
1049 import_ownertrust( const char *fname )
1050 {
1051     FILE *fp;
1052     int is_stdin=0;
1053     char line[256];
1054     char *p;
1055     size_t n, fprlen;
1056     unsigned otrust;
1057
1058     if( !fname || (*fname == '-' && !fname[1]) ) {
1059         fp = stdin;
1060         fname = "[stdin]";
1061         is_stdin = 1;
1062     }
1063     else if( !(fp = fopen( fname, "r" )) ) {
1064         log_error_f(fname, _("can't open file: %s\n"), strerror(errno) );
1065         return;
1066     }
1067
1068     while( fgets( line, DIM(line)-1, fp ) ) {
1069         TRUSTREC rec;
1070         int rc;
1071
1072         if( !*line || *line == '#' )
1073             continue;
1074         n = strlen(line);
1075         if( line[n-1] != '\n' ) {
1076             log_error_f(fname, _("line to long\n") );
1077             /* ... or last line does not have a LF */
1078             break; /* can't continue */
1079         }
1080         for(p = line; *p && *p != ':' ; p++ )
1081             if( !isxdigit(*p) )
1082                 break;
1083         if( *p != ':' ) {
1084             log_error_f(fname, _("error: missing colon\n") );
1085             continue;
1086         }
1087         fprlen = p - line;
1088         if( fprlen != 32 && fprlen != 40 ) {
1089             log_error_f(fname, _("error: invalid fingerprint\n") );
1090             continue;
1091         }
1092         if( sscanf(p, ":%u:", &otrust ) != 1 ) {
1093             log_error_f(fname, _("error: no ownertrust value\n") );
1094             continue;
1095         }
1096         if( !otrust )
1097             continue; /* no otrust defined - no need to update or insert */
1098         /* convert the ascii fingerprint to binary */
1099         for(p=line, fprlen=0; *p != ':'; p += 2 )
1100             line[fprlen++] = HEXTOBIN(p[0]) * 16 + HEXTOBIN(p[1]);
1101         line[fprlen] = 0;
1102
1103       repeat:
1104         rc = tdbio_search_dir_byfpr( line, fprlen, 0, &rec );
1105         if( !rc ) { /* found: update */
1106             if( rec.r.dir.ownertrust )
1107                 log_info(_("LID %lu: changing trust from %u to %u\n"),
1108                           rec.r.dir.lid, rec.r.dir.ownertrust, otrust );
1109             else
1110                 log_info(_("LID %lu: setting trust to %u\n"),
1111                                    rec.r.dir.lid, otrust );
1112             rec.r.dir.ownertrust = otrust;
1113             write_record( &rec );
1114         }
1115         else if( rc == -1 ) { /* not found; get the key from the ring */
1116             PKT_public_key *pk = m_alloc_clear( sizeof *pk );
1117
1118             log_info_f(fname, _("key not in trustdb, searching ring.\n"));
1119             rc = get_pubkey_byfprint( pk, line, fprlen );
1120             if( rc )
1121                 log_info_f(fname, _("key not in ring: %s\n"), g10_errstr(rc));
1122             else {
1123                 rc = query_trust_record( pk );  /* only as assertion */
1124                 if( rc != -1 )
1125                     log_error_f(fname, _("Oops: key is now in trustdb???\n"));
1126                 else {
1127                     rc = insert_trust_record( pk );
1128                     if( !rc )
1129                         goto repeat; /* update the ownertrust */
1130                     log_error_f(fname, _("insert trust record failed: %s\n"),
1131                                                            g10_errstr(rc) );
1132                 }
1133             }
1134         }
1135         else /* error */
1136             log_error_f(fname, _("error finding dir record: %s\n"),
1137                                                     g10_errstr(rc));
1138     }
1139     if( ferror(fp) )
1140         log_error_f(fname, _("read error: %s\n"), strerror(errno) );
1141     if( !is_stdin )
1142         fclose(fp);
1143     do_sync();
1144 }
1145
1146
1147
1148
1149 static void
1150 print_path( int pathlen, TRUST_INFO *path )
1151 {
1152     int rc, i;
1153     u32 keyid[2];
1154
1155     fputs("path:", stdout);
1156     for( i = 0; i < pathlen; i++ )  {
1157         if( i && !(i%4) )
1158             fputs("     ", stdout );
1159         rc = keyid_from_lid( path[i].lid, keyid );
1160         if( rc )
1161             printf(" ????????.%lu:", path[i].lid );
1162         else
1163             printf(" %08lX.%lu:", (ulong)keyid[1], path[i].lid );
1164         print_sigflags( stdout, path[i].otrust );
1165     }
1166     putchar('\n');
1167 }
1168
1169
1170
1171 void
1172 list_trust_path( int max_depth, const char *username )
1173 {
1174     int rc;
1175     int wipe=0;
1176     TRUSTREC rec;
1177     TRUST_INFO *tmppath;
1178     TRUST_SEG_LIST trust_seg_list, tsl, tsl2;
1179     PKT_public_key *pk = m_alloc_clear( sizeof *pk );
1180
1181     if( max_depth < 0 ) {
1182         wipe = 1;
1183         max_depth = -max_depth;
1184     }
1185
1186     if( (rc = get_pubkey_byname(NULL, pk, username, NULL )) )
1187         log_error(_("user '%s' not found: %s\n"), username, g10_errstr(rc) );
1188     else if( (rc=tdbio_search_dir_bypk( pk, &rec )) && rc != -1 )
1189         log_error(_("problem finding '%s' in trustdb: %s\n"),
1190                                             username, g10_errstr(rc));
1191     else if( rc == -1 ) {
1192         log_info(_("user '%s' not in trustdb - inserting\n"), username);
1193         rc = insert_trust_record( pk );
1194         if( rc )
1195             log_error(_("failed to put '%s' into trustdb: %s\n"),
1196                                                     username, g10_errstr(rc));
1197         else {
1198             assert( pk->local_id );
1199         }
1200     }
1201     free_public_key( pk );
1202
1203     /* collect the paths */
1204     tmppath = m_alloc_clear( (max_depth+1)* sizeof *tmppath );
1205     trust_seg_list = NULL;
1206     collect_paths( 0, max_depth, 1, &rec, tmppath, &trust_seg_list );
1207     m_free( tmppath );
1208     /* and now print them */
1209     for(tsl = trust_seg_list; tsl; tsl = tsl->next ) {
1210         print_path( tsl->pathlen, tsl->path );
1211     }
1212
1213     /* release the list */
1214     for(tsl = trust_seg_list; tsl; tsl = tsl2 ) {
1215         tsl2 = tsl->next;
1216         m_free( tsl );
1217     }
1218     trust_seg_list = NULL;
1219 }
1220
1221
1222 /****************
1223  * Check the complete trustdb or only the entries for the given username.
1224  * We check the complete database and recalculate all flags.
1225  */
1226 void
1227 check_trustdb( const char *username )
1228 {
1229     TRUSTREC rec;
1230     KBNODE keyblock = NULL;
1231     KBPOS kbpos;
1232     int rc;
1233
1234     if( username ) {
1235         rc = find_keyblock_byname( &kbpos, username );
1236         if( !rc )
1237             rc = read_keyblock( &kbpos, &keyblock );
1238         if( rc ) {
1239             log_error(_("%s: keyblock read problem: %s\n"),
1240                                     username, g10_errstr(rc));
1241         }
1242         else {
1243             int modified;
1244
1245             rc = update_trust_record( keyblock, 0, &modified );
1246             if( rc == -1 ) { /* not yet in trustdb: insert */
1247                 rc = insert_trust_record(
1248                             find_kbnode( keyblock, PKT_PUBLIC_KEY
1249                                        ) ->pkt->pkt.public_key );
1250
1251             }
1252             if( rc )
1253                 log_error(_("%s: update failed: %s\n"),
1254                                            username, g10_errstr(rc) );
1255             else if( modified )
1256                 log_info(_("%s: updated\n"), username );
1257             else
1258                 log_info(_("%s: okay\n"), username );
1259
1260         }
1261         release_kbnode( keyblock ); keyblock = NULL;
1262     }
1263     else {
1264         ulong recnum;
1265         ulong count=0, upd_count=0, err_count=0, skip_count=0;
1266
1267         for(recnum=0; !tdbio_read_record( recnum, &rec, 0); recnum++ ) {
1268             if( rec.rectype == RECTYPE_DIR ) {
1269                 TRUSTREC tmp;
1270                 int modified;
1271
1272                 if( !rec.r.dir.keylist ) {
1273                     log_info(_("lid %lu: dir record w/o key - skipped\n"),
1274                                                                   recnum);
1275                     count++;
1276                     skip_count++;
1277                     continue;
1278                 }
1279
1280                 read_record( rec.r.dir.keylist, &tmp, RECTYPE_KEY );
1281
1282                 rc = get_keyblock_byfprint( &keyblock,
1283                                             tmp.r.key.fingerprint,
1284                                             tmp.r.key.fingerprint_len );
1285                 if( rc ) {
1286                     log_error(_("lid %lu: keyblock not found: %s\n"),
1287                                                  recnum, g10_errstr(rc) );
1288                     count++;
1289                     skip_count++;
1290                     continue;
1291                 }
1292
1293                 rc = update_trust_record( keyblock, 0, &modified );
1294                 if( rc ) {
1295                     log_error(_("lid %lu: update failed: %s\n"),
1296                                                  recnum, g10_errstr(rc) );
1297                     err_count++;
1298                 }
1299                 else if( modified ) {
1300                     if( opt.verbose )
1301                         log_info(_("lid %lu: updated\n"), recnum );
1302                     upd_count++;
1303                 }
1304                 else if( opt.verbose > 1 )
1305                     log_info(_("lid %lu: okay\n"), recnum );
1306
1307                 release_kbnode( keyblock ); keyblock = NULL;
1308                 if( !(++count % 100) )
1309                     log_info(_("%lu keys so far processed\n"), count);
1310             }
1311         }
1312         log_info(_("%lu keys processed\n"), count);
1313         if( skip_count )
1314             log_info(_("\t%lu keys skipped\n"), skip_count);
1315         if( err_count )
1316             log_info(_("\t%lu keys with errors\n"), err_count);
1317         if( upd_count )
1318             log_info(_("\t%lu keys updated\n"), upd_count);
1319     }
1320 }
1321
1322
1323 /****************
1324  * Put new entries  from the pubrings into the trustdb.
1325  * This function honors the sig flags to speed up the check.
1326  */
1327 void
1328 update_trustdb( )
1329 {
1330     KBNODE keyblock = NULL;
1331     KBPOS kbpos;
1332     int rc;
1333
1334     rc = enum_keyblocks( 0, &kbpos, &keyblock );
1335     if( !rc ) {
1336         ulong count=0, upd_count=0, err_count=0, new_count=0;
1337
1338         while( !(rc = enum_keyblocks( 1, &kbpos, &keyblock )) ) {
1339             int modified;
1340
1341             rc = update_trust_record( keyblock, 1, &modified );
1342             if( rc == -1 ) { /* not yet in trustdb: insert */
1343                 PKT_public_key *pk =
1344                             find_kbnode( keyblock, PKT_PUBLIC_KEY
1345                                        ) ->pkt->pkt.public_key;
1346                 rc = insert_trust_record( pk );
1347                 if( rc && !pk->local_id ) {
1348                     log_error(_("lid ?: insert failed: %s\n"),
1349                                                      g10_errstr(rc) );
1350                     err_count++;
1351                 }
1352                 else if( rc ) {
1353                     log_error(_("lid %lu: insert failed: %s\n"),
1354                                        pk->local_id, g10_errstr(rc) );
1355                     err_count++;
1356                 }
1357                 else {
1358                     if( opt.verbose )
1359                         log_info(_("lid %lu: inserted\n"), pk->local_id );
1360                     new_count++;
1361                 }
1362             }
1363             else if( rc ) {
1364                 log_error(_("lid %lu: update failed: %s\n"),
1365                          lid_from_keyblock(keyblock), g10_errstr(rc) );
1366                 err_count++;
1367             }
1368             else if( modified ) {
1369                 if( opt.verbose )
1370                     log_info(_("lid %lu: updated\n"), lid_from_keyblock(keyblock));
1371                 upd_count++;
1372             }
1373             else if( opt.verbose > 1 )
1374                 log_info(_("lid %lu: okay\n"), lid_from_keyblock(keyblock) );
1375
1376             release_kbnode( keyblock ); keyblock = NULL;
1377             if( !(++count % 100) )
1378                 log_info(_("%lu keys so far processed\n"), count);
1379         }
1380         log_info(_("%lu keys processed\n"), count);
1381         if( err_count )
1382             log_info(_("\t%lu keys with errors\n"), err_count);
1383         if( upd_count )
1384             log_info(_("\t%lu keys updated\n"), upd_count);
1385         if( new_count )
1386             log_info(_("\t%lu keys inserted\n"), new_count);
1387     }
1388     if( rc && rc != -1 )
1389         log_error(_("enumerate keyblocks failed: %s\n"), g10_errstr(rc));
1390
1391     enum_keyblocks( 2, &kbpos, &keyblock ); /* close */
1392     release_kbnode( keyblock );
1393 }
1394
1395
1396 \f
1397 /****************
1398  * Get the trustlevel for this PK.
1399  * Note: This does not ask any questions
1400  * Returns: 0 okay of an errorcode
1401  *
1402  * It operates this way:
1403  *  locate the pk in the trustdb
1404  *      found:
1405  *          Do we have a valid cache record for it?
1406  *              yes: return trustlevel from cache
1407  *              no:  make a cache record and all the other stuff
1408  *      not found:
1409  *          try to insert the pubkey into the trustdb and check again
1410  *
1411  * Problems: How do we get the complete keyblock to check that the
1412  *           cache record is actually valid?  Think we need a clever
1413  *           cache in getkey.c  to keep track of this stuff. Maybe it
1414  *           is not necessary to check this if we use a local pubring. Hmmmm.
1415  */
1416 int
1417 check_trust( PKT_public_key *pk, unsigned *r_trustlevel )
1418 {
1419     TRUSTREC rec;
1420     unsigned trustlevel = TRUST_UNKNOWN;
1421     int rc=0;
1422     u32 cur_time;
1423     u32 keyid[2];
1424
1425
1426     keyid_from_pk( pk, keyid );
1427
1428     /* get the pubkey record */
1429     if( pk->local_id ) {
1430         read_record( pk->local_id, &rec, RECTYPE_DIR );
1431     }
1432     else { /* no local_id: scan the trustdb */
1433         if( (rc=tdbio_search_dir_bypk( pk, &rec )) && rc != -1 ) {
1434             log_error(_("check_trust: search dir record failed: %s\n"),
1435                                                             g10_errstr(rc));
1436             return rc;
1437         }
1438         else if( rc == -1 ) { /* not found - insert */
1439             rc = insert_trust_record( pk );
1440             if( rc ) {
1441                 log_error(_("key %08lX: insert trust record failed: %s\n"),
1442                                           (ulong)keyid[1], g10_errstr(rc));
1443                 goto leave;
1444             }
1445             log_info(_("key %08lX.%lu: inserted into trustdb\n"),
1446                                           (ulong)keyid[1], pk->local_id );
1447             /* and re-read the dir record */
1448             read_record( pk->local_id, &rec, RECTYPE_DIR );
1449         }
1450     }
1451     cur_time = make_timestamp();
1452     if( pk->timestamp > cur_time ) {
1453         log_info(_("key %08lX.%lu: created in future "
1454                    "(time warp or clock problem)\n"),
1455                                           (ulong)keyid[1], pk->local_id );
1456         return G10ERR_TIME_CONFLICT;
1457     }
1458
1459     if( pk->expiredate && pk->expiredate <= cur_time ) {
1460         log_info(_("key %08lX.%lu: expired at %s\n"),
1461                         (ulong)keyid[1], pk->local_id,
1462                              asctimestamp( pk->expiredate) );
1463          trustlevel = TRUST_EXPIRED;
1464     }
1465     else {
1466         rc = do_check( &rec, &trustlevel );
1467         if( rc ) {
1468             log_error(_("key %08lX.%lu: trust check failed: %s\n"),
1469                             (ulong)keyid[1], pk->local_id, g10_errstr(rc));
1470             return rc;
1471         }
1472     }
1473
1474
1475   leave:
1476     if( DBG_TRUST )
1477         log_debug("check_trust() returns trustlevel %04x.\n", trustlevel);
1478     *r_trustlevel = trustlevel;
1479     return 0;
1480 }
1481
1482
1483 int
1484 query_trust_info( PKT_public_key *pk )
1485 {
1486     unsigned trustlevel;
1487     int c;
1488
1489     if( check_trust( pk, &trustlevel ) )
1490         return '?';
1491     if( trustlevel & TRUST_FLAG_REVOKED )
1492         return 'r';
1493     switch( (trustlevel & TRUST_MASK) ) {
1494       case TRUST_UNKNOWN:   c = 'o'; break;
1495       case TRUST_EXPIRED:   c = 'e'; break;
1496       case TRUST_UNDEFINED: c = 'q'; break;
1497       case TRUST_NEVER:     c = 'n'; break;
1498       case TRUST_MARGINAL:  c = 'm'; break;
1499       case TRUST_FULLY:     c = 'f'; break;
1500       case TRUST_ULTIMATE:  c = 'u'; break;
1501       default: BUG();
1502     }
1503     return c;
1504 }
1505
1506
1507
1508 /****************
1509  * Enumerate all keys, which are needed to build all trust paths for
1510  * the given key.  This function does not return the key itself or
1511  * the ultimate key (the last point in cerificate chain).  Only
1512  * certificate chains which ends up at an ultimately trusted key
1513  * are listed.  If ownertrust or validity is not NULL, the corresponding
1514  * value for the returned LID is also returned in these variable(s).
1515  *
1516  *  1) create a void pointer and initialize it to NULL
1517  *  2) pass this void pointer by reference to this function.
1518  *     Set lid to the key you want to enumerate and pass it by reference.
1519  *  3) call this function as long as it does not return -1
1520  *     to indicate EOF. LID does contain the next key used to build the web
1521  *  4) Always call this function a last time with LID set to NULL,
1522  *     so that it can free its context.
1523  *
1524  * Returns: -1 on EOF or the level of the returned LID
1525  */
1526 int
1527 enum_cert_paths( void **context, ulong *lid,
1528                  unsigned *ownertrust, unsigned *validity )
1529 {
1530     struct {
1531        int init;
1532        TRUST_SEG_LIST tsl_head;
1533        TRUST_SEG_LIST tsl;
1534        int idx;
1535     } *ctx;
1536     TRUST_SEG_LIST tsl;
1537
1538     if( !lid ) {  /* release the context */
1539         if( *context ) {
1540             TRUST_SEG_LIST tsl2;
1541
1542             ctx = *context;
1543             for(tsl = ctx->tsl_head; tsl; tsl = tsl2 ) {
1544                 tsl2 = tsl->next;
1545                 m_free( tsl );
1546             }
1547             *context = NULL;
1548         }
1549         return -1;
1550     }
1551
1552     if( !*context ) {
1553         TRUST_INFO *tmppath;
1554         TRUSTREC rec;
1555
1556         if( !lid )
1557             return -1;
1558
1559         ctx = m_alloc_clear( sizeof *ctx );
1560         *context = ctx;
1561         /* collect the paths */
1562         read_record( *lid, &rec, RECTYPE_DIR );
1563         tmppath = m_alloc_clear( (opt.max_cert_depth+1)* sizeof *tmppath );
1564         tsl = NULL;
1565         collect_paths( 0, opt.max_cert_depth, 1, &rec, tmppath, &tsl );
1566         m_free( tmppath );
1567         /* and now print them */
1568         ctx->tsl_head = tsl;
1569         ctx->tsl = ctx->tsl_head;
1570         ctx->idx = 0;
1571     }
1572     else
1573         ctx = *context;
1574
1575     while( ctx->tsl && ctx->idx >= tsl->pathlen )  {
1576         ctx->tsl = ctx->tsl->next;
1577         ctx->idx = 0;
1578     }
1579     tsl = ctx->tsl;
1580     if( !tsl )
1581         return -1; /* eof */
1582
1583     if( ownertrust )
1584         *ownertrust = tsl->path[ctx->idx].otrust;
1585     if( validity )
1586         *validity = tsl->path[ctx->idx].trust;
1587     *lid = tsl->path[ctx->idx].lid;
1588     ctx->idx++;
1589     return ctx->idx-1;
1590 }
1591
1592
1593 /****************
1594  * Return the assigned ownertrust value for the given LID
1595  */
1596 unsigned
1597 get_ownertrust( ulong lid )
1598 {
1599     TRUSTREC rec;
1600
1601     read_record( lid, &rec, RECTYPE_DIR );
1602     return rec.r.dir.ownertrust;
1603 }
1604
1605 int
1606 get_ownertrust_info( ulong lid )
1607 {
1608     unsigned otrust;
1609     int c;
1610
1611     otrust = get_ownertrust( lid );
1612     switch( (otrust & TRUST_MASK) ) {
1613       case TRUST_NEVER:     c = 'n'; break;
1614       case TRUST_MARGINAL:  c = 'm'; break;
1615       case TRUST_FULLY:     c = 'f'; break;
1616       case TRUST_ULTIMATE:  c = 'u'; break;
1617       default:              c = '-'; break;
1618     }
1619     return c;
1620 }
1621
1622
1623 byte *
1624 get_pref_data( ulong lid, const byte *namehash, size_t *ret_n )
1625 {
1626     TRUSTREC rec;
1627     ulong recno;
1628
1629     read_record( lid, &rec, RECTYPE_DIR );
1630     for( recno=rec.r.dir.uidlist; recno; recno = rec.r.uid.next ) {
1631         read_record( recno, &rec, RECTYPE_UID );
1632         if( rec.r.uid.prefrec
1633             && ( !namehash || !memcmp(namehash, rec.r.uid.namehash, 20) ))  {
1634             byte *buf;
1635             /* found the correct one or the first one */
1636             read_record( rec.r.uid.prefrec, &rec, RECTYPE_PREF );
1637             if( rec.r.pref.next )
1638                 log_info(_("WARNING: can't yet handle long pref records\n"));
1639             buf = m_alloc( ITEMS_PER_PREF_RECORD );
1640             memcpy( buf, rec.r.pref.data, ITEMS_PER_PREF_RECORD );
1641             *ret_n = ITEMS_PER_PREF_RECORD;
1642             return buf;
1643         }
1644     }
1645     return NULL;
1646 }
1647
1648
1649
1650 /****************
1651  * Check whether the algorithm is in one of the pref records
1652  */
1653 int
1654 is_algo_in_prefs( ulong lid, int preftype, int algo )
1655 {
1656     TRUSTREC rec;
1657     ulong recno;
1658     int i;
1659     byte *pref;
1660
1661     read_record( lid, &rec, RECTYPE_DIR );
1662     for( recno=rec.r.dir.uidlist; recno; recno = rec.r.uid.next ) {
1663         read_record( recno, &rec, RECTYPE_UID );
1664         if( rec.r.uid.prefrec ) {
1665             read_record( rec.r.uid.prefrec, &rec, RECTYPE_PREF );
1666             if( rec.r.pref.next )
1667                 log_info(_("WARNING: can't yet handle long pref records\n"));
1668             pref = rec.r.pref.data;
1669             for(i=0; i+1 < ITEMS_PER_PREF_RECORD; i+=2 ) {
1670                 if( pref[i] == preftype && pref[i+1] == algo )
1671                     return 1;
1672             }
1673         }
1674     }
1675     return 0;
1676 }
1677
1678
1679 static int
1680 get_dir_record( PKT_public_key *pk, TRUSTREC *rec )
1681 {
1682     int rc=0;
1683
1684     if( pk->local_id ) {
1685         read_record( pk->local_id, rec, RECTYPE_DIR );
1686     }
1687     else { /* no local_id: scan the trustdb */
1688         if( (rc=tdbio_search_dir_bypk( pk, rec )) && rc != -1 )
1689             log_error(_("get_dir_record: search_record failed: %s\n"),
1690                                                             g10_errstr(rc));
1691     }
1692     return rc;
1693 }
1694
1695
1696
1697 /****************
1698  * This function simply looks for the key in the trustdb
1699  * and makes sure that pk->local_id is set to the coreect value.
1700  * Return: 0 = found
1701  *         -1 = not found
1702  *        other = error
1703  */
1704 int
1705 query_trust_record( PKT_public_key *pk )
1706 {
1707     TRUSTREC rec;
1708     return get_dir_record( pk, &rec );
1709 }
1710
1711
1712 int
1713 clear_trust_checked_flag( PKT_public_key *pk )
1714 {
1715     TRUSTREC rec;
1716     int rc;
1717
1718     rc = get_dir_record( pk, &rec );
1719     if( rc )
1720         return rc;
1721
1722     /* check whether they are already reset */
1723     if(   !(rec.r.dir.dirflags & DIRF_CHECKED)
1724        && !(rec.r.dir.dirflags & DIRF_VALVALID) )
1725         return 0;
1726
1727     /* reset the flag */
1728     rec.r.dir.dirflags &= ~DIRF_CHECKED;
1729     rec.r.dir.dirflags &= ~DIRF_VALVALID;
1730     write_record( &rec );
1731     do_sync();
1732     return 0;
1733 }
1734
1735
1736
1737
1738 static void
1739 check_hint_sig( ulong lid, KBNODE keyblock, u32 *keyid, byte *uidrec_hash,
1740                 TRUSTREC *sigrec, int sigidx, ulong hint_owner )
1741 {
1742     KBNODE node;
1743     int rc, state;
1744     byte uhash[20];
1745     int is_selfsig;
1746     PKT_signature *sigpkt = NULL;
1747     TRUSTREC tmp;
1748     u32 sigkid[2];
1749     int revoke = 0;
1750
1751     if( sigrec->r.sig.sig[sigidx].flag & SIGF_CHECKED )
1752         log_info(_("NOTE: sig rec %lu[%d] in hintlist "
1753                    "of %lu but marked as checked\n"),
1754                     sigrec->recnum, sigidx, hint_owner );
1755     if( !(sigrec->r.sig.sig[sigidx].flag & SIGF_NOPUBKEY) )
1756         log_info(_("NOTE: sig rec %lu[%d] in hintlist "
1757                    "of %lu but not marked\n"),
1758                     sigrec->recnum, sigidx, hint_owner );
1759
1760     read_record( sigrec->r.sig.sig[sigidx].lid, &tmp, 0 );
1761     if( tmp.rectype != RECTYPE_DIR ) {
1762         /* we need the dir record */
1763         log_error(_("sig rec %lu[%d] in hintlist "
1764                     "of %lu does not point to a dir record\n"),
1765                     sigrec->recnum, sigidx, hint_owner );
1766         return;
1767     }
1768     if( !tmp.r.dir.keylist ) {
1769         log_error(_("lid %lu: no primary key\n"), tmp.r.dir.lid );
1770         return;
1771     }
1772     read_record(tmp.r.dir.keylist, &tmp, RECTYPE_KEY );
1773     keyid_from_fingerprint( tmp.r.key.fingerprint,
1774                             tmp.r.key.fingerprint_len, sigkid );
1775
1776
1777     /* find the correct signature packet */
1778     state = 0;
1779     for( node=keyblock; node; node = node->next ) {
1780         if( node->pkt->pkttype == PKT_USER_ID ) {
1781             PKT_user_id *uidpkt = node->pkt->pkt.user_id;
1782
1783             if( state )
1784                 break;
1785             rmd160_hash_buffer( uhash, uidpkt->name, uidpkt->len );
1786             if( !memcmp( uhash, uidrec_hash, 20 ) )
1787                 state = 1;
1788         }
1789         else if( state && node->pkt->pkttype == PKT_SIGNATURE ) {
1790             sigpkt = node->pkt->pkt.signature;
1791             if( sigpkt->keyid[0] == sigkid[0]
1792                 && sigpkt->keyid[1] == sigkid[1]
1793                 && ( (sigpkt->sig_class&~3) == 0x10
1794                      || ( revoke = (sigpkt->sig_class == 0x30)) ) ) {
1795                 state = 2;
1796                 break; /* found */
1797             }
1798         }
1799     }
1800
1801     if( !node ) {
1802         log_info(_("lid %lu: user id not found in keyblock\n"), lid );
1803         return ;
1804     }
1805     if( state != 2 ) {
1806         log_info(_("lid %lu: user id without signature\n"), lid );
1807         return ;
1808     }
1809
1810     /* and check the sig */
1811     rc = check_key_signature( keyblock, node, &is_selfsig );
1812     if( is_selfsig ) {
1813         log_error(_("lid %lu: self-signature in hintlist\n"), lid );
1814         return;
1815     }
1816
1817     /* FiXME: handling fo SIGF_REVOKED is not correct! */
1818
1819     if( !rc ) { /* valid signature */
1820         if( opt.verbose )
1821             log_info("sig %08lX.%lu/%02X%02X/%08lX: %s\n",
1822                     (ulong)keyid[1], lid, uhash[18], uhash[19],
1823                     (ulong)sigpkt->keyid[1],
1824                     revoke? _("Valid certificate revocation")
1825                           : _("Good certificate") );
1826         sigrec->r.sig.sig[sigidx].flag = SIGF_CHECKED | SIGF_VALID;
1827         if( revoke )
1828             sigrec->r.sig.sig[sigidx].flag |= SIGF_REVOKED;
1829     }
1830     else if( rc == G10ERR_NO_PUBKEY ) {
1831         log_info("sig %08lX.%lu/%02X%02X/%08lX: %s\n",
1832               (ulong)keyid[1], lid, uhash[18], uhash[19],
1833                (ulong)sigpkt->keyid[1],
1834                  _("very strange: no public key\n") );
1835         sigrec->r.sig.sig[sigidx].flag = SIGF_NOPUBKEY;
1836     }
1837     else {
1838         log_info("sig %08lX.%lu/%02X%02X/%08lX: %s\n",
1839                     (ulong)keyid[1], lid, uhash[18], uhash[19],
1840                     (ulong)sigpkt->keyid[1], g10_errstr(rc) );
1841         sigrec->r.sig.sig[sigidx].flag = SIGF_CHECKED;
1842     }
1843     sigrec->dirty = 1;
1844 }
1845
1846
1847 /****************
1848  * Process a hintlist.
1849  * Fixme: this list is not anymore anchored to another
1850  *        record, so it should be put elsewehere in case of an error
1851  */
1852 static void
1853 process_hintlist( ulong hintlist, ulong hint_owner )
1854 {
1855     ulong hlst_rn;
1856     int rc;
1857
1858     for( hlst_rn = hintlist; hlst_rn; ) {
1859         TRUSTREC hlstrec;
1860         int hlst_idx;
1861
1862         read_record( hlst_rn, &hlstrec, RECTYPE_HLST );
1863
1864         for( hlst_idx=0; hlst_idx < ITEMS_PER_HLST_RECORD; hlst_idx++ ) {
1865             TRUSTREC dirrec;
1866             TRUSTREC uidrec;
1867             TRUSTREC tmprec;
1868             KBNODE keyblock = NULL;
1869             u32 keyid[2];
1870             ulong lid;
1871             ulong r1, r2;
1872
1873             lid = hlstrec.r.hlst.rnum[hlst_idx];
1874             if( !lid )
1875                 continue;
1876
1877             read_record( lid, &dirrec, 0 );
1878             /* make sure it points to a dir record:
1879              * this should be true because it only makes sense to
1880              * call this function if the dir record is available */
1881             if( dirrec.rectype != RECTYPE_DIR )  {
1882                 log_error(_("hintlist %lu[%d] of %lu "
1883                             "does not point to a dir record\n"),
1884                             hlst_rn, hlst_idx, hint_owner );
1885                 continue;
1886             }
1887             if( !dirrec.r.dir.keylist ) {
1888                 log_error(_("lid %lu does not have a key\n"), lid );
1889                 continue;
1890             }
1891
1892             /* get the keyblock */
1893             read_record( dirrec.r.dir.keylist, &tmprec, RECTYPE_KEY );
1894             rc = get_keyblock_byfprint( &keyblock,
1895                                         tmprec.r.key.fingerprint,
1896                                         tmprec.r.key.fingerprint_len );
1897             if( rc ) {
1898                 log_error(_("lid %lu: can't get keyblock: %s\n"),
1899                                                     lid, g10_errstr(rc) );
1900                 continue;
1901             }
1902             keyid_from_fingerprint( tmprec.r.key.fingerprint,
1903                                     tmprec.r.key.fingerprint_len, keyid );
1904
1905             /* Walk over all user ids and their signatures and check all
1906              * the signature which are created by hint_owner */
1907             for( r1 = dirrec.r.dir.uidlist; r1; r1 = uidrec.r.uid.next ) {
1908                 TRUSTREC sigrec;
1909
1910                 read_record( r1, &uidrec, RECTYPE_UID );
1911                 for( r2 = uidrec.r.uid.siglist; r2; r2 = sigrec.r.sig.next ) {
1912                     int i;
1913
1914                     read_record( r2, &sigrec, RECTYPE_SIG );
1915                     sigrec.dirty = 0;
1916                     for(i=0; i < SIGS_PER_RECORD; i++ ) {
1917                         if( !sigrec.r.sig.sig[i].lid )
1918                             continue; /* skip deleted sigs */
1919                         if( sigrec.r.sig.sig[i].lid != hint_owner )
1920                             continue; /* not for us */
1921                         /* some diagnostic messages */
1922                         /* and do the signature check */
1923                         check_hint_sig( lid, keyblock, keyid,
1924                                         uidrec.r.uid.namehash,
1925                                         &sigrec, i, hint_owner );
1926                     }
1927                     if( sigrec.dirty )
1928                         write_record( &sigrec );
1929                 }
1930             }
1931             release_kbnode( keyblock );
1932         } /* loop over hlst entries */
1933
1934         /* delete this hlst record */
1935         hlst_rn = hlstrec.r.hlst.next;
1936         delete_record( hlstrec.recnum );
1937     } /* loop over hintlist */
1938 }
1939
1940
1941 /****************
1942  * Create or update shadow dir record and return the LID of the record
1943  */
1944 static ulong
1945 create_shadow_dir( PKT_signature *sig, ulong lid  )
1946 {
1947     TRUSTREC sdir, hlst, tmphlst;
1948     ulong recno, newlid;
1949     int tmpidx=0; /* avoids gcc warnign - this is controlled by tmphlst */
1950     int rc;
1951
1952     /* first see whether we already have such a record */
1953     rc = tdbio_search_sdir( sig->keyid, sig->pubkey_algo, &sdir );
1954     if( rc && rc != -1 ) {
1955         log_error(_("tdbio_search_dir failed: %s\n"), g10_errstr(rc));
1956         die_invalid_db();
1957     }
1958     if( rc == -1 ) { /* not found: create */
1959         memset( &sdir, 0, sizeof sdir );
1960         sdir.recnum = tdbio_new_recnum();
1961         sdir.rectype= RECTYPE_SDIR;
1962         sdir.r.sdir.lid = sdir.recnum;
1963         sdir.r.sdir.keyid[0] = sig->keyid[0];
1964         sdir.r.sdir.keyid[1] = sig->keyid[1];
1965         sdir.r.sdir.pubkey_algo = sig->pubkey_algo;
1966         sdir.r.sdir.hintlist = 0;
1967         write_record( &sdir );
1968     }
1969     newlid = sdir.recnum;
1970     /* Put the record number into the hintlist.
1971      * (It is easier to use the lid and not the record number of the
1972      *  key to save some space (assuming that a signator has
1973      *  signed more than one user id - and it is easier to implement.)
1974      */
1975     tmphlst.recnum = 0;
1976     for( recno=sdir.r.sdir.hintlist; recno; recno = hlst.r.hlst.next) {
1977         int i;
1978         read_record( recno, &hlst, RECTYPE_HLST );
1979         for( i=0; i < ITEMS_PER_HLST_RECORD; i++ ) {
1980             if( !hlst.r.hlst.rnum[i] ) {
1981                 if( !tmphlst.recnum ) {
1982                     tmphlst = hlst;
1983                     tmpidx = i;
1984                 }
1985             }
1986             else if( hlst.r.hlst.rnum[i] == lid )
1987                 return newlid; /* the signature is already in the hintlist */
1988         }
1989     }
1990     /* not yet in the hint list, write it */
1991     if( tmphlst.recnum ) { /* we have an empty slot */
1992         tmphlst.r.hlst.rnum[tmpidx] = lid;
1993         write_record( &tmphlst );
1994     }
1995     else { /* must append a new hlst record */
1996         memset( &hlst, 0, sizeof hlst );
1997         hlst.recnum = tdbio_new_recnum();
1998         hlst.rectype = RECTYPE_HLST;
1999         hlst.r.hlst.next = sdir.r.sdir.hintlist;
2000         hlst.r.hlst.rnum[0] = lid;
2001         write_record( &hlst );
2002         sdir.r.sdir.hintlist = hlst.recnum;
2003         write_record( &sdir );
2004     }
2005
2006     return newlid;
2007 }
2008
2009
2010 /****************
2011  * This function checks the given public key and inserts or updates
2012  * the keyrecord from the trustdb.  Revocation certificates
2013  * are handled here and the keybinding of subkeys is checked.
2014  * Hmmm: Should we check here, that the key has at least one valid
2015  * user ID or do we allow keys w/o user ID?
2016  *
2017  * keyblock points to the first node in the keyblock,
2018  * keynode is the node with the public key to check
2019  * (either primary or secondary), keyid is the keyid of
2020  * the primary key, drec is the directory record and recno_list
2021  * is a list used to keep track of visited records.
2022  * Existing keyflags are recalculated if recheck is true.
2023  */
2024 static void
2025 upd_key_record( KBNODE keyblock, KBNODE keynode, u32 *keyid,
2026                 TRUSTREC *drec, RECNO_LIST *recno_list, int recheck )
2027 {
2028     TRUSTREC krec;
2029     KBNODE  node;
2030     PKT_public_key *pk = keynode->pkt->pkt.public_key;
2031     ulong lid = drec->recnum;
2032     byte fpr[MAX_FINGERPRINT_LEN];
2033     size_t fprlen;
2034     ulong recno, newrecno;
2035     int keybind_seen = 0;
2036     int revoke_seen = 0;
2037     int rc;
2038
2039     fingerprint_from_pk( pk, fpr, &fprlen );
2040     /* do we already have this key? */
2041     for( recno=drec->r.dir.keylist; recno; recno = krec.r.key.next ) {
2042         read_record( recno, &krec, RECTYPE_KEY );
2043         if( krec.r.key.fingerprint_len == fprlen
2044             && !memcmp( krec.r.key.fingerprint, fpr, fprlen ) )
2045             break;
2046     }
2047     if( recno ) { /* yes */
2048         ins_recno_list( recno_list, recno, RECTYPE_KEY );
2049     }
2050     else { /* no: insert this new key */
2051         recheck = 1;
2052         memset( &krec, 0, sizeof(krec) );
2053         krec.rectype = RECTYPE_KEY;
2054         krec.r.key.lid = lid;
2055         krec.r.key.pubkey_algo = pk->pubkey_algo;
2056         krec.r.key.fingerprint_len = fprlen;
2057         memcpy(krec.r.key.fingerprint, fpr, fprlen );
2058         krec.recnum = newrecno = tdbio_new_recnum();
2059         write_record( &krec );
2060         ins_recno_list( recno_list, newrecno, RECTYPE_KEY );
2061         /* and put this new record at the end of the keylist */
2062         if( !(recno=drec->r.dir.keylist) ) {
2063             /* this is the first key */
2064             drec->r.dir.keylist = newrecno;
2065             drec->dirty = 1;
2066         }
2067         else { /* we already have a key, append the new one */
2068             TRUSTREC save = krec;
2069             for( ; recno; recno = krec.r.key.next )
2070                 read_record( recno, &krec, RECTYPE_KEY );
2071             krec.r.key.next = newrecno;
2072             write_record( &krec );
2073             krec = save;
2074         }
2075     }
2076
2077     if( !recheck && (krec.r.key.keyflags & KEYF_CHECKED) )
2078         return;
2079
2080     /* check keybindings and revocations */
2081     krec.r.key.keyflags = 0;
2082     if( keynode->pkt->pkttype == PKT_PUBLIC_KEY ) {
2083         /* we assume that a primary key is always valid
2084          * and check later whether we have a revocation */
2085         krec.r.key.keyflags |= KEYF_CHECKED | KEYF_VALID;
2086     }
2087
2088     for( node=keynode->next; node; node = node->next ) {
2089         PKT_signature *sig;
2090
2091         if( node->pkt->pkttype == PKT_PUBLIC_SUBKEY )
2092             break; /* ready */
2093         else if( node->pkt->pkttype != PKT_SIGNATURE )
2094             continue;
2095
2096         sig = node->pkt->pkt.signature;
2097
2098         if( keyid[0] != sig->keyid[0] || keyid[1] != sig->keyid[1] )
2099             continue; /* not a self signature */
2100         if( sig->sig_class == 0x18 && !keybind_seen ) { /* a keybinding */
2101             if( keynode->pkt->pkttype == PKT_PUBLIC_KEY )
2102                 continue; /* oops, not for a main key */
2103             /* we check until we find a valid keybinding */
2104             rc = check_key_signature( keyblock, node, NULL );
2105             if( !rc ) {
2106                 if( opt.verbose )
2107                     log_info(_(
2108                         "key %08lX.%lu: Good subkey binding\n"),
2109                          (ulong)keyid_from_pk(pk,NULL), lid );
2110                 krec.r.key.keyflags |= KEYF_CHECKED | KEYF_VALID;
2111             }
2112             else {
2113                 log_info(_(
2114                   "key %08lX.%lu: Invalid subkey binding: %s\n"),
2115                     (ulong)keyid_from_pk(pk,NULL), lid, g10_errstr(rc) );
2116                 krec.r.key.keyflags |= KEYF_CHECKED;
2117                 krec.r.key.keyflags &= ~KEYF_VALID;
2118             }
2119             keybind_seen = 1;
2120         }
2121         else if( sig->sig_class == 0x20 && !revoke_seen ) {
2122             if( keynode->pkt->pkttype == PKT_PUBLIC_SUBKEY )
2123                 continue; /* a subkey is not expected here */
2124             /* This is a key revocation certificate: check it */
2125             rc = check_key_signature( keyblock, node, NULL );
2126             if( !rc ) {
2127                 if( opt.verbose )
2128                     log_info(_(
2129                         "key %08lX.%lu: Valid key revocation\n"),
2130                          (ulong)keyid_from_pk(pk,NULL), lid );
2131                 krec.r.key.keyflags |= KEYF_REVOKED;
2132             }
2133             else {
2134                 log_info(_(
2135                   "key %08lX.%lu: Invalid key revocation: %s\n"),
2136                   (ulong)keyid_from_pk(pk,NULL), lid, g10_errstr(rc) );
2137             }
2138             revoke_seen = 1;
2139         }
2140         else if( sig->sig_class == 0x28 && !revoke_seen ) {
2141             if( keynode->pkt->pkttype == PKT_PUBLIC_KEY )
2142                 continue; /* a mainkey is not expected here */
2143             /* This is a subkey revocation certificate: check it */
2144             /* fixme: we should also check the revocation
2145              * is newer than the key (OpenPGP) */
2146             rc = check_key_signature( keyblock, node, NULL );
2147             if( !rc ) {
2148                 if( opt.verbose )
2149                     log_info(_(
2150                         "key %08lX.%lu: Valid subkey revocation\n"),
2151                          (ulong)keyid_from_pk(pk,NULL), lid );
2152                 krec.r.key.keyflags |= KEYF_REVOKED;
2153             }
2154             else {
2155                 log_info(_(
2156                   "key %08lX.%lu: Invalid subkey binding: %s\n"),
2157                   (ulong)keyid_from_pk(pk,NULL), lid, g10_errstr(rc) );
2158             }
2159             revoke_seen = 1;
2160         }
2161     }
2162
2163     write_record( &krec );
2164 }
2165
2166
2167 /****************
2168  * This function checks the given user ID and inserts or updates
2169  * the uid record of the trustdb.  Revocation certificates
2170  * are handled here.
2171  *
2172  * keyblock points to the first node in the keyblock,
2173  * uidnode is the node with the user id to check
2174  * keyid is the keyid of
2175  * the primary key, drec is the directory record and recno_list
2176  * is a list used to keep track of visited records.
2177  * Existing uidflags are recalculated if recheck is true.
2178  */
2179 static void
2180 upd_uid_record( KBNODE keyblock, KBNODE uidnode, u32 *keyid,
2181                 TRUSTREC *drec, RECNO_LIST *recno_list, int recheck )
2182 {
2183     ulong lid = drec->recnum;
2184     PKT_user_id *uid = uidnode->pkt->pkt.user_id;
2185     TRUSTREC urec;
2186     PKT_signature *selfsig = NULL;
2187     byte uidhash[20];
2188     KBNODE node;
2189     ulong recno, newrecno;
2190     int rc;
2191
2192     /* see whether we already have an uid record */
2193     rmd160_hash_buffer( uidhash, uid->name, uid->len );
2194     for( recno=drec->r.dir.uidlist; recno; recno = urec.r.uid.next ) {
2195         read_record( recno, &urec, RECTYPE_UID );
2196         if( !memcmp( uidhash, urec.r.uid.namehash, 20 ) )
2197             break;
2198     }
2199     if( recno ) { /* we already have this record */
2200         ins_recno_list( recno_list, recno, RECTYPE_UID );
2201     }
2202     else { /* new user id */
2203         recheck = 1;
2204         memset( &urec, 0 , sizeof(urec) );
2205         urec.rectype = RECTYPE_UID;
2206         urec.r.uid.lid = drec->recnum;
2207         memcpy(urec.r.uid.namehash, uidhash, 20 );
2208         urec.recnum = newrecno = tdbio_new_recnum();
2209         write_record( &urec );
2210         ins_recno_list( recno_list, newrecno, RECTYPE_UID );
2211         /* and put this new record at the end of the uidlist */
2212         if( !(recno=drec->r.dir.uidlist) ) { /* this is the first uid */
2213             drec->r.dir.uidlist = newrecno;
2214             drec->dirty = 1;
2215         }
2216         else { /* we already have an uid, append it to the list */
2217             TRUSTREC save = urec;
2218             for( ; recno; recno = urec.r.key.next )
2219                 read_record( recno, &urec, RECTYPE_UID );
2220             urec.r.uid.next = newrecno;
2221             write_record( &urec );
2222             urec = save;
2223         }
2224     }
2225
2226     if( recheck || !(urec.r.uid.uidflags & UIDF_CHECKED) ) {
2227         /* check self signatures */
2228         urec.r.uid.uidflags = 0;
2229         for( node=uidnode->next; node; node = node->next ) {
2230             PKT_signature *sig;
2231
2232             if( node->pkt->pkttype == PKT_USER_ID )
2233                 break; /* ready */
2234             if( node->pkt->pkttype == PKT_PUBLIC_SUBKEY )
2235                 break; /* ready */
2236             if( node->pkt->pkttype != PKT_SIGNATURE )
2237                 continue;
2238
2239             sig = node->pkt->pkt.signature;
2240
2241             if( keyid[0] != sig->keyid[0] || keyid[1] != sig->keyid[1] )
2242                 continue; /* not a self signature */
2243
2244             if( (sig->sig_class&~3) == 0x10 ) { /* regular self signature */
2245                 rc = check_key_signature( keyblock, node, NULL );
2246                 if( !rc ) {
2247                     if( opt.verbose )
2248                         log_info( "uid %08lX.%lu/%02X%02X: %s\n",
2249                            (ulong)keyid[1], lid, uidhash[18], uidhash[19],
2250                                   _("Good self-signature") );
2251                     urec.r.uid.uidflags |= UIDF_CHECKED | UIDF_VALID;
2252                     if( !selfsig )
2253                         selfsig = sig; /* use the first valid sig */
2254                 }
2255                 else {
2256                     log_info( "uid %08lX/%02X%02X: %s: %s\n",
2257                                (ulong)keyid[1], uidhash[18], uidhash[19],
2258                               _("Invalid self-signature"),
2259                                g10_errstr(rc) );
2260                     urec.r.uid.uidflags |= UIDF_CHECKED;
2261                 }
2262             }
2263             else if( sig->sig_class == 0x30 ) { /* cert revocation */
2264                 rc = check_key_signature( keyblock, node, NULL );
2265                 if( !rc ) {
2266                     if( opt.verbose )
2267                         log_info( "uid %08lX.%lu/%02X%02X: %s\n",
2268                            (ulong)keyid[1], lid, uidhash[18], uidhash[19],
2269                                  _("Valid user ID revocation\n") );
2270                     urec.r.uid.uidflags |= UIDF_CHECKED | UIDF_VALID;
2271                     urec.r.uid.uidflags |= UIDF_REVOKED;
2272                 }
2273                 else {
2274                     log_info("uid %08lX/%02X%02X: %s: %s\n",
2275                                 (ulong)keyid[1], uidhash[18], uidhash[19],
2276                                _("Invalid user ID revocation"),
2277                                                         g10_errstr(rc) );
2278                 }
2279             }
2280         }
2281         write_record( &urec );
2282     } /* end check self-signatures */
2283
2284
2285     if( (urec.r.uid.uidflags & (UIDF_CHECKED|UIDF_VALID))
2286         != (UIDF_CHECKED|UIDF_VALID) )
2287         return; /* user ID is not valid, so no need to check more things */
2288
2289     /* check the preferences */
2290     if( selfsig )
2291         upd_pref_record( &urec, keyid, selfsig );
2292
2293     /* check non-self signatures */
2294     for( node=uidnode->next; node; node = node->next ) {
2295         PKT_signature *sig;
2296
2297         if( node->pkt->pkttype == PKT_USER_ID )
2298             break; /* ready */
2299         if( node->pkt->pkttype == PKT_PUBLIC_SUBKEY )
2300             break; /* ready */
2301         if( node->pkt->pkttype != PKT_SIGNATURE )
2302             continue;
2303
2304         sig = node->pkt->pkt.signature;
2305
2306         if( keyid[0] == sig->keyid[0] || keyid[1] == sig->keyid[1] )
2307             continue; /* skip self signature */
2308
2309         if( (sig->sig_class&~3) == 0x10 ) { /* regular certification */
2310             upd_cert_record( keyblock, node, keyid, drec, recno_list,
2311                              recheck, &urec, uidhash, 0 );
2312         }
2313         else if( sig->sig_class == 0x30 ) { /* cert revocation */
2314             upd_cert_record( keyblock, node, keyid, drec, recno_list,
2315                              recheck, &urec, uidhash, 1 );
2316         }
2317     } /* end check certificates */
2318
2319     write_record( &urec );
2320 }
2321
2322
2323
2324 /****************
2325  *
2326  *
2327  */
2328 static void
2329 upd_pref_record( TRUSTREC *urec, u32 *keyid, PKT_signature *sig )
2330 {
2331     static struct {
2332         sigsubpkttype_t subpkttype;
2333         int preftype;
2334     } ptable[] = {
2335         { SIGSUBPKT_PREF_SYM,   PREFTYPE_SYM    },
2336         { SIGSUBPKT_PREF_HASH,  PREFTYPE_HASH   },
2337         { SIGSUBPKT_PREF_COMPR, PREFTYPE_COMPR  },
2338         { 0, 0 }
2339     };
2340     TRUSTREC prec;
2341     ulong lid = urec->r.uid.lid ;
2342     const byte *uidhash = urec->r.uid.namehash;
2343     const byte *s;
2344     size_t n;
2345     int k, i;
2346     ulong recno;
2347     byte prefs_sig[200];
2348     int n_prefs_sig = 0;
2349     byte prefs_rec[200];
2350     int n_prefs_rec = 0;
2351
2352     /* check for changed preferences */
2353     for(k=0; ptable[k].subpkttype; k++ ) {
2354         s = parse_sig_subpkt2( sig, ptable[k].subpkttype, &n );
2355         if( s ) {
2356             if( n_prefs_sig >= DIM(prefs_sig)-1 ) {
2357                 log_info("uid %08lX.%lu/%02X%02X: %s\n",
2358                           (ulong)keyid[1], lid, uidhash[18], uidhash[19],
2359                           _("Too many preferences") );
2360                 break;
2361             }
2362             prefs_sig[n_prefs_sig++] = ptable[k].preftype;
2363             prefs_sig[n_prefs_sig++] = *s;
2364         }
2365     }
2366     for( recno=urec->r.uid.prefrec; recno; recno = prec.r.pref.next ) {
2367         read_record( recno, &prec, RECTYPE_PREF );
2368         for(i = 0; i < ITEMS_PER_PREF_RECORD; i +=2 )  {
2369             if( n_prefs_rec >= DIM(prefs_rec)-1 ) {
2370                 log_info("uid %08lX.%lu/%02X%02X: %s\n",
2371                           (ulong)keyid[1], lid, uidhash[18], uidhash[19],
2372                           _("Too many preference items") );
2373                 break;
2374             }
2375             prefs_rec[n_prefs_rec++] = prec.r.pref.data[i];
2376             prefs_rec[n_prefs_rec++] = prec.r.pref.data[i+1];
2377         }
2378     }
2379     if( n_prefs_sig == n_prefs_rec
2380         && !memcmp( prefs_sig, prefs_rec, n_prefs_sig ) )
2381         return;  /* not chnaged */
2382
2383     /* Preferences have changed:  Delete all pref records
2384      * This is much simpler than checking whether we have to
2385      * do update the record at all - the record cache may care about it
2386      */
2387     for( recno=urec->r.uid.prefrec; recno; recno = prec.r.pref.next ) {
2388         read_record( recno, &prec, RECTYPE_PREF );
2389         delete_record( recno );
2390     }
2391
2392     if( n_prefs_sig > ITEMS_PER_PREF_RECORD )
2393          log_info(_("WARNING: can't yet handle long pref records\n"));
2394
2395     memset( &prec, 0, sizeof prec );
2396     prec.recnum = tdbio_new_recnum();
2397     prec.rectype = RECTYPE_PREF;
2398     prec.r.pref.lid = lid;
2399     if( n_prefs_sig <= ITEMS_PER_PREF_RECORD )
2400         memcpy( prec.r.pref.data, prefs_sig, n_prefs_sig );
2401     else { /* need more than one pref record */
2402         TRUSTREC tmp;
2403         ulong nextrn;
2404         int n = n_prefs_sig;
2405         byte *pp = prefs_sig;
2406
2407         memcpy( prec.r.pref.data, pp, ITEMS_PER_PREF_RECORD );
2408         n -= ITEMS_PER_PREF_RECORD;
2409         pp += ITEMS_PER_PREF_RECORD;
2410         nextrn = prec.r.pref.next = tdbio_new_recnum();
2411         do {
2412             memset( &tmp, 0, sizeof tmp );
2413             tmp.recnum = nextrn;
2414             tmp.rectype = RECTYPE_PREF;
2415             tmp.r.pref.lid = lid;
2416             if( n <= ITEMS_PER_PREF_RECORD ) {
2417                 memcpy( tmp.r.pref.data, pp, n );
2418                 n = 0;
2419             }
2420             else {
2421                 memcpy( tmp.r.pref.data, pp, ITEMS_PER_PREF_RECORD );
2422                 n -= ITEMS_PER_PREF_RECORD;
2423                 pp += ITEMS_PER_PREF_RECORD;
2424                 nextrn = tmp.r.pref.next = tdbio_new_recnum();
2425             }
2426             write_record( &tmp );
2427         } while( n );
2428     }
2429     write_record( &prec );
2430     urec->r.uid.prefrec = prec.recnum;
2431     urec->dirty = 1;
2432 }
2433
2434
2435
2436 static void
2437 upd_cert_record( KBNODE keyblock, KBNODE signode, u32 *keyid,
2438                  TRUSTREC *drec, RECNO_LIST *recno_list, int recheck,
2439                  TRUSTREC *urec, const byte *uidhash, int revoke )
2440 {
2441     /* We simply insert the signature into the sig records but
2442      * avoid duplicate ones.  We do not check them here because
2443      * there is a big chance, that we import required public keys
2444      * later.  The problem with this is that we must somewhere store
2445      * the information about this signature (we need a record id).
2446      * We do this by using the record type shadow dir, which will
2447      * be converted to a dir record as soon as a new public key is
2448      * inserted into the trustdb.
2449      */
2450     ulong lid = drec->recnum;
2451     PKT_signature *sig = signode->pkt->pkt.signature;
2452     TRUSTREC rec;
2453     ulong recno;
2454     TRUSTREC delrec;
2455     int delrecidx=0;
2456     int newflag = 0;
2457     ulong newlid = 0;
2458     PKT_public_key *pk = m_alloc_clear( sizeof *pk );
2459     ulong pk_lid = 0;
2460     int found_sig = 0;
2461     int found_delrec = 0;
2462     int rc;
2463
2464     delrec.recnum = 0;
2465
2466     /* get the LID of the pubkey of the signature under verification */
2467     rc = get_pubkey( pk, sig->keyid );
2468     if( !rc ) {
2469         if( pk->local_id )
2470             pk_lid = pk->local_id;
2471         else {
2472             rc = tdbio_search_dir_bypk( pk, &rec );
2473             if( !rc )
2474                 pk_lid = rec.recnum;
2475             else if( rc == -1 ) { /* see whether there is a sdir instead */
2476                 u32 akid[2];
2477
2478                 keyid_from_pk( pk, akid );
2479                 rc = tdbio_search_sdir( akid, pk->pubkey_algo, &rec );
2480                 if( !rc )
2481                     pk_lid = rec.recnum;
2482             }
2483         }
2484     }
2485     free_public_key( pk ); pk = NULL;
2486
2487     /* Loop over all signatures just in case one is not correctly
2488      * marked.  If we see the correct signature, set a flag.
2489      * delete duplicate signatures (should not happen but...) */
2490     for( recno = urec->r.uid.siglist; recno; recno = rec.r.sig.next ) {
2491         int i;
2492
2493         read_record( recno, &rec, RECTYPE_SIG );
2494         for(i=0; i < SIGS_PER_RECORD; i++ ) {
2495             TRUSTREC tmp;
2496             if( !rec.r.sig.sig[i].lid ) {
2497                 if( !found_delrec && !delrec.recnum ) {
2498                     delrec = rec;
2499                     delrecidx = i;
2500                     found_delrec=1;
2501                 }
2502                 continue; /* skip deleted sigs */
2503             }
2504             if( rec.r.sig.sig[i].lid == pk_lid ) {
2505                 if( found_sig ) {
2506                     log_info( "sig %08lX.%lu/%02X%02X/%08lX: %s\n",
2507                               (ulong)keyid[1], lid, uidhash[18],
2508                                uidhash[19], (ulong)sig->keyid[1],
2509                              _("Duplicated certificate - deleted") );
2510                     rec.r.sig.sig[i].lid = 0;
2511                     rec.dirty = 1;
2512                     continue;
2513                 }
2514                 found_sig = 1;
2515             }
2516             if( !recheck && !revoke && (rec.r.sig.sig[i].flag & SIGF_CHECKED) )
2517                 continue; /* we already checked this signature */
2518             if( !recheck && (rec.r.sig.sig[i].flag & SIGF_NOPUBKEY) )
2519                 continue; /* we do not have the public key */
2520
2521             read_record( rec.r.sig.sig[i].lid, &tmp, 0 );
2522             if( tmp.rectype == RECTYPE_DIR ) {
2523                 /* In this case we should now be able to check the signature */
2524                 rc = check_key_signature( keyblock, signode, NULL );
2525                 if( !rc ) { /* valid signature */
2526                     if( opt.verbose )
2527                         log_info("sig %08lX.%lu/%02X%02X/%08lX: %s\n",
2528                                 (ulong)keyid[1], lid, uidhash[18],
2529                                 uidhash[19], (ulong)sig->keyid[1],
2530                                 revoke? _("Valid certificate revocation")
2531                                       : _("Good certificate") );
2532                     rec.r.sig.sig[i].flag = SIGF_CHECKED | SIGF_VALID;
2533                     if( revoke )
2534                         rec.r.sig.sig[i].flag |= SIGF_REVOKED;
2535                 }
2536                 else if( rc == G10ERR_NO_PUBKEY ) {
2537                     if( (rec.r.sig.sig[i].flag & SIGF_CHECKED) )
2538                         log_info("sig %08lX.%lu/%02X%02X/%08lX: %s\n",
2539                                   (ulong)keyid[1], lid, uidhash[18],
2540                                  uidhash[19], (ulong)sig->keyid[1],
2541                                  _("Hmmm, public key lost?") );
2542                     rec.r.sig.sig[i].flag = SIGF_NOPUBKEY;
2543                     if( revoke )
2544                         rec.r.sig.sig[i].flag |= SIGF_REVOKED;
2545                 }
2546                 else {
2547                     log_info("sig %08lX.%lu/%02X%02X/%08lX: %s: %s\n",
2548                                 (ulong)keyid[1], lid, uidhash[18],
2549                                 uidhash[19], (ulong)sig->keyid[1],
2550                                 revoke? _("Invalid certificate revocation")
2551                                       : _("Invalid certificate"),
2552                                                     g10_errstr(rc));
2553                     rec.r.sig.sig[i].flag = SIGF_CHECKED;
2554                     if( revoke )
2555                         rec.r.sig.sig[i].flag |= SIGF_REVOKED;
2556                 }
2557                 rec.dirty = 1;
2558             }
2559             else if( tmp.rectype == RECTYPE_SDIR ) {
2560                 /* must check that it is the right one */
2561                 if( tmp.r.sdir.keyid[0] == sig->keyid[0]
2562                     && tmp.r.sdir.keyid[1] == sig->keyid[1]
2563                     && (!tmp.r.sdir.pubkey_algo
2564                          || tmp.r.sdir.pubkey_algo == sig->pubkey_algo )) {
2565                     if( !(rec.r.sig.sig[i].flag & SIGF_NOPUBKEY) )
2566                         log_info(_("uid %08lX.%lu/%02X%02X: "
2567                                 "has shadow dir %lu but is not yet marked.\n"),
2568                                 (ulong)keyid[1], lid,
2569                                 uidhash[18], uidhash[19], tmp.recnum );
2570                     rec.r.sig.sig[i].flag = SIGF_NOPUBKEY;
2571                     if( revoke )
2572                         rec.r.sig.sig[i].flag |= SIGF_REVOKED;
2573                     rec.dirty = 1;
2574                     /* fixme: should we verify that the record is
2575                      * in the hintlist? - This case here should anyway
2576                      * never occur */
2577                 }
2578             }
2579             else {
2580                 log_error(_("sig record %lu[%d] points to wrong record.\n"),
2581                             rec.r.sig.sig[i].lid, i );
2582                 die_invalid_db();
2583             }
2584         }
2585         if( found_delrec && delrec.recnum ) {
2586             delrec = rec;
2587             found_delrec = 0; /* we only want the first one */
2588         }
2589         if( rec.dirty ) {
2590             write_record( &rec );
2591             rec.dirty = 0;
2592         }
2593     }
2594
2595     if( found_sig )
2596         return;
2597
2598     /* at this point, we have verified, that the signature is not in
2599      * our list of signatures.  Add a new record with that signature
2600      * and if the public key is there, check the signature. */
2601
2602     if( !pk_lid ) /* we have already seen that there is no pubkey */
2603         rc = G10ERR_NO_PUBKEY;
2604     else
2605         rc = check_key_signature( keyblock, signode, NULL );
2606
2607     if( !rc ) { /* valid signature */
2608         if( opt.verbose )
2609             log_info("sig %08lX.%lu/%02X%02X/%08lX: %s\n",
2610                           (ulong)keyid[1], lid, uidhash[18],
2611                            uidhash[19], (ulong)sig->keyid[1],
2612                                 revoke? _("Valid certificate revocation")
2613                                       : _("Good certificate") );
2614         newlid = pk_lid;  /* this is the pk of the signature */
2615         newflag = SIGF_CHECKED | SIGF_VALID;
2616         if( revoke )
2617             newflag |= SIGF_REVOKED;
2618     }
2619     else if( rc == G10ERR_NO_PUBKEY ) {
2620         if( opt.verbose > 1 )
2621             log_info("sig %08lX.%lu/%02X%02X/%08lX: %s\n",
2622                      (ulong)keyid[1], lid, uidhash[18],
2623                       uidhash[19], (ulong)sig->keyid[1], g10_errstr(rc) );
2624         newlid = create_shadow_dir( sig, lid );
2625         newflag = SIGF_NOPUBKEY;
2626         if( revoke )
2627             newflag |= SIGF_REVOKED;
2628     }
2629     else {
2630         log_info( "sig %08lX.%lu/%02X%02X/%08lX: %s: %s\n",
2631                     (ulong)keyid[1], lid, uidhash[18], uidhash[19],
2632                               (ulong)sig->keyid[1],
2633                 revoke? _("Invalid certificate revocation")
2634                       : _("Invalid certificate"),
2635                                             g10_errstr(rc));
2636         newlid = create_shadow_dir( sig, lid );
2637         newflag = SIGF_CHECKED;
2638         if( revoke )
2639             newflag |= SIGF_REVOKED;
2640     }
2641
2642     if( delrec.recnum ) { /* we can reuse a deleted/unused slot */
2643         delrec.r.sig.sig[delrecidx].lid = newlid;
2644         delrec.r.sig.sig[delrecidx].flag= newflag;
2645         write_record( &delrec );
2646     }
2647     else { /* must insert a new sig record */
2648         TRUSTREC tmp;
2649
2650         memset( &tmp, 0, sizeof tmp );
2651         tmp.recnum = tdbio_new_recnum();
2652         tmp.rectype = RECTYPE_SIG;
2653         tmp.r.sig.lid = lid;
2654         tmp.r.sig.next = urec->r.uid.siglist;
2655         tmp.r.sig.sig[0].lid = newlid;
2656         tmp.r.sig.sig[0].flag= newflag;
2657         write_record( &tmp );
2658         urec->r.uid.siglist = tmp.recnum;
2659         urec->dirty = 1;
2660     }
2661 }
2662
2663
2664 /****************
2665  * Update all the info from the public keyblock.
2666  * The key must already exist in the keydb.
2667  * This function is responsible for checking the signatures in cases
2668  * where the public key is already available.  If we do not have the public
2669  * key, the check is done by some special code in insert_trust_record().
2670  */
2671 int
2672 update_trust_record( KBNODE keyblock, int recheck, int *modified )
2673 {
2674     PKT_public_key *primary_pk;
2675     KBNODE node;
2676     TRUSTREC drec;
2677     TRUSTREC krec;
2678     TRUSTREC urec;
2679     TRUSTREC prec;
2680     TRUSTREC helprec;
2681     int rc = 0;
2682     u32 keyid[2]; /* keyid of primary key */
2683     ulong recno, lastrecno;
2684     RECNO_LIST recno_list = NULL; /* list of verified records */
2685     /* fixme: replace recno_list by a lookup on node->recno */
2686
2687     if( modified )
2688         *modified = 0;
2689
2690     node = find_kbnode( keyblock, PKT_PUBLIC_KEY );
2691     primary_pk = node->pkt->pkt.public_key;
2692     rc = get_dir_record( primary_pk, &drec );
2693     if( rc )
2694         return rc;
2695     if( !primary_pk->local_id )
2696         primary_pk->local_id = drec.recnum;
2697
2698     keyid_from_pk( primary_pk, keyid );
2699
2700     /* fixme: check that the keyblock has a valid structure */
2701
2702     rc = tdbio_begin_transaction();
2703     if( rc )
2704         return rc;
2705
2706     /* update the keys */
2707     for( node=keyblock; node; node = node->next ) {
2708         if( node->pkt->pkttype == PKT_PUBLIC_KEY
2709             || node->pkt->pkttype == PKT_PUBLIC_SUBKEY )
2710             upd_key_record( keyblock, node, keyid,
2711                             &drec, &recno_list, recheck );
2712     }
2713     /* update the user IDs */
2714     for( node=keyblock; node; node = node->next ) {
2715         if( node->pkt->pkttype == PKT_USER_ID )
2716             upd_uid_record( keyblock, node, keyid,
2717                             &drec, &recno_list, recheck );
2718     }
2719
2720     /* delete keyrecords from the trustdb which are not anymore used */
2721     /* should we really do this, or is it better to keep them and */
2722     /* mark as unused? */
2723     lastrecno = 0;
2724     for( recno=drec.r.dir.keylist; recno; recno = krec.r.key.next ) {
2725         read_record( recno, &krec, RECTYPE_KEY );
2726         if( !qry_recno_list( recno_list, recno, RECTYPE_KEY ) ) {
2727             /* delete this one */
2728             if( !lastrecno ) {
2729                 drec.r.dir.keylist = krec.r.key.next;
2730                 drec.dirty = 1;
2731             }
2732             else {
2733                 read_record( lastrecno, &helprec, RECTYPE_KEY );
2734                 helprec.r.key.next = krec.r.key.next;
2735                 write_record( &helprec );
2736             }
2737             delete_record( recno );
2738         }
2739         else
2740             lastrecno = recno;
2741     }
2742     /* delete uid records and sig and their pref records from the
2743      * trustdb which are not anymore used */
2744     lastrecno = 0;
2745     for( recno=drec.r.dir.uidlist; recno; recno = urec.r.uid.next ) {
2746         read_record( recno, &urec, RECTYPE_UID );
2747         if( !qry_recno_list( recno_list, recno, RECTYPE_UID ) ) {
2748             ulong r2;
2749             /* delete this one */
2750             if( !lastrecno ) {
2751                 drec.r.dir.uidlist = urec.r.uid.next;
2752                 drec.dirty = 1;
2753             }
2754             else {
2755                 read_record( lastrecno, &helprec, RECTYPE_UID );
2756                 helprec.r.uid.next = urec.r.uid.next;
2757                 write_record( &helprec );
2758             }
2759             for(r2=urec.r.uid.prefrec ; r2; r2 = prec.r.pref.next ) {
2760                 read_record( r2, &prec, RECTYPE_PREF );
2761                 delete_record( r2 );
2762             }
2763             for(r2=urec.r.uid.siglist ; r2; r2 = helprec.r.sig.next ) {
2764                 read_record( r2, &helprec, RECTYPE_SIG );
2765                 delete_record( r2 );
2766             }
2767             delete_record( recno );
2768         }
2769         else
2770             lastrecno = recno;
2771     }
2772
2773
2774
2775     if( rc )
2776         rc = tdbio_cancel_transaction();
2777     else {
2778         drec.r.dir.dirflags |= DIRF_CHECKED;
2779         drec.r.dir.dirflags &= ~DIRF_VALVALID;
2780         write_record( &drec );
2781         if( modified && tdbio_is_dirty() )
2782             *modified = 1;
2783         rc = tdbio_end_transaction();
2784     }
2785     rel_recno_list( &recno_list );
2786     return rc;
2787 }
2788
2789
2790 /****************
2791  * Insert a trust record into the TrustDB
2792  * This function assumes that the record does not yet exist.
2793  */
2794 int
2795 insert_trust_record( PKT_public_key *pk )
2796 {
2797     TRUSTREC dirrec;
2798     TRUSTREC shadow;
2799     KBNODE keyblock = NULL;
2800     KBNODE node;
2801     byte fingerprint[MAX_FINGERPRINT_LEN];
2802     size_t fingerlen;
2803     int rc = 0;
2804     ulong hintlist = 0;
2805
2806     if( pk->local_id )
2807         log_bug("pk->local_id=%lu\n", pk->local_id );
2808
2809     fingerprint_from_pk( pk, fingerprint, &fingerlen );
2810
2811     /* fixme: assert that we do not have this record.
2812      * we can do this by searching for the primary keyid
2813      *
2814      * fixme: If there is no such key we should look whether one
2815      * of the subkeys has been used to sign another key and in this case
2816      * we got the key anyway.  Because a secondary key can't be used
2817      * without a primary key (it is needed to bind the secondary one
2818      * to the primary one which has the user ids etc.)
2819      */
2820
2821     /* get the keyblock which has the key */
2822     rc = get_keyblock_byfprint( &keyblock, fingerprint, fingerlen );
2823     if( rc ) { /* that should never happen */
2824         log_error( _("insert_trust_record: keyblock not found: %s\n"),
2825                                                           g10_errstr(rc) );
2826         goto leave;
2827     }
2828
2829     /* check that we used the primary key (we are little bit paranoid) */
2830     {   PKT_public_key *a_pk;
2831         u32 akid[2], bkid[2];
2832
2833         node = find_kbnode( keyblock, PKT_PUBLIC_KEY );
2834         a_pk = node->pkt->pkt.public_key;
2835
2836         /* we can't use cmp_public_keys here because some parts (expiredate)
2837          * might not be set in pk <--- but why (fixme) */
2838         keyid_from_pk( a_pk, akid );
2839         keyid_from_pk( pk, bkid );
2840
2841         if( akid[0] != bkid[0] || akid[1] != bkid[1] ) {
2842             log_error(_("did not use primary key for insert_trust_record()\n"));
2843             rc = G10ERR_GENERAL;
2844             goto leave;
2845         }
2846     }
2847
2848     /* We have to look for a shadow dir record which must be reused
2849      * as the dir record. And: check all signatures which are listed
2850      * in the hintlist of the shadow dir record.
2851      */
2852     rc = tdbio_search_sdir( pk->keyid, pk->pubkey_algo, &shadow );
2853     if( rc && rc != -1 ) {
2854         log_error(_("tdbio_search_dir failed: %s\n"), g10_errstr(rc));
2855         die_invalid_db();
2856     }
2857     memset( &dirrec, 0, sizeof dirrec );
2858     dirrec.rectype = RECTYPE_DIR;
2859     if( !rc ) {
2860         /* hey, great: this key has already signed other keys
2861          * convert this to a real directory entry */
2862         hintlist = shadow.r.sdir.hintlist;
2863         dirrec.recnum = shadow.recnum;
2864     }
2865     else {
2866         dirrec.recnum = tdbio_new_recnum();
2867     }
2868     dirrec.r.dir.lid = dirrec.recnum;
2869     write_record( &dirrec );
2870
2871     /* store the LID */
2872     pk->local_id = dirrec.r.dir.lid;
2873     for( node=keyblock; node; node = node->next ) {
2874         if( node->pkt->pkttype == PKT_PUBLIC_KEY
2875             || node->pkt->pkttype == PKT_PUBLIC_SUBKEY ) {
2876             PKT_public_key *pk = node->pkt->pkt.public_key;
2877             pk->local_id = dirrec.r.dir.lid;
2878         }
2879         else if( node->pkt->pkttype == PKT_SIGNATURE ) {
2880             PKT_signature *sig = node->pkt->pkt.signature;
2881             sig->local_id = dirrec.r.dir.lid;
2882         }
2883     }
2884
2885     /* and put all the other stuff into the keydb */
2886     rc = update_trust_record( keyblock, 0, NULL );
2887     if( !rc )
2888         process_hintlist( hintlist, dirrec.r.dir.lid );
2889
2890   leave:
2891     if( rc && hintlist )
2892         ; /* fixme: the hintlist is not anymore anchored */
2893     release_kbnode( keyblock );
2894     do_sync();
2895     return rc;
2896 }
2897
2898
2899 int
2900 update_ownertrust( ulong lid, unsigned new_trust )
2901 {
2902     TRUSTREC rec;
2903
2904     read_record( lid, &rec, RECTYPE_DIR );
2905     rec.r.dir.ownertrust = new_trust;
2906     write_record( &rec );
2907     do_sync();
2908     return 0;
2909 }
2910
2911