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