1a8e74df1eacd47d10a038c11cfdfb698d2d1529
[gnupg.git] / g10 / trustdb.c
1 /* trustdb.c
2  * Copyright (C) 1998, 1999, 2000, 2001, 2002 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 <assert.h>
26
27 #ifndef DISABLE_REGEX
28 #include <sys/types.h>
29 #ifdef USE_GNU_REGEX
30 #include "_regex.h"
31 #else
32 #include <regex.h>
33 #endif
34 #endif /* !DISABLE_REGEX */
35
36 #include "errors.h"
37 #include "iobuf.h"
38 #include "keydb.h"
39 #include "memory.h"
40 #include "util.h"
41 #include "options.h"
42 #include "packet.h"
43 #include "main.h"
44 #include "i18n.h"
45 #include "tdbio.h"
46 #include "trustdb.h"
47
48
49 /*
50  * A structure to store key identification as well as some stuff needed
51  * for validation 
52  */
53 struct key_item {
54   struct key_item *next;
55   unsigned int ownertrust,min_ownertrust;
56   byte trust_depth;
57   byte trust_value;
58   char *trust_regexp;
59   u32 kid[2];
60 };
61
62
63 typedef struct key_item **KeyHashTable; /* see new_key_hash_table() */
64
65 /*
66  * Structure to keep track of keys, this is used as an array wherre
67  * the item right after the last one has a keyblock set to NULL. 
68  * Maybe we can drop this thing and replace it by key_item
69  */
70 struct key_array {
71   KBNODE keyblock;
72 };
73
74
75 /* control information for the trust DB */
76 static struct {
77     int init;
78     int level;
79     char *dbname;
80 } trustdb_args;
81
82 /* some globals */
83 static struct key_item *user_utk_list; /* temp. used to store --trusted-keys */
84 static struct key_item *utk_list;      /* all ultimately trusted keys */
85
86 static int pending_check_trustdb;
87
88 static int validate_keys (int interactive);
89
90 \f
91 /**********************************************
92  ************* some helpers *******************
93  **********************************************/
94
95 static struct key_item *
96 new_key_item (void)
97 {
98   struct key_item *k;
99   
100   k = m_alloc_clear (sizeof *k);
101   return k;
102 }
103
104 static void
105 release_key_items (struct key_item *k)
106 {
107   struct key_item *k2;
108
109   for (; k; k = k2)
110     {
111       k2 = k->next;
112       m_free (k->trust_regexp);
113       m_free (k);
114     }
115 }
116
117 /*
118  * For fast keylook up we need a hash table.  Each byte of a KeyIDs
119  * should be distributed equally over the 256 possible values (except
120  * for v3 keyIDs but we consider them as not important here). So we
121  * can just use 10 bits to index a table of 1024 key items. 
122  * Possible optimization: Don not use key_items but other hash_table when the
123  * duplicates lists gets too large. 
124  */
125 static KeyHashTable 
126 new_key_hash_table (void)
127 {
128   struct key_item **tbl;
129
130   tbl = m_alloc_clear (1024 * sizeof *tbl);
131   return tbl;
132 }
133
134 static void
135 release_key_hash_table (KeyHashTable tbl)
136 {
137   int i;
138
139   if (!tbl)
140     return;
141   for (i=0; i < 1024; i++)
142     release_key_items (tbl[i]);
143   m_free (tbl);
144 }
145
146 /* 
147  * Returns: True if the keyID is in the given hash table
148  */
149 static int
150 test_key_hash_table (KeyHashTable tbl, u32 *kid)
151 {
152   struct key_item *k;
153
154   for (k = tbl[(kid[1] & 0x03ff)]; k; k = k->next)
155     if (k->kid[0] == kid[0] && k->kid[1] == kid[1])
156       return 1;
157   return 0;
158 }
159
160 /*
161  * Add a new key to the hash table.  The key is identified by its key ID.
162  */
163 static void
164 add_key_hash_table (KeyHashTable tbl, u32 *kid)
165 {
166   struct key_item *k, *kk;
167
168   for (k = tbl[(kid[1] & 0x03ff)]; k; k = k->next)
169     if (k->kid[0] == kid[0] && k->kid[1] == kid[1])
170       return; /* already in table */
171   
172   kk = new_key_item ();
173   kk->kid[0] = kid[0];
174   kk->kid[1] = kid[1];
175   kk->next = tbl[(kid[1] & 0x03ff)];
176   tbl[(kid[1] & 0x03ff)] = kk;
177 }
178
179 /*
180  * Release a key_array
181  */
182 static void
183 release_key_array ( struct key_array *keys )
184 {
185     struct key_array *k;
186
187     if (keys) {
188         for (k=keys; k->keyblock; k++)
189             release_kbnode (k->keyblock);
190         m_free (keys);
191     }
192 }
193
194 \f
195 /*********************************************
196  **********  Initialization  *****************
197  *********************************************/
198
199
200
201 /*
202  * Used to register extra ultimately trusted keys - this has to be done
203  * before initializing the validation module.
204  * FIXME: Should be replaced by a function to add those keys to the trustdb.
205  */
206 void
207 register_trusted_key( const char *string )
208 {
209   KEYDB_SEARCH_DESC desc;
210   struct key_item *k;
211
212   if (classify_user_id (string, &desc) != KEYDB_SEARCH_MODE_LONG_KID ) {
213     log_error(_("`%s' is not a valid long keyID\n"), string );
214     return;
215   }
216
217   k = new_key_item ();
218   k->kid[0] = desc.u.kid[0];
219   k->kid[1] = desc.u.kid[1];
220   k->next = user_utk_list;
221   user_utk_list = k;
222 }
223
224 /*
225  * Helper to add a key to the global list of ultimately trusted keys.
226  * Retruns: true = inserted, false = already in in list.
227  */
228 static int
229 add_utk (u32 *kid)
230 {
231   struct key_item *k;
232
233   for (k = utk_list; k; k = k->next) 
234     {
235       if (k->kid[0] == kid[0] && k->kid[1] == kid[1])
236         {
237           return 0;
238         }
239     }
240
241   k = new_key_item ();
242   k->kid[0] = kid[0];
243   k->kid[1] = kid[1];
244   k->ownertrust = TRUST_ULTIMATE;
245   k->next = utk_list;
246   utk_list = k;
247   if( opt.verbose > 1 )
248     log_info(_("key %08lX: accepted as trusted key\n"), (ulong)kid[1]);
249   return 1;
250 }
251
252
253 /****************
254  * Verify that all our secret keys are usable and put them into the utk_list.
255  */
256 static void
257 verify_own_keys(void)
258 {
259   TRUSTREC rec;
260   ulong recnum;
261   int rc;
262   struct key_item *k;
263
264   if (utk_list)
265     return;
266
267   /* scan the trustdb to find all ultimately trusted keys */
268   for (recnum=1; !tdbio_read_record (recnum, &rec, 0); recnum++ ) 
269     {
270       if ( rec.rectype == RECTYPE_TRUST 
271            && (rec.r.trust.ownertrust & TRUST_MASK) == TRUST_ULTIMATE)
272         {
273             byte *fpr = rec.r.trust.fingerprint;
274             int fprlen;
275             u32 kid[2];
276             
277             /* Problem: We do only use fingerprints in the trustdb but
278              * we need the keyID here to indetify the key; we can only
279              * use that ugly hack to distinguish between 16 and 20
280              * butes fpr - it does not work always so we better change
281              * the whole validation code to only work with
282              * fingerprints */
283             fprlen = (!fpr[16] && !fpr[17] && !fpr[18] && !fpr[19])? 16:20;
284             keyid_from_fingerprint (fpr, fprlen, kid);
285             if (!add_utk (kid))
286                 log_info(_("key %08lX occurs more than once in the trustdb\n"),
287                             (ulong)kid[1]);
288         }
289     }
290   
291   /* the --trusted-key option is again deprecated; however we automagically
292    * add those keys to the trustdb */
293   for (k = user_utk_list; k; k = k->next) 
294     {
295       if ( add_utk (k->kid) ) 
296         { /* not yet in trustDB as ultimately trusted */
297           PKT_public_key pk;
298
299           memset (&pk, 0, sizeof pk);
300           rc = get_pubkey (&pk, k->kid);
301           if (rc) {
302             log_info(_("key %08lX: no public key for trusted key - skipped\n"),
303                      (ulong)k->kid[1] );
304           }
305           else {
306             update_ownertrust (&pk,
307                                ((get_ownertrust (&pk) & ~TRUST_MASK)
308                                 | TRUST_ULTIMATE ));
309             release_public_key_parts (&pk);
310           }
311           log_info (_("key %08lX marked as ultimately trusted\n"),
312                     (ulong)k->kid[1]);
313         }
314     }
315
316
317   /* release the helper table table */
318   release_key_items (user_utk_list);
319   user_utk_list = NULL;
320   return;
321 }
322
323 \f
324 /*********************************************
325  *********** TrustDB stuff *******************
326  *********************************************/
327
328 /*
329  * Read a record but die if it does not exist
330  */
331 static void
332 read_record (ulong recno, TRUSTREC *rec, int rectype )
333 {
334   int rc = tdbio_read_record (recno, rec, rectype);
335   if (rc)
336     {
337       log_error(_("trust record %lu, req type %d: read failed: %s\n"),
338                 recno, rec->rectype, g10_errstr(rc) );
339       tdbio_invalid();
340     }
341   if (rectype != rec->rectype)
342     {
343       log_error(_("trust record %lu is not of requested type %d\n"),
344                 rec->recnum, rectype);
345       tdbio_invalid();
346     }
347 }
348
349 /*
350  * Write a record and die on error
351  */
352 static void
353 write_record (TRUSTREC *rec)
354 {
355   int rc = tdbio_write_record (rec);
356   if (rc)
357     {
358       log_error(_("trust record %lu, type %d: write failed: %s\n"),
359                             rec->recnum, rec->rectype, g10_errstr(rc) );
360       tdbio_invalid();
361     }
362 }
363
364 /*
365  * sync the TrustDb and die on error
366  */
367 static void
368 do_sync(void)
369 {
370     int rc = tdbio_sync ();
371     if(rc)
372       {
373         log_error (_("trustdb: sync failed: %s\n"), g10_errstr(rc) );
374         g10_exit(2);
375       }
376 }
377
378
379 /****************
380  * Perform some checks over the trustdb
381  *  level 0: only open the db
382  *        1: used for initial program startup
383  */
384 int
385 setup_trustdb( int level, const char *dbname )
386 {
387     /* just store the args */
388     if( trustdb_args.init )
389         return 0;
390     trustdb_args.level = level;
391     trustdb_args.dbname = dbname? m_strdup(dbname): NULL;
392     return 0;
393 }
394
395 void
396 init_trustdb()
397 {
398   int rc=0;
399   int level = trustdb_args.level;
400   const char* dbname = trustdb_args.dbname;
401
402   if( trustdb_args.init )
403     return;
404
405   trustdb_args.init = 1;
406
407   if ( !level || level==1)
408     {
409       rc = tdbio_set_dbname( dbname, !!level );
410       if( !rc )
411         {
412           if( !level )
413             return;
414           
415           /* verify that our own keys are in the trustDB
416            * or move them to the trustdb. */
417           verify_own_keys();
418           
419           /* should we check whether there is no other ultimately trusted
420            * key in the database? */
421         }
422     }
423   else
424     BUG();
425   if( rc )
426     log_fatal("can't init trustdb: %s\n", g10_errstr(rc) );
427 }
428
429
430
431 \f
432 /***********************************************
433  *************  Print helpers   ****************
434  ***********************************************/
435
436 /****************
437  * This function returns a letter for a trustvalue  Trust flags
438  * are ignore.
439  */
440 int
441 trust_letter (unsigned int value)
442 {
443   switch( (value & TRUST_MASK) ) 
444     {
445     case TRUST_UNKNOWN:   return '-';
446     case TRUST_EXPIRED:   return 'e';
447     case TRUST_UNDEFINED: return 'q';
448     case TRUST_NEVER:     return 'n';
449     case TRUST_MARGINAL:  return 'm';
450     case TRUST_FULLY:     return 'f';
451     case TRUST_ULTIMATE:  return 'u';
452     default:              return 0;
453     }
454 }
455
456 /* The strings here are similar to those in
457    pkclist.c:do_edit_ownertrust() */
458 const char *
459 trust_string (unsigned int value)
460 {
461   switch( (value & TRUST_MASK) ) 
462     {
463     case TRUST_UNKNOWN:   return _("unknown trust");
464     case TRUST_EXPIRED:   return _("expired");
465     case TRUST_UNDEFINED: return _("undefined trust");
466     case TRUST_NEVER:     return _("do NOT trust");
467     case TRUST_MARGINAL:  return _("marginal trust");
468     case TRUST_FULLY:     return _("full trust");
469     case TRUST_ULTIMATE:  return _("ultimate trust");
470     default:              return "err";
471     }
472 }
473
474 /****************
475  * Recreate the WoT but do not ask for new ownertrusts.  Special
476  * feature: In batch mode and without a forced yes, this is only done
477  * when a check is due.  This can be used to run the check from a crontab
478  */
479 void
480 check_trustdb ()
481 {
482   init_trustdb();
483   if (opt.batch && !opt.answer_yes)
484     {
485       ulong scheduled;
486
487       scheduled = tdbio_read_nextcheck ();
488       if (!scheduled)
489         {
490           log_info (_("no need for a trustdb check\n"));
491           return;
492         }
493
494       if (scheduled > make_timestamp ())
495         {
496           log_info (_("next trustdb check due at %s\n"),
497                     strtimestamp (scheduled));
498           return;
499         }
500     }
501
502   validate_keys (0);
503 }
504
505
506 /*
507  * Recreate the WoT. 
508  */
509 void
510 update_trustdb()
511 {
512   init_trustdb();
513   validate_keys (1);
514 }
515
516 void
517 revalidation_mark (void)
518 {
519   init_trustdb();
520   /* we simply set the time for the next check to 1 (far back in 1970)
521    * so that a --update-trustdb will be scheduled */
522   if (tdbio_write_nextcheck (1))
523       do_sync ();
524   pending_check_trustdb = 1;
525 }
526
527 \f
528 /***********************************************
529  ***********  Ownertrust et al. ****************
530  ***********************************************/
531
532 static int 
533 read_trust_record (PKT_public_key *pk, TRUSTREC *rec)
534 {
535   int rc;
536   
537   init_trustdb();
538   rc = tdbio_search_trust_bypk (pk, rec);
539   if (rc == -1)
540     return -1; /* no record yet */
541   if (rc) 
542     {
543       log_error ("trustdb: searching trust record failed: %s\n",
544                  g10_errstr (rc));
545       return rc; 
546     }
547       
548   if (rec->rectype != RECTYPE_TRUST)
549     {
550       log_error ("trustdb: record %lu is not a trust record\n",
551                  rec->recnum);
552       return G10ERR_TRUSTDB; 
553     }      
554   
555   return 0;
556 }
557
558 /****************
559  * Return the assigned ownertrust value for the given public key.
560  * The key should be the primary key.
561  */
562 unsigned int 
563 get_ownertrust ( PKT_public_key *pk)
564 {
565   TRUSTREC rec;
566   int rc;
567   
568   rc = read_trust_record (pk, &rec);
569   if (rc == -1)
570     return TRUST_UNKNOWN; /* no record yet */
571   if (rc) 
572     {
573       tdbio_invalid ();
574       return rc; /* actually never reached */
575     }
576
577   return rec.r.trust.ownertrust;
578 }
579
580 unsigned int 
581 get_min_ownertrust (PKT_public_key *pk)
582 {
583   TRUSTREC rec;
584   int rc;
585   
586   rc = read_trust_record (pk, &rec);
587   if (rc == -1)
588     return TRUST_UNKNOWN; /* no record yet */
589   if (rc) 
590     {
591       tdbio_invalid ();
592       return rc; /* actually never reached */
593     }
594
595   return rec.r.trust.min_ownertrust;
596 }
597
598 /*
599  * Same as get_ownertrust but return a trust letter instead of an value.
600  */
601 int
602 get_ownertrust_info (PKT_public_key *pk)
603 {
604     unsigned int otrust,otrust_min;
605     int c;
606
607     otrust = get_ownertrust (pk);
608     otrust_min = get_min_ownertrust (pk);
609     if(otrust<otrust_min)
610       {
611         /* If the trust that the user has set is less than the trust
612            that was calculated from a trust signature chain, use the
613            higher of the two.  We do this here and not in
614            get_ownertrust since the underlying ownertrust should not
615            really be set - just the appearance of the ownertrust. */
616
617         otrust=otrust_min;
618       }
619
620     c = trust_letter( (otrust & TRUST_MASK) );
621     if( !c )
622         c = '?';
623     return c;
624 }
625
626 /*
627  * Set the trust value of the given public key to the new value.
628  * The key should be a primary one.
629  */
630 void
631 update_ownertrust (PKT_public_key *pk, unsigned int new_trust )
632 {
633   TRUSTREC rec;
634   int rc;
635   
636   rc = read_trust_record (pk, &rec);
637   if (!rc)
638     {
639       if (DBG_TRUST)
640         log_debug ("update ownertrust from %u to %u\n",
641                    (unsigned int)rec.r.trust.ownertrust, new_trust );
642       if (rec.r.trust.ownertrust != new_trust)
643         {
644           rec.r.trust.ownertrust = new_trust;
645           write_record( &rec );
646           revalidation_mark ();
647           do_sync ();
648         }
649     }
650   else if (rc == -1)
651     { /* no record yet - create a new one */
652       size_t dummy;
653
654       if (DBG_TRUST)
655         log_debug ("insert ownertrust %u\n", new_trust );
656
657       memset (&rec, 0, sizeof rec);
658       rec.recnum = tdbio_new_recnum ();
659       rec.rectype = RECTYPE_TRUST;
660       fingerprint_from_pk (pk, rec.r.trust.fingerprint, &dummy);
661       rec.r.trust.ownertrust = new_trust;
662       write_record (&rec);
663       revalidation_mark ();
664       do_sync ();
665       rc = 0;
666     }
667   else 
668     {
669       tdbio_invalid ();
670     }
671 }
672
673 static void
674 update_min_ownertrust (u32 *kid, unsigned int new_trust )
675 {
676   PKT_public_key *pk;
677   TRUSTREC rec;
678   int rc;
679
680   pk = m_alloc_clear (sizeof *pk);
681   rc = get_pubkey (pk, kid);
682   if (rc)
683     {
684       log_error (_("public key %08lX not found: %s\n"),
685                  (ulong)kid[1], g10_errstr(rc) );
686       return;
687     }
688
689   rc = read_trust_record (pk, &rec);
690   if (!rc)
691     {
692       if (DBG_TRUST)
693         log_debug ("key %08lX: update min_ownertrust from %u to %u\n",
694                    (ulong)kid[1],(unsigned int)rec.r.trust.min_ownertrust,
695                    new_trust );
696       if (rec.r.trust.min_ownertrust != new_trust)
697         {
698           rec.r.trust.min_ownertrust = new_trust;
699           write_record( &rec );
700           revalidation_mark ();
701           do_sync ();
702         }
703     }
704   else if (rc == -1)
705     { /* no record yet - create a new one */
706       size_t dummy;
707
708       if (DBG_TRUST)
709         log_debug ("insert min_ownertrust %u\n", new_trust );
710
711       memset (&rec, 0, sizeof rec);
712       rec.recnum = tdbio_new_recnum ();
713       rec.rectype = RECTYPE_TRUST;
714       fingerprint_from_pk (pk, rec.r.trust.fingerprint, &dummy);
715       rec.r.trust.min_ownertrust = new_trust;
716       write_record (&rec);
717       revalidation_mark ();
718       do_sync ();
719       rc = 0;
720     }
721   else 
722     {
723       tdbio_invalid ();
724     }
725 }
726
727 /* Clear the ownertrust and min_ownertrust values.  Return true if a
728    change actually happened. */
729 int
730 clear_ownertrusts (PKT_public_key *pk)
731 {
732   TRUSTREC rec;
733   int rc;
734   
735   rc = read_trust_record (pk, &rec);
736   if (!rc)
737     {
738       if (DBG_TRUST)
739         {
740           log_debug ("clearing ownertrust (old value %u)\n",
741                      (unsigned int)rec.r.trust.ownertrust);
742           log_debug ("clearing min_ownertrust (old value %u)\n",
743                      (unsigned int)rec.r.trust.min_ownertrust);
744         }
745       if (rec.r.trust.ownertrust || rec.r.trust.min_ownertrust)
746         {
747           rec.r.trust.ownertrust = 0;
748           rec.r.trust.min_ownertrust = 0;
749           write_record( &rec );
750           revalidation_mark ();
751           do_sync ();
752           return 1;
753         }
754     }
755   else if (rc != -1)
756     {
757       tdbio_invalid ();
758     }
759   return 0;
760 }
761
762 /* 
763  * Note: Caller has to do a sync 
764  */
765 static void
766 update_validity (PKT_public_key *pk, const byte *namehash,
767                  int depth, int validity)
768 {
769   TRUSTREC trec, vrec;
770   int rc;
771   ulong recno;
772   
773   rc = read_trust_record (pk, &trec);
774   if (rc && rc != -1)
775     {
776       tdbio_invalid ();
777       return;
778     }
779   if (rc == -1) /* no record yet - create a new one */
780     { 
781       size_t dummy;
782
783       rc = 0;
784       memset (&trec, 0, sizeof trec);
785       trec.recnum = tdbio_new_recnum ();
786       trec.rectype = RECTYPE_TRUST;
787       fingerprint_from_pk (pk, trec.r.trust.fingerprint, &dummy);
788       trec.r.trust.ownertrust = 0;
789       }
790
791   /* locate an existing one */
792   recno = trec.r.trust.validlist;
793   while (recno)
794     {
795       read_record (recno, &vrec, RECTYPE_VALID);
796       if ( !memcmp (vrec.r.valid.namehash, namehash, 20) )
797         break;
798       recno = vrec.r.valid.next;
799     }
800
801   if (!recno) /* insert a new validity record */
802     {
803       memset (&vrec, 0, sizeof vrec);
804       vrec.recnum = tdbio_new_recnum ();
805       vrec.rectype = RECTYPE_VALID;
806       memcpy (vrec.r.valid.namehash, namehash, 20);
807       vrec.r.valid.next = trec.r.trust.validlist;
808     }
809   vrec.r.valid.validity = validity;
810   write_record (&vrec);
811   trec.r.trust.depth = depth;
812   trec.r.trust.validlist = vrec.recnum;
813   write_record (&trec);
814 }
815
816
817 /* reset validity for all user IDs.  Caller must sync. */
818 static int
819 clear_validity (PKT_public_key *pk)
820 {
821   TRUSTREC trec, vrec;
822   int rc;
823   ulong recno;
824   int any = 0;
825   
826   rc = read_trust_record (pk, &trec);
827   if (rc && rc != -1)
828     {
829       tdbio_invalid ();
830       return 0;
831     }
832   if (rc == -1) /* no record yet - no need to clear it then ;-) */
833     return 0;
834
835   /* Clear minimum ownertrust, if any */
836   if(trec.r.trust.min_ownertrust)
837     {
838       trec.r.trust.min_ownertrust=0;
839       write_record(&trec);
840     }
841
842   /* reset validity for all user IDs */
843   recno = trec.r.trust.validlist;
844   while (recno)
845     {
846       read_record (recno, &vrec, RECTYPE_VALID);
847       if ((vrec.r.valid.validity & TRUST_MASK))
848         {
849           vrec.r.valid.validity &= ~TRUST_MASK;
850           write_record (&vrec);
851           any = 1;
852         }
853       recno = vrec.r.valid.next;
854     }
855
856   return any;
857 }
858
859 /***********************************************
860  *********  Query trustdb values  **************
861  ***********************************************/
862
863 /*
864  * Return the validity information for PK.  If the namehash is not
865  * NULL, the validity of the corresponsing user ID is returned,
866  * otherwise, a reasonable value for the entire key is returned. 
867  */
868 unsigned int
869 get_validity (PKT_public_key *pk, const byte *namehash)
870 {
871   static int did_nextcheck;
872   TRUSTREC trec, vrec;
873   int rc;
874   ulong recno;
875   unsigned int validity;
876   u32 kid[2];
877   PKT_public_key *main_pk;
878   
879   init_trustdb ();
880   if (!did_nextcheck)
881     {
882       ulong scheduled;
883
884       did_nextcheck = 1;
885       scheduled = tdbio_read_nextcheck ();
886       if (scheduled && scheduled <= make_timestamp ())
887         {
888           if (opt.no_auto_check_trustdb) 
889             {
890               pending_check_trustdb = 1;
891               log_info ("please do a --check-trustdb\n");
892             }
893           else
894             {
895               log_info (_("checking the trustdb\n"));
896               validate_keys (0);
897             }
898         }
899     }
900
901   keyid_from_pk (pk, kid);
902   if (pk->main_keyid[0] != kid[0] || pk->main_keyid[1] != kid[1])
903     { /* this is a subkey - get the mainkey */
904       main_pk = m_alloc_clear (sizeof *main_pk);
905       rc = get_pubkey (main_pk, pk->main_keyid);
906       if (rc)
907         {
908           log_error ("error getting main key %08lX of subkey %08lX: %s\n",
909                      (ulong)pk->main_keyid[1], (ulong)kid[1], g10_errstr(rc));
910           validity = TRUST_UNKNOWN; 
911           goto leave;
912         }
913     }
914   else
915     main_pk = pk;
916
917   rc = read_trust_record (main_pk, &trec);
918   if (rc && rc != -1)
919     {
920       tdbio_invalid ();
921       return 0;
922     }
923   if (rc == -1) /* no record found */
924     {
925       validity = TRUST_UNKNOWN; 
926       goto leave;
927     }
928
929   /* loop over all user IDs */
930   recno = trec.r.trust.validlist;
931   validity = 0;
932   while (recno)
933     {
934       read_record (recno, &vrec, RECTYPE_VALID);
935       if ( validity < (vrec.r.valid.validity & TRUST_MASK) )
936         validity = (vrec.r.valid.validity & TRUST_MASK);
937       if ( namehash && !memcmp (vrec.r.valid.namehash, namehash, 20) )
938         break;
939       recno = vrec.r.valid.next;
940     }
941   
942   if (recno) /* okay, use the user ID associated one */
943     validity = (vrec.r.valid.validity & TRUST_MASK);
944
945   if ( (trec.r.trust.ownertrust & TRUST_FLAG_DISABLED) )
946     validity |= TRUST_FLAG_DISABLED;
947
948  leave:
949   /* set some flags direct from the key */
950   if (main_pk->is_revoked)
951     validity |= TRUST_FLAG_REVOKED;
952   if (main_pk != pk && pk->is_revoked)
953     validity |= TRUST_FLAG_SUB_REVOKED;
954   /* Note: expiration is a trust value and not a flag - don't know why
955    * I initially designed it that way */
956   if (main_pk->has_expired || pk->has_expired)
957     validity = (validity & ~TRUST_MASK) | TRUST_EXPIRED;
958   
959   if (pending_check_trustdb)
960     validity |= TRUST_FLAG_PENDING_CHECK;
961
962   if (main_pk != pk)
963     free_public_key (main_pk);
964   return validity;
965 }
966
967
968 int
969 get_validity_info (PKT_public_key *pk, const byte *namehash)
970 {
971     int trustlevel;
972     int c;
973
974     trustlevel = get_validity (pk, namehash);
975     if( trustlevel & TRUST_FLAG_DISABLED )
976         return 'd';
977     if( trustlevel & TRUST_FLAG_REVOKED )
978         return 'r';
979     c = trust_letter ( (trustlevel & TRUST_MASK) );
980     if( !c )
981         c = '?';
982     return c;
983 }
984
985
986
987
988 void
989 list_trust_path( const char *username )
990 {
991 }
992
993
994
995
996 /****************
997  * Enumerate all keys, which are needed to build all trust paths for
998  * the given key.  This function does not return the key itself or
999  * the ultimate key (the last point in cerificate chain).  Only
1000  * certificate chains which ends up at an ultimately trusted key
1001  * are listed.  If ownertrust or validity is not NULL, the corresponding
1002  * value for the returned LID is also returned in these variable(s).
1003  *
1004  *  1) create a void pointer and initialize it to NULL
1005  *  2) pass this void pointer by reference to this function.
1006  *     Set lid to the key you want to enumerate and pass it by reference.
1007  *  3) call this function as long as it does not return -1
1008  *     to indicate EOF. LID does contain the next key used to build the web
1009  *  4) Always call this function a last time with LID set to NULL,
1010  *     so that it can free its context.
1011  *
1012  * Returns: -1 on EOF or the level of the returned LID
1013  */
1014 int
1015 enum_cert_paths( void **context, ulong *lid,
1016                  unsigned *ownertrust, unsigned *validity )
1017 {
1018     return -1;
1019 }
1020
1021
1022 /****************
1023  * Print the current path
1024  */
1025 void
1026 enum_cert_paths_print( void **context, FILE *fp,
1027                                        int refresh, ulong selected_lid )
1028 {
1029     return;
1030 }
1031
1032
1033 \f
1034 /****************************************
1035  *********** NEW NEW NEW ****************
1036  ****************************************/
1037
1038 static int
1039 ask_ownertrust (u32 *kid,int minimum)
1040 {
1041   PKT_public_key *pk;
1042   int rc;
1043   int ot;
1044
1045   pk = m_alloc_clear (sizeof *pk);
1046   rc = get_pubkey (pk, kid);
1047   if (rc)
1048     {
1049       log_error (_("public key %08lX not found: %s\n"),
1050                  (ulong)kid[1], g10_errstr(rc) );
1051       return TRUST_UNKNOWN;
1052     }
1053  
1054   ot=edit_ownertrust(pk,0);
1055   if(ot>0)
1056     ot = get_ownertrust (pk);
1057   else if(ot==0)
1058     ot = minimum?minimum:TRUST_UNDEFINED;
1059   else
1060     ot = -1; /* quit */
1061   free_public_key( pk );
1062
1063   return ot;
1064 }
1065
1066
1067 static void
1068 mark_keyblock_seen (KeyHashTable tbl, KBNODE node)
1069 {
1070   for ( ;node; node = node->next )
1071     if (node->pkt->pkttype == PKT_PUBLIC_KEY
1072         || node->pkt->pkttype == PKT_PUBLIC_SUBKEY)
1073       {
1074         u32 aki[2];
1075
1076         keyid_from_pk (node->pkt->pkt.public_key, aki);
1077         add_key_hash_table (tbl, aki);
1078       }
1079 }
1080
1081
1082
1083 static void
1084 dump_key_array (int depth, struct key_array *keys)
1085 {
1086   struct key_array *kar;
1087
1088   for (kar=keys; kar->keyblock; kar++)
1089     {
1090       KBNODE node = kar->keyblock;
1091       u32 kid[2];
1092
1093       keyid_from_pk(node->pkt->pkt.public_key, kid);
1094       printf ("%d:%08lX%08lX:K::%c::::\n",
1095               depth, (ulong)kid[0], (ulong)kid[1], '?');
1096
1097       for (; node; node = node->next)
1098         {
1099           if (node->pkt->pkttype == PKT_USER_ID)
1100             {
1101               int len = node->pkt->pkt.user_id->len;
1102
1103               if (len > 30)
1104                 len = 30;
1105               printf ("%d:%08lX%08lX:U:::%c:::",
1106                       depth, (ulong)kid[0], (ulong)kid[1],
1107                       (node->flag & 4)? 'f':
1108                       (node->flag & 2)? 'm':
1109                       (node->flag & 1)? 'q':'-');
1110               print_string (stdout,  node->pkt->pkt.user_id->name, len, ':');
1111               putchar (':');
1112               putchar ('\n');
1113             }
1114         }
1115     }
1116 }  
1117
1118
1119 static void
1120 store_validation_status (int depth, KBNODE keyblock)
1121 {
1122   KBNODE node;
1123   byte namehash[20];
1124   int status;
1125   int any = 0;
1126
1127   for (node=keyblock; node; node = node->next)
1128     {
1129       if (node->pkt->pkttype == PKT_USER_ID)
1130         {
1131           PKT_user_id *uid = node->pkt->pkt.user_id;
1132
1133           if (node->flag & 4)
1134             status = TRUST_FULLY;
1135           else if (node->flag & 2)
1136             status = TRUST_MARGINAL;
1137           else if (node->flag & 1)
1138             status = TRUST_UNDEFINED;
1139           else
1140             status = 0;
1141           
1142           if (status)
1143             {
1144               if( uid->attrib_data )
1145                 rmd160_hash_buffer (namehash,uid->attrib_data,uid->attrib_len);
1146               else
1147                 rmd160_hash_buffer (namehash, uid->name, uid->len );
1148               
1149               update_validity (keyblock->pkt->pkt.public_key,
1150                                namehash, depth, status);
1151               any = 1;
1152             }
1153         }
1154     }
1155
1156   if (any)
1157     do_sync ();
1158 }  
1159
1160 /*
1161  * check whether the signature sig is in the klist k
1162  */
1163 static struct key_item *
1164 is_in_klist (struct key_item *k, PKT_signature *sig)
1165 {
1166   for (; k; k = k->next)
1167     {
1168       if (k->kid[0] == sig->keyid[0] && k->kid[1] == sig->keyid[1])
1169         return k;
1170     }
1171   return NULL;
1172 }
1173
1174 /*
1175  * Mark the signature of the given UID which are used to certify it.
1176  * To do this, we first revmove all signatures which are not valid and
1177  * from the remain ones we look for the latest one.  If this is not a
1178  * certification revocation signature we mark the signature by setting
1179  * node flag bit 8.  Note that flag bits 9 and 10 are used for internal
1180  * purposes.  
1181  */
1182 static void
1183 mark_usable_uid_certs (KBNODE keyblock, KBNODE uidnode,
1184                        u32 *main_kid, struct key_item *klist,
1185                        u32 curtime, u32 *next_expire)
1186 {
1187   KBNODE node;
1188   PKT_signature *sig;
1189   
1190   /* first check all signatures */
1191   for (node=uidnode->next; node; node = node->next)
1192     {
1193       node->flag &= ~(1<<8 | 1<<9 | 1<<10);
1194       if (node->pkt->pkttype == PKT_USER_ID
1195           || node->pkt->pkttype == PKT_PUBLIC_SUBKEY)
1196         break; /* ready */
1197       if (node->pkt->pkttype != PKT_SIGNATURE)
1198         continue;
1199       
1200       sig = node->pkt->pkt.signature;
1201       if (sig->keyid[0] == main_kid[0] && sig->keyid[1] == main_kid[1])
1202         continue; /* ignore self-signatures */
1203       if (!IS_UID_SIG(sig) && !IS_UID_REV(sig))
1204         continue; /* we only look at these signature classes */
1205       if (!is_in_klist (klist, sig))
1206         continue;  /* no need to check it then */
1207       if (check_key_signature (keyblock, node, NULL))
1208         continue; /* ignore invalid signatures */
1209       node->flag |= 1<<9;
1210     }      
1211   /* reset the remaining flags */
1212   for (; node; node = node->next)
1213       node->flag &= ~(1<<8 | 1<<9 | 1 << 10);
1214
1215   /* kbnode flag usage: bit 9 is here set for signatures to consider,
1216    * bit 10 will be set by the loop to keep track of keyIDs already
1217    * processed, bit 8 will be set for the usable signatures */
1218
1219   /* for each cert figure out the latest valid one */
1220   for (node=uidnode->next; node; node = node->next)
1221     {
1222       KBNODE n, signode;
1223       u32 kid[2];
1224       u32 sigdate;
1225       
1226       if (node->pkt->pkttype == PKT_PUBLIC_SUBKEY)
1227         break;
1228       if ( !(node->flag & (1<<9)) )
1229         continue; /* not a node to look at */
1230       if ( (node->flag & (1<<10)) )
1231         continue; /* signature with a keyID already processed */
1232       node->flag |= (1<<10); /* mark this node as processed */
1233       sig = node->pkt->pkt.signature;
1234       signode = node;
1235       sigdate = sig->timestamp;
1236       kid[0] = sig->keyid[0]; kid[1] = sig->keyid[1];
1237       for (n=uidnode->next; n; n = n->next)
1238         {
1239           if (n->pkt->pkttype == PKT_PUBLIC_SUBKEY)
1240             break;
1241           if ( !(n->flag & (1<<9)) )
1242             continue;
1243           if ( (n->flag & (1<<10)) )
1244             continue; /* shortcut already processed signatures */
1245           sig = n->pkt->pkt.signature;
1246           if (kid[0] != sig->keyid[0] || kid[1] != sig->keyid[1])
1247             continue;
1248           n->flag |= (1<<10); /* mark this node as processed */
1249
1250           /* If signode is nonrevocable and unexpired and n isn't,
1251              then take signode (skip).  It doesn't matter which is
1252              older: if signode was older then we don't want to take n
1253              as signode is nonrevocable.  If n was older then we're
1254              automatically fine. */
1255           
1256           if(((IS_UID_SIG(signode->pkt->pkt.signature) &&
1257                !signode->pkt->pkt.signature->flags.revocable &&
1258                (signode->pkt->pkt.signature->expiredate==0 ||
1259                 signode->pkt->pkt.signature->expiredate>curtime))) &&
1260              (!(IS_UID_SIG(n->pkt->pkt.signature) &&
1261                 !n->pkt->pkt.signature->flags.revocable &&
1262                 (n->pkt->pkt.signature->expiredate==0 ||
1263                  n->pkt->pkt.signature->expiredate>curtime))))
1264             continue;
1265
1266           /* If n is nonrevocable and unexpired and signode isn't,
1267              then take n.  Again, it doesn't matter which is older: if
1268              n was older then we don't want to take signode as n is
1269              nonrevocable.  If signode was older then we're
1270              automatically fine. */
1271           
1272           if((!(IS_UID_SIG(signode->pkt->pkt.signature) &&
1273                 !signode->pkt->pkt.signature->flags.revocable &&
1274                 (signode->pkt->pkt.signature->expiredate==0 ||
1275                  signode->pkt->pkt.signature->expiredate>curtime))) &&
1276              ((IS_UID_SIG(n->pkt->pkt.signature) &&
1277                !n->pkt->pkt.signature->flags.revocable &&
1278                (n->pkt->pkt.signature->expiredate==0 ||
1279                 n->pkt->pkt.signature->expiredate>curtime))))
1280             {
1281               signode = n;
1282               sigdate = sig->timestamp;
1283               continue;
1284             }
1285
1286           /* At this point, if it's newer, it goes in as the only
1287              remaining possibilities are signode and n are both either
1288              revocable or expired or both nonrevocable and unexpired.
1289              If the timestamps are equal take the later ordered
1290              packet, presuming that the key packets are hopefully in
1291              their original order. */
1292
1293           if (sig->timestamp >= sigdate)
1294             {
1295               signode = n;
1296               sigdate = sig->timestamp;
1297             }
1298         }
1299       sig = signode->pkt->pkt.signature;
1300       if (IS_UID_SIG (sig))
1301         { /* this seems to be a usable one which is not revoked. 
1302            * Just need to check whether there is an expiration time,
1303            * We do the expired certification after finding a suitable
1304            * certification, the assumption is that a signator does not
1305            * want that after the expiration of his certificate the
1306            * system falls back to an older certification which has a
1307            * different expiration time */
1308           const byte *p;
1309           u32 expire;
1310                     
1311           p = parse_sig_subpkt (sig->hashed, SIGSUBPKT_SIG_EXPIRE, NULL );
1312           expire = p? sig->timestamp + buffer_to_u32(p) : 0;
1313
1314           if (expire==0 || expire > curtime )
1315             {
1316               signode->flag |= (1<<8); /* yeah, found a good cert */
1317               if (expire && expire < *next_expire)
1318                 *next_expire = expire;
1319             }
1320         }
1321     }
1322 }
1323
1324 /* Used by validate_one_keyblock to confirm a regexp within a trust
1325    signature.  Returns 1 for match, and 0 for no match or regex
1326    error. */
1327 static int
1328 check_regexp(const char *exp,const char *string)
1329 {
1330 #ifdef DISABLE_REGEXP
1331   /* When DISABLE_REGEXP is defined, assume all regexps do not
1332      match. */
1333   return 0;
1334 #else
1335   int ret;
1336   regex_t pat;
1337
1338   if(regcomp(&pat,exp,REG_ICASE|REG_NOSUB)!=0)
1339     return 0;
1340
1341   ret=regexec(&pat,string,0,NULL,0);
1342
1343   regfree(&pat);
1344
1345   if(DBG_TRUST)
1346     log_debug("regexp \"%s\" on \"%s\": %s\n",exp,string,ret==0?"YES":"NO");
1347
1348   return (ret==0);
1349 #endif
1350 }
1351
1352 /*
1353  * Return true if the key is signed by one of the keys in the given
1354  * key ID list.  User IDs with a valid signature are marked by node
1355  * flags as follows:
1356  *  flag bit 0: There is at least one signature
1357  *           1: There is marginal confidence that this is a legitimate uid
1358  *           2: There is full confidence that this is a legitimate uid.
1359  *           8: Used for internal purposes.
1360  *           9: Ditto (in mark_usable_uid_certs())
1361  *          10: Ditto (ditto)
1362  * This function assumes that all kbnode flags are cleared on entry.
1363  */
1364 static int
1365 validate_one_keyblock (KBNODE kb, struct key_item *klist,
1366                        u32 curtime, u32 *next_expire)
1367 {
1368   struct key_item *kr;
1369   KBNODE node, uidnode=NULL;
1370   PKT_public_key *pk = kb->pkt->pkt.public_key;
1371   u32 main_kid[2];
1372   int issigned=0, any_signed = 0, fully_count =0, marginal_count = 0;
1373
1374   keyid_from_pk(pk, main_kid);
1375   for (node=kb; node; node = node->next)
1376     {
1377       if (node->pkt->pkttype == PKT_USER_ID)
1378         {
1379           if (uidnode && issigned)
1380             {
1381               if (fully_count >= opt.completes_needed
1382                   || marginal_count >= opt.marginals_needed )
1383                 uidnode->flag |= 4; 
1384               else if (fully_count || marginal_count)
1385                 uidnode->flag |= 2;
1386               uidnode->flag |= 1;
1387               any_signed = 1;
1388             }
1389           uidnode = node;
1390           issigned = 0;
1391           fully_count = marginal_count = 0;
1392           mark_usable_uid_certs (kb, uidnode, main_kid, klist, 
1393                                  curtime, next_expire);
1394         }
1395       else if (node->pkt->pkttype == PKT_SIGNATURE 
1396                && (node->flag & (1<<8)) )
1397         {
1398           /* Note that we are only seeing unrevoked sigs here */
1399           PKT_signature *sig = node->pkt->pkt.signature;
1400           
1401           kr = is_in_klist (klist, sig);
1402           /* If the trust_regexp does not match, it's as if the sig
1403              did not exist.  This is safe for non-trust sigs as well
1404              since we don't accept a regexp on the sig unless it's a
1405              trust sig. */
1406           if (kr && (kr->trust_regexp==NULL ||
1407                      (uidnode && check_regexp(kr->trust_regexp,
1408                                             uidnode->pkt->pkt.user_id->name))))
1409             {
1410               if(DBG_TRUST && sig->trust_depth)
1411                 log_debug("trust sig on %s, sig depth is %d, kr depth is %d\n",
1412                           uidnode->pkt->pkt.user_id->name,sig->trust_depth,
1413                           kr->trust_depth);
1414
1415               /* Are we part of a trust sig chain?  We always favor
1416                  the latest trust sig, rather than the greater or
1417                  lesser trust sig or value.  I could make a decent
1418                  argument for any of these cases, but this seems to be
1419                  what PGP does, and I'd like to be compatible. -dms */
1420               if(sig->trust_depth &&
1421                  pk->trust_timestamp<=sig->timestamp &&
1422                  (sig->trust_depth<=kr->trust_depth ||
1423                   kr->ownertrust==TRUST_ULTIMATE))
1424                 {
1425                   /* If we got here, we know that:
1426
1427                      this is a trust sig.
1428
1429                      it's a newer trust sig than any previous trust
1430                      sig on this key (not uid).
1431
1432                      it is legal in that it was either generated by an
1433                      ultimate key, or a key that was part of a trust
1434                      chain, and the depth does not violate the
1435                      original trust sig.
1436
1437                      if there is a regexp attached, it matched
1438                      successfully.
1439                   */
1440
1441                   if(DBG_TRUST)
1442                     log_debug("replacing trust value %d with %d and "
1443                               "depth %d with %d\n",
1444                               pk->trust_value,sig->trust_value,
1445                               pk->trust_depth,sig->trust_depth);
1446
1447                   pk->trust_value=sig->trust_value;
1448                   pk->trust_depth=sig->trust_depth-1;
1449
1450                   /* If the trust sig contains a regexp, record it
1451                      on the pk for the next round. */
1452                   if(sig->trust_regexp)
1453                     pk->trust_regexp=sig->trust_regexp;
1454                 }
1455
1456               if (kr->ownertrust == TRUST_ULTIMATE)
1457                 fully_count = opt.completes_needed;
1458               else if (kr->ownertrust == TRUST_FULLY)
1459                 fully_count++;
1460               else if (kr->ownertrust == TRUST_MARGINAL)
1461                 marginal_count++;
1462               issigned = 1;
1463             }
1464         }
1465     }
1466
1467   if (uidnode && issigned)
1468     {
1469       if (fully_count >= opt.completes_needed
1470                || marginal_count >= opt.marginals_needed )
1471         uidnode->flag |= 4; 
1472       else if (fully_count || marginal_count)
1473         uidnode->flag |= 2;
1474       uidnode->flag |= 1;
1475       any_signed = 1;
1476     }
1477
1478   return any_signed;
1479 }
1480
1481
1482 static int
1483 search_skipfnc (void *opaque, u32 *kid)
1484 {
1485   return test_key_hash_table ((KeyHashTable)opaque, kid);
1486 }
1487
1488
1489 /*
1490  * Scan all keys and return a key_array of all suitable keys from
1491  * kllist.  The caller has to pass keydb handle so that we don't use
1492  * to create our own.  Returns either a key_array or NULL in case of
1493  * an error.  No results found are indicated by an empty array.
1494  * Caller hast to release the returned array.  
1495  */
1496 static struct key_array *
1497 validate_key_list (KEYDB_HANDLE hd, KeyHashTable visited,
1498                    struct key_item *klist, u32 curtime, u32 *next_expire)
1499 {
1500   KBNODE keyblock = NULL;
1501   struct key_array *keys = NULL;
1502   size_t nkeys, maxkeys;
1503   int rc;
1504   KEYDB_SEARCH_DESC desc;
1505   
1506   maxkeys = 1000;
1507   keys = m_alloc ((maxkeys+1) * sizeof *keys);
1508   nkeys = 0;
1509   
1510   rc = keydb_search_reset (hd);
1511   if (rc)
1512     {
1513       log_error ("keydb_search_reset failed: %s\n", g10_errstr(rc));
1514       m_free (keys);
1515       return NULL;
1516     }
1517
1518   memset (&desc, 0, sizeof desc);
1519   desc.mode = KEYDB_SEARCH_MODE_FIRST;
1520   desc.skipfnc = search_skipfnc;
1521   desc.skipfncvalue = visited;
1522   rc = keydb_search (hd, &desc, 1);
1523   if (rc == -1)
1524     {
1525       keys[nkeys].keyblock = NULL;
1526       return keys;
1527     }
1528   if (rc)
1529     {
1530       log_error ("keydb_search_first failed: %s\n", g10_errstr(rc));
1531       m_free (keys);
1532       return NULL;
1533     }
1534   
1535   desc.mode = KEYDB_SEARCH_MODE_NEXT; /* change mode */
1536   do
1537     {
1538       PKT_public_key *pk;
1539         
1540       rc = keydb_get_keyblock (hd, &keyblock);
1541       if (rc) 
1542         {
1543           log_error ("keydb_get_keyblock failed: %s\n", g10_errstr(rc));
1544           m_free (keys);
1545           return NULL;
1546         }
1547       
1548       if ( keyblock->pkt->pkttype != PKT_PUBLIC_KEY) 
1549         {
1550           log_debug ("ooops: invalid pkttype %d encountered\n",
1551                      keyblock->pkt->pkttype);
1552           dump_kbnode (keyblock);
1553           release_kbnode(keyblock);
1554           continue;
1555         }
1556
1557       /* prepare the keyblock for further processing */
1558       merge_keys_and_selfsig (keyblock); 
1559       clear_kbnode_flags (keyblock);
1560       pk = keyblock->pkt->pkt.public_key;
1561       if (pk->has_expired || pk->is_revoked)
1562         {
1563           /* it does not make sense to look further at those keys */
1564           mark_keyblock_seen (visited, keyblock);
1565         }
1566       else if (validate_one_keyblock (keyblock, klist, curtime, next_expire))
1567         {
1568           if (pk->expiredate && pk->expiredate >= curtime
1569               && pk->expiredate < *next_expire)
1570             *next_expire = pk->expiredate;
1571
1572           if (nkeys == maxkeys) {
1573             maxkeys += 1000;
1574             keys = m_realloc (keys, (maxkeys+1) * sizeof *keys);
1575           }
1576           keys[nkeys++].keyblock = keyblock;
1577           /* this key is signed - don't check it again */
1578           mark_keyblock_seen (visited, keyblock);
1579           keyblock = NULL;
1580         }
1581
1582       release_kbnode (keyblock);
1583       keyblock = NULL;
1584     } 
1585   while ( !(rc = keydb_search (hd, &desc, 1)) );
1586   if (rc && rc != -1) 
1587     {
1588       log_error ("keydb_search_next failed: %s\n", g10_errstr(rc));
1589       m_free (keys);
1590       return NULL;
1591     }
1592
1593   keys[nkeys].keyblock = NULL;
1594   return keys;
1595
1596
1597
1598 static void
1599 reset_unconnected_keys (KEYDB_HANDLE hd, KeyHashTable visited)
1600 {
1601   int rc;
1602   KBNODE keyblock = NULL;
1603   KEYDB_SEARCH_DESC desc;
1604   int count = 0, nreset = 0;
1605   
1606   rc = keydb_search_reset (hd);
1607   if (rc)
1608     {
1609       log_error ("keydb_search_reset failed: %s\n", g10_errstr(rc));
1610       return;
1611     }
1612
1613   memset (&desc, 0, sizeof desc);
1614   desc.mode = KEYDB_SEARCH_MODE_FIRST;
1615   desc.skipfnc = search_skipfnc;
1616   desc.skipfncvalue = visited;
1617   rc = keydb_search (hd, &desc, 1);
1618   if (rc && rc != -1 )
1619     log_error ("keydb_search_first failed: %s\n", g10_errstr(rc));
1620   else if (!rc)
1621     {
1622       desc.mode = KEYDB_SEARCH_MODE_NEXT; /* change mode */
1623       do
1624         {
1625           rc = keydb_get_keyblock (hd, &keyblock);
1626           if (rc) 
1627             {
1628               log_error ("keydb_get_keyblock failed: %s\n", g10_errstr(rc));
1629               break;
1630             }
1631           count++;
1632
1633           if (keyblock->pkt->pkttype == PKT_PUBLIC_KEY) /* paranoid assertion*/
1634             {
1635               nreset += clear_validity (keyblock->pkt->pkt.public_key);
1636               release_kbnode (keyblock);
1637             } 
1638         }
1639       while ( !(rc = keydb_search (hd, &desc, 1)) );
1640       if (rc && rc != -1) 
1641         log_error ("keydb_search_next failed: %s\n", g10_errstr(rc));
1642     }
1643   if (opt.verbose)
1644     log_info ("%d unconnected keys (%d trust records cleared)\n",
1645               count, nreset);
1646   do_sync ();
1647
1648
1649
1650 /*
1651  * Run the key validation procedure.
1652  *
1653  * This works this way:
1654  * Step 1: Find all ultimately trusted keys (UTK).
1655  *         mark them all as seen and put them into klist.
1656  * Step 2: loop max_cert_times
1657  * Step 3:   if OWNERTRUST of any key in klist is undefined
1658  *             ask user to assign ownertrust
1659  * Step 4:   Loop over all keys in the keyDB which are not marked seen 
1660  * Step 5:     if key is revoked or expired
1661  *                mark key as seen
1662  *                continue loop at Step 4
1663  * Step 6:     For each user ID of that key signed by a key in klist
1664  *                Calculate validity by counting trusted signatures.
1665  *                Set validity of user ID
1666  * Step 7:     If any signed user ID was found
1667  *                mark key as seen
1668  *             End Loop
1669  * Step 8:   Build a new klist from all fully trusted keys from step 6
1670  *           End Loop
1671  *         Ready  
1672  *
1673  */
1674 static int
1675 validate_keys (int interactive)
1676 {
1677   int rc = 0;
1678   int quit=0;
1679   struct key_item *klist = NULL;
1680   struct key_item *k;
1681   struct key_array *keys = NULL;
1682   struct key_array *kar;
1683   KEYDB_HANDLE kdb = NULL;
1684   KBNODE node;
1685   int depth;
1686   int key_count;
1687   int ot_unknown, ot_undefined, ot_never, ot_marginal, ot_full, ot_ultimate;
1688   KeyHashTable visited;
1689   u32 start_time, next_expire;
1690
1691   start_time = make_timestamp ();
1692   next_expire = 0xffffffff; /* set next expire to the year 2106 */
1693   visited = new_key_hash_table ();
1694   /* Fixme: Instead of always building a UTK list, we could just build it
1695    * here when needed */
1696   if (!utk_list)
1697     {
1698       log_info ("no ultimately trusted keys found\n");
1699       goto leave;
1700     }
1701
1702   /* mark all UTKs as visited and set validity to ultimate */
1703   for (k=utk_list; k; k = k->next)
1704     {
1705       KBNODE keyblock;
1706       PKT_public_key *pk;
1707
1708       keyblock = get_pubkeyblock (k->kid);
1709       if (!keyblock)
1710         {
1711           log_error (_("public key of ultimately"
1712                        " trusted key %08lX not found\n"), (ulong)k->kid[1]);
1713           continue;
1714         }
1715       mark_keyblock_seen (visited, keyblock);
1716       pk = keyblock->pkt->pkt.public_key;
1717       for (node=keyblock; node; node = node->next)
1718         {
1719           if (node->pkt->pkttype == PKT_USER_ID)
1720             {
1721               byte namehash[20];
1722               PKT_user_id *uid = node->pkt->pkt.user_id;
1723               
1724               if( uid->attrib_data )
1725                 rmd160_hash_buffer (namehash,uid->attrib_data,uid->attrib_len);
1726               else
1727                 rmd160_hash_buffer (namehash, uid->name, uid->len );
1728               update_validity (pk, namehash, 0, TRUST_ULTIMATE);
1729             }
1730         }
1731       if ( pk->expiredate && pk->expiredate >= start_time
1732            && pk->expiredate < next_expire)
1733         next_expire = pk->expiredate;
1734       
1735       release_kbnode (keyblock);
1736       do_sync ();
1737     }
1738
1739   klist = utk_list;
1740   kdb = keydb_new (0);
1741
1742   for (depth=0; depth < opt.max_cert_depth; depth++)
1743     {
1744       /* See whether we should assign ownertrust values to the keys in
1745          utk_list.  */
1746       ot_unknown = ot_undefined = ot_never = 0;
1747       ot_marginal = ot_full = ot_ultimate = 0;
1748       for (k=klist; k; k = k->next)
1749         {
1750           int min=0;
1751
1752           /* 120 and 60 are as per RFC2440 */
1753           if(k->trust_value>=120)
1754             min=TRUST_FULLY;
1755           else if(k->trust_value>=60)
1756             min=TRUST_MARGINAL;
1757
1758           if(min!=k->min_ownertrust)
1759             update_min_ownertrust(k->kid,min);
1760
1761           if (interactive && k->ownertrust == TRUST_UNKNOWN)
1762             {
1763               k->ownertrust = ask_ownertrust (k->kid,min);
1764
1765               if (k->ownertrust == -1)
1766                 {
1767                   quit=1;
1768                   goto leave;
1769                 }
1770             }
1771
1772           /* This can happen during transition from an old trustdb
1773              before trust sigs.  It can also happen if a user uses two
1774              different versions of GnuPG. */
1775           if(k->ownertrust<min)
1776             {
1777               if(DBG_TRUST)
1778                 log_debug("key %08lX: "
1779                           "overriding ownertrust \"%s\" with \"%s\"\n",
1780                           (ulong)k->kid[1],
1781                           trust_string(k->ownertrust),trust_string(min));
1782
1783               k->ownertrust=min;
1784             }
1785
1786           if (k->ownertrust == TRUST_UNKNOWN)
1787             ot_unknown++;
1788           else if (k->ownertrust == TRUST_UNDEFINED)
1789             ot_undefined++;
1790           else if (k->ownertrust == TRUST_NEVER)
1791             ot_never++;
1792           else if (k->ownertrust == TRUST_MARGINAL)
1793             ot_marginal++;
1794           else if (k->ownertrust == TRUST_FULLY)
1795             ot_full++;
1796           else if (k->ownertrust == TRUST_ULTIMATE)
1797             ot_ultimate++;
1798         }
1799
1800       /* Find all keys which are signed by a key in kdlist */
1801       keys = validate_key_list (kdb, visited, klist, start_time, &next_expire);
1802       if (!keys) 
1803         {
1804           log_error ("validate_key_list failed\n");
1805           rc = G10ERR_GENERAL;
1806           goto leave;
1807         }
1808
1809       for (key_count=0, kar=keys; kar->keyblock; kar++, key_count++)
1810         ;
1811
1812       /* Store the calculated valididation status somewhere */
1813       if (opt.verbose > 1)
1814         dump_key_array (depth, keys);
1815
1816       log_info (_("checking at depth %d signed=%d"
1817                   " ot(-/q/n/m/f/u)=%d/%d/%d/%d/%d/%d\n"), 
1818                 depth, key_count, ot_unknown, ot_undefined,
1819                 ot_never, ot_marginal, ot_full, ot_ultimate ); 
1820
1821       for (kar=keys; kar->keyblock; kar++)
1822           store_validation_status (depth, kar->keyblock);
1823
1824       /* Build a new kdlist from all fully valid keys in KEYS */
1825       if (klist != utk_list)
1826         release_key_items (klist);
1827       klist = NULL;
1828       for (kar=keys; kar->keyblock; kar++)
1829         {
1830           for (node=kar->keyblock; node; node = node->next)
1831             {
1832               if (node->pkt->pkttype == PKT_USER_ID && (node->flag & 4))
1833                 {
1834                   k = new_key_item ();
1835                   keyid_from_pk (kar->keyblock->pkt->pkt.public_key, k->kid);
1836                   k->ownertrust = get_ownertrust (kar->keyblock
1837                                                   ->pkt->pkt.public_key);
1838                   k->min_ownertrust = get_min_ownertrust (kar->keyblock
1839                                                         ->pkt->pkt.public_key);
1840                   k->trust_depth=
1841                     kar->keyblock->pkt->pkt.public_key->trust_depth;
1842                   k->trust_value=
1843                     kar->keyblock->pkt->pkt.public_key->trust_value;
1844                   if(kar->keyblock->pkt->pkt.public_key->trust_regexp)
1845                     k->trust_regexp=
1846                       m_strdup(kar->keyblock->pkt->
1847                                pkt.public_key->trust_regexp);
1848                   k->next = klist;
1849                   klist = k;
1850                   break;
1851                 }
1852             }
1853         }
1854       release_key_array (keys);
1855       keys = NULL;
1856       if (!klist)
1857         break; /* no need to dive in deeper */
1858     }
1859
1860   reset_unconnected_keys (kdb, visited);
1861
1862  leave:
1863   keydb_release (kdb);
1864   release_key_array (keys);
1865   release_key_items (klist);
1866   release_key_hash_table (visited);
1867   if (!rc && !quit) /* mark trustDB as checked */
1868     {
1869       if (next_expire == 0xffffffff || next_expire < start_time )
1870         tdbio_write_nextcheck (0); 
1871       else
1872         {
1873           tdbio_write_nextcheck (next_expire); 
1874           log_info (_("next trustdb check due at %s\n"),
1875                     strtimestamp (next_expire));
1876         }
1877       do_sync ();
1878       pending_check_trustdb = 0;
1879     }
1880   return rc;
1881 }