* keylist.c (print_capabilities): Show 'D' for disabled keys in
[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   if(!tdbio_db_matches_options())
429     pending_check_trustdb=1;
430 }
431
432
433
434 \f
435 /***********************************************
436  *************  Print helpers   ****************
437  ***********************************************/
438
439 /****************
440  * This function returns a letter for a trustvalue  Trust flags
441  * are ignore.
442  */
443 int
444 trust_letter (unsigned int value)
445 {
446   switch( (value & TRUST_MASK) ) 
447     {
448     case TRUST_UNKNOWN:   return '-';
449     case TRUST_EXPIRED:   return 'e';
450     case TRUST_UNDEFINED: return 'q';
451     case TRUST_NEVER:     return 'n';
452     case TRUST_MARGINAL:  return 'm';
453     case TRUST_FULLY:     return 'f';
454     case TRUST_ULTIMATE:  return 'u';
455     default:              return 0;
456     }
457 }
458
459 /* The strings here are similar to those in
460    pkclist.c:do_edit_ownertrust() */
461 const char *
462 trust_string (unsigned int value)
463 {
464   switch( (value & TRUST_MASK) ) 
465     {
466     case TRUST_UNKNOWN:   return _("unknown trust");
467     case TRUST_EXPIRED:   return _("expired");
468     case TRUST_UNDEFINED: return _("undefined trust");
469     case TRUST_NEVER:     return _("do NOT trust");
470     case TRUST_MARGINAL:  return _("marginal trust");
471     case TRUST_FULLY:     return _("full trust");
472     case TRUST_ULTIMATE:  return _("ultimate trust");
473     default:              return "err";
474     }
475 }
476
477 static const char *
478 trust_model_string(void)
479 {
480   switch(opt.trust_model)
481     {
482     case TM_OPENPGP: return "OpenPGP";
483     case TM_CLASSIC: return "classic";
484     case TM_ALWAYS:  return "always";
485     default:         return "unknown";
486     }
487 }
488
489 /****************
490  * Recreate the WoT but do not ask for new ownertrusts.  Special
491  * feature: In batch mode and without a forced yes, this is only done
492  * when a check is due.  This can be used to run the check from a crontab
493  */
494 void
495 check_trustdb ()
496 {
497   if(opt.trust_model==TM_OPENPGP || opt.trust_model==TM_CLASSIC)
498     {
499       init_trustdb();
500       if (opt.batch && !opt.answer_yes)
501         {
502           ulong scheduled;
503
504           scheduled = tdbio_read_nextcheck ();
505           if (!scheduled)
506             {
507               log_info (_("no need for a trustdb check\n"));
508               return;
509             }
510
511           if (scheduled > make_timestamp ())
512             {
513               log_info (_("next trustdb check due at %s\n"),
514                         strtimestamp (scheduled));
515               return;
516             }
517         }
518
519       validate_keys (0);
520     }
521   else
522     log_info (_("no need for a trustdb check with \"%s\" trust model\n"),
523               trust_model_string());
524 }
525
526
527 /*
528  * Recreate the WoT. 
529  */
530 void
531 update_trustdb()
532 {
533   if(opt.trust_model==TM_OPENPGP || opt.trust_model==TM_CLASSIC)
534     {
535       init_trustdb();
536       validate_keys (1);
537     }
538   else
539     log_info (_("no need for a trustdb update with \"%s\" trust model\n"),
540               trust_model_string());
541 }
542
543 void
544 revalidation_mark (void)
545 {
546   init_trustdb();
547   /* we simply set the time for the next check to 1 (far back in 1970)
548    * so that a --update-trustdb will be scheduled */
549   if (tdbio_write_nextcheck (1))
550       do_sync ();
551   pending_check_trustdb = 1;
552 }
553
554 int
555 trustdb_pending_check(void)
556 {
557   return pending_check_trustdb;
558 }
559
560 \f
561 /***********************************************
562  ***********  Ownertrust et al. ****************
563  ***********************************************/
564
565 static int 
566 read_trust_record (PKT_public_key *pk, TRUSTREC *rec)
567 {
568   int rc;
569   
570   init_trustdb();
571   rc = tdbio_search_trust_bypk (pk, rec);
572   if (rc == -1)
573     return -1; /* no record yet */
574   if (rc) 
575     {
576       log_error ("trustdb: searching trust record failed: %s\n",
577                  g10_errstr (rc));
578       return rc; 
579     }
580       
581   if (rec->rectype != RECTYPE_TRUST)
582     {
583       log_error ("trustdb: record %lu is not a trust record\n",
584                  rec->recnum);
585       return G10ERR_TRUSTDB; 
586     }      
587   
588   return 0;
589 }
590
591 /****************
592  * Return the assigned ownertrust value for the given public key.
593  * The key should be the primary key.
594  */
595 unsigned int 
596 get_ownertrust ( PKT_public_key *pk)
597 {
598   TRUSTREC rec;
599   int rc;
600   
601   rc = read_trust_record (pk, &rec);
602   if (rc == -1)
603     return TRUST_UNKNOWN; /* no record yet */
604   if (rc) 
605     {
606       tdbio_invalid ();
607       return rc; /* actually never reached */
608     }
609
610   return rec.r.trust.ownertrust;
611 }
612
613 unsigned int 
614 get_min_ownertrust (PKT_public_key *pk)
615 {
616   TRUSTREC rec;
617   int rc;
618   
619   rc = read_trust_record (pk, &rec);
620   if (rc == -1)
621     return TRUST_UNKNOWN; /* no record yet */
622   if (rc) 
623     {
624       tdbio_invalid ();
625       return rc; /* actually never reached */
626     }
627
628   return rec.r.trust.min_ownertrust;
629 }
630
631 /*
632  * Same as get_ownertrust but return a trust letter instead of an value.
633  */
634 int
635 get_ownertrust_info (PKT_public_key *pk)
636 {
637     unsigned int otrust,otrust_min;
638     int c;
639
640     otrust = get_ownertrust (pk);
641     otrust_min = get_min_ownertrust (pk);
642     if(otrust<otrust_min)
643       {
644         /* If the trust that the user has set is less than the trust
645            that was calculated from a trust signature chain, use the
646            higher of the two.  We do this here and not in
647            get_ownertrust since the underlying ownertrust should not
648            really be set - just the appearance of the ownertrust. */
649
650         otrust=otrust_min;
651       }
652
653     c = trust_letter( (otrust & TRUST_MASK) );
654     if( !c )
655         c = '?';
656     return c;
657 }
658
659 /*
660  * Set the trust value of the given public key to the new value.
661  * The key should be a primary one.
662  */
663 void
664 update_ownertrust (PKT_public_key *pk, unsigned int new_trust )
665 {
666   TRUSTREC rec;
667   int rc;
668   
669   rc = read_trust_record (pk, &rec);
670   if (!rc)
671     {
672       if (DBG_TRUST)
673         log_debug ("update ownertrust from %u to %u\n",
674                    (unsigned int)rec.r.trust.ownertrust, new_trust );
675       if (rec.r.trust.ownertrust != new_trust)
676         {
677           rec.r.trust.ownertrust = new_trust;
678           write_record( &rec );
679           revalidation_mark ();
680           do_sync ();
681         }
682     }
683   else if (rc == -1)
684     { /* no record yet - create a new one */
685       size_t dummy;
686
687       if (DBG_TRUST)
688         log_debug ("insert ownertrust %u\n", new_trust );
689
690       memset (&rec, 0, sizeof rec);
691       rec.recnum = tdbio_new_recnum ();
692       rec.rectype = RECTYPE_TRUST;
693       fingerprint_from_pk (pk, rec.r.trust.fingerprint, &dummy);
694       rec.r.trust.ownertrust = new_trust;
695       write_record (&rec);
696       revalidation_mark ();
697       do_sync ();
698       rc = 0;
699     }
700   else 
701     {
702       tdbio_invalid ();
703     }
704 }
705
706 static void
707 update_min_ownertrust (u32 *kid, unsigned int new_trust )
708 {
709   PKT_public_key *pk;
710   TRUSTREC rec;
711   int rc;
712
713   pk = m_alloc_clear (sizeof *pk);
714   rc = get_pubkey (pk, kid);
715   if (rc)
716     {
717       log_error (_("public key %08lX not found: %s\n"),
718                  (ulong)kid[1], g10_errstr(rc) );
719       return;
720     }
721
722   rc = read_trust_record (pk, &rec);
723   if (!rc)
724     {
725       if (DBG_TRUST)
726         log_debug ("key %08lX: update min_ownertrust from %u to %u\n",
727                    (ulong)kid[1],(unsigned int)rec.r.trust.min_ownertrust,
728                    new_trust );
729       if (rec.r.trust.min_ownertrust != new_trust)
730         {
731           rec.r.trust.min_ownertrust = new_trust;
732           write_record( &rec );
733           revalidation_mark ();
734           do_sync ();
735         }
736     }
737   else if (rc == -1)
738     { /* no record yet - create a new one */
739       size_t dummy;
740
741       if (DBG_TRUST)
742         log_debug ("insert min_ownertrust %u\n", new_trust );
743
744       memset (&rec, 0, sizeof rec);
745       rec.recnum = tdbio_new_recnum ();
746       rec.rectype = RECTYPE_TRUST;
747       fingerprint_from_pk (pk, rec.r.trust.fingerprint, &dummy);
748       rec.r.trust.min_ownertrust = new_trust;
749       write_record (&rec);
750       revalidation_mark ();
751       do_sync ();
752       rc = 0;
753     }
754   else 
755     {
756       tdbio_invalid ();
757     }
758 }
759
760 /* Clear the ownertrust and min_ownertrust values.  Return true if a
761    change actually happened. */
762 int
763 clear_ownertrusts (PKT_public_key *pk)
764 {
765   TRUSTREC rec;
766   int rc;
767   
768   rc = read_trust_record (pk, &rec);
769   if (!rc)
770     {
771       if (DBG_TRUST)
772         {
773           log_debug ("clearing ownertrust (old value %u)\n",
774                      (unsigned int)rec.r.trust.ownertrust);
775           log_debug ("clearing min_ownertrust (old value %u)\n",
776                      (unsigned int)rec.r.trust.min_ownertrust);
777         }
778       if (rec.r.trust.ownertrust || rec.r.trust.min_ownertrust)
779         {
780           rec.r.trust.ownertrust = 0;
781           rec.r.trust.min_ownertrust = 0;
782           write_record( &rec );
783           revalidation_mark ();
784           do_sync ();
785           return 1;
786         }
787     }
788   else if (rc != -1)
789     {
790       tdbio_invalid ();
791     }
792   return 0;
793 }
794
795 /* 
796  * Note: Caller has to do a sync 
797  */
798 static void
799 update_validity (PKT_public_key *pk, const byte *namehash,
800                  int depth, int validity)
801 {
802   TRUSTREC trec, vrec;
803   int rc;
804   ulong recno;
805   
806   rc = read_trust_record (pk, &trec);
807   if (rc && rc != -1)
808     {
809       tdbio_invalid ();
810       return;
811     }
812   if (rc == -1) /* no record yet - create a new one */
813     { 
814       size_t dummy;
815
816       rc = 0;
817       memset (&trec, 0, sizeof trec);
818       trec.recnum = tdbio_new_recnum ();
819       trec.rectype = RECTYPE_TRUST;
820       fingerprint_from_pk (pk, trec.r.trust.fingerprint, &dummy);
821       trec.r.trust.ownertrust = 0;
822       }
823
824   /* locate an existing one */
825   recno = trec.r.trust.validlist;
826   while (recno)
827     {
828       read_record (recno, &vrec, RECTYPE_VALID);
829       if ( !memcmp (vrec.r.valid.namehash, namehash, 20) )
830         break;
831       recno = vrec.r.valid.next;
832     }
833
834   if (!recno) /* insert a new validity record */
835     {
836       memset (&vrec, 0, sizeof vrec);
837       vrec.recnum = tdbio_new_recnum ();
838       vrec.rectype = RECTYPE_VALID;
839       memcpy (vrec.r.valid.namehash, namehash, 20);
840       vrec.r.valid.next = trec.r.trust.validlist;
841     }
842   vrec.r.valid.validity = validity;
843   write_record (&vrec);
844   trec.r.trust.depth = depth;
845   trec.r.trust.validlist = vrec.recnum;
846   write_record (&trec);
847 }
848
849
850 /* reset validity for all user IDs.  Caller must sync. */
851 static int
852 clear_validity (PKT_public_key *pk)
853 {
854   TRUSTREC trec, vrec;
855   int rc;
856   ulong recno;
857   int any = 0;
858   
859   rc = read_trust_record (pk, &trec);
860   if (rc && rc != -1)
861     {
862       tdbio_invalid ();
863       return 0;
864     }
865   if (rc == -1) /* no record yet - no need to clear it then ;-) */
866     return 0;
867
868   /* Clear minimum ownertrust, if any */
869   if(trec.r.trust.min_ownertrust)
870     {
871       trec.r.trust.min_ownertrust=0;
872       write_record(&trec);
873     }
874
875   /* reset validity for all user IDs */
876   recno = trec.r.trust.validlist;
877   while (recno)
878     {
879       read_record (recno, &vrec, RECTYPE_VALID);
880       if ((vrec.r.valid.validity & TRUST_MASK))
881         {
882           vrec.r.valid.validity &= ~TRUST_MASK;
883           write_record (&vrec);
884           any = 1;
885         }
886       recno = vrec.r.valid.next;
887     }
888
889   return any;
890 }
891
892 /***********************************************
893  *********  Query trustdb values  **************
894  ***********************************************/
895
896 /* Return true if key is disabled */
897 int
898 is_disabled(void *dummy,u32 *keyid)
899 {
900   int rc;
901   TRUSTREC trec;
902   int disabled=0; /* default to not disabled */
903   PKT_public_key *pk=m_alloc_clear(sizeof(PKT_public_key));
904
905   init_trustdb ();
906
907   rc = get_pubkey(pk, keyid);
908   if(rc)
909     {
910       log_error("error checking disabled status of %08lX: %s\n",
911                 (ulong)keyid[1],g10_errstr(rc));
912       goto leave;
913     }
914  
915   rc = read_trust_record (pk, &trec);
916   if (rc && rc != -1)
917     {
918       tdbio_invalid ();
919       goto leave;
920     }
921   if (rc == -1) /* no record found, so assume not disabled */
922     goto leave;
923  
924   if(trec.r.trust.ownertrust & TRUST_FLAG_DISABLED)
925     disabled=1;
926  
927  leave:
928   free_public_key(pk);
929   return disabled;
930 }
931
932 /*
933  * Return the validity information for PK.  If the namehash is not
934  * NULL, the validity of the corresponsing user ID is returned,
935  * otherwise, a reasonable value for the entire key is returned. 
936  */
937 unsigned int
938 get_validity (PKT_public_key *pk, const byte *namehash)
939 {
940   static int did_nextcheck;
941   TRUSTREC trec, vrec;
942   int rc;
943   ulong recno;
944   unsigned int validity;
945   u32 kid[2];
946   PKT_public_key *main_pk;
947
948   init_trustdb ();
949   if (!did_nextcheck)
950     {
951       ulong scheduled;
952
953       did_nextcheck = 1;
954       scheduled = tdbio_read_nextcheck ();
955       if (scheduled && scheduled <= make_timestamp ())
956         {
957           if (opt.no_auto_check_trustdb) 
958             {
959               pending_check_trustdb = 1;
960               log_info ("please do a --check-trustdb\n");
961             }
962           else
963             {
964               log_info (_("checking the trustdb\n"));
965               validate_keys (0);
966             }
967         }
968     }
969
970   keyid_from_pk (pk, kid);
971   if (pk->main_keyid[0] != kid[0] || pk->main_keyid[1] != kid[1])
972     { /* this is a subkey - get the mainkey */
973       main_pk = m_alloc_clear (sizeof *main_pk);
974       rc = get_pubkey (main_pk, pk->main_keyid);
975       if (rc)
976         {
977           log_error ("error getting main key %08lX of subkey %08lX: %s\n",
978                      (ulong)pk->main_keyid[1], (ulong)kid[1], g10_errstr(rc));
979           validity = TRUST_UNKNOWN; 
980           goto leave;
981         }
982     }
983   else
984     main_pk = pk;
985
986   rc = read_trust_record (main_pk, &trec);
987   if (rc && rc != -1)
988     {
989       tdbio_invalid ();
990       return 0;
991     }
992   if (rc == -1) /* no record found */
993     {
994       validity = TRUST_UNKNOWN; 
995       goto leave;
996     }
997
998   /* loop over all user IDs */
999   recno = trec.r.trust.validlist;
1000   validity = 0;
1001   while (recno)
1002     {
1003       read_record (recno, &vrec, RECTYPE_VALID);
1004       if ( validity < (vrec.r.valid.validity & TRUST_MASK) )
1005         validity = (vrec.r.valid.validity & TRUST_MASK);
1006       if ( namehash && !memcmp (vrec.r.valid.namehash, namehash, 20) )
1007         break;
1008       recno = vrec.r.valid.next;
1009     }
1010   
1011   if (recno) /* okay, use the user ID associated one */
1012     validity = (vrec.r.valid.validity & TRUST_MASK);
1013
1014   if ( (trec.r.trust.ownertrust & TRUST_FLAG_DISABLED) )
1015     validity |= TRUST_FLAG_DISABLED;
1016
1017  leave:
1018   /* set some flags direct from the key */
1019   if (main_pk->is_revoked)
1020     validity |= TRUST_FLAG_REVOKED;
1021   if (main_pk != pk && pk->is_revoked)
1022     validity |= TRUST_FLAG_SUB_REVOKED;
1023   /* Note: expiration is a trust value and not a flag - don't know why
1024    * I initially designed it that way */
1025   if (main_pk->has_expired || pk->has_expired)
1026     validity = (validity & ~TRUST_MASK) | TRUST_EXPIRED;
1027   
1028   if (pending_check_trustdb)
1029     validity |= TRUST_FLAG_PENDING_CHECK;
1030
1031   if (main_pk != pk)
1032     free_public_key (main_pk);
1033   return validity;
1034 }
1035
1036
1037 int
1038 get_validity_info (PKT_public_key *pk, const byte *namehash)
1039 {
1040     int trustlevel;
1041     int c;
1042
1043     trustlevel = get_validity (pk, namehash);
1044     if( trustlevel & TRUST_FLAG_DISABLED )
1045         return 'd';
1046     if( trustlevel & TRUST_FLAG_REVOKED )
1047         return 'r';
1048     c = trust_letter ( (trustlevel & TRUST_MASK) );
1049     if( !c )
1050         c = '?';
1051     return c;
1052 }
1053
1054
1055
1056
1057 void
1058 list_trust_path( const char *username )
1059 {
1060 }
1061
1062
1063
1064
1065 /****************
1066  * Enumerate all keys, which are needed to build all trust paths for
1067  * the given key.  This function does not return the key itself or
1068  * the ultimate key (the last point in cerificate chain).  Only
1069  * certificate chains which ends up at an ultimately trusted key
1070  * are listed.  If ownertrust or validity is not NULL, the corresponding
1071  * value for the returned LID is also returned in these variable(s).
1072  *
1073  *  1) create a void pointer and initialize it to NULL
1074  *  2) pass this void pointer by reference to this function.
1075  *     Set lid to the key you want to enumerate and pass it by reference.
1076  *  3) call this function as long as it does not return -1
1077  *     to indicate EOF. LID does contain the next key used to build the web
1078  *  4) Always call this function a last time with LID set to NULL,
1079  *     so that it can free its context.
1080  *
1081  * Returns: -1 on EOF or the level of the returned LID
1082  */
1083 int
1084 enum_cert_paths( void **context, ulong *lid,
1085                  unsigned *ownertrust, unsigned *validity )
1086 {
1087     return -1;
1088 }
1089
1090
1091 /****************
1092  * Print the current path
1093  */
1094 void
1095 enum_cert_paths_print( void **context, FILE *fp,
1096                                        int refresh, ulong selected_lid )
1097 {
1098     return;
1099 }
1100
1101
1102 \f
1103 /****************************************
1104  *********** NEW NEW NEW ****************
1105  ****************************************/
1106
1107 static int
1108 ask_ownertrust (u32 *kid,int minimum)
1109 {
1110   PKT_public_key *pk;
1111   int rc;
1112   int ot;
1113
1114   pk = m_alloc_clear (sizeof *pk);
1115   rc = get_pubkey (pk, kid);
1116   if (rc)
1117     {
1118       log_error (_("public key %08lX not found: %s\n"),
1119                  (ulong)kid[1], g10_errstr(rc) );
1120       return TRUST_UNKNOWN;
1121     }
1122  
1123   if(opt.force_ownertrust)
1124     {
1125       log_info("force trust for key %08lX to %s\n",(ulong)kid[1],
1126                trust_string(opt.force_ownertrust));
1127       update_ownertrust(pk,opt.force_ownertrust);
1128       ot=opt.force_ownertrust;
1129     }
1130   else
1131     {
1132       ot=edit_ownertrust(pk,0);
1133       if(ot>0)
1134         ot = get_ownertrust (pk);
1135       else if(ot==0)
1136         ot = minimum?minimum:TRUST_UNDEFINED;
1137       else
1138         ot = -1; /* quit */
1139     }
1140
1141   free_public_key( pk );
1142
1143   return ot;
1144 }
1145
1146
1147 static void
1148 mark_keyblock_seen (KeyHashTable tbl, KBNODE node)
1149 {
1150   for ( ;node; node = node->next )
1151     if (node->pkt->pkttype == PKT_PUBLIC_KEY
1152         || node->pkt->pkttype == PKT_PUBLIC_SUBKEY)
1153       {
1154         u32 aki[2];
1155
1156         keyid_from_pk (node->pkt->pkt.public_key, aki);
1157         add_key_hash_table (tbl, aki);
1158       }
1159 }
1160
1161
1162
1163 static void
1164 dump_key_array (int depth, struct key_array *keys)
1165 {
1166   struct key_array *kar;
1167
1168   for (kar=keys; kar->keyblock; kar++)
1169     {
1170       KBNODE node = kar->keyblock;
1171       u32 kid[2];
1172
1173       keyid_from_pk(node->pkt->pkt.public_key, kid);
1174       printf ("%d:%08lX%08lX:K::%c::::\n",
1175               depth, (ulong)kid[0], (ulong)kid[1], '?');
1176
1177       for (; node; node = node->next)
1178         {
1179           if (node->pkt->pkttype == PKT_USER_ID)
1180             {
1181               int len = node->pkt->pkt.user_id->len;
1182
1183               if (len > 30)
1184                 len = 30;
1185               printf ("%d:%08lX%08lX:U:::%c:::",
1186                       depth, (ulong)kid[0], (ulong)kid[1],
1187                       (node->flag & 4)? 'f':
1188                       (node->flag & 2)? 'm':
1189                       (node->flag & 1)? 'q':'-');
1190               print_string (stdout,  node->pkt->pkt.user_id->name, len, ':');
1191               putchar (':');
1192               putchar ('\n');
1193             }
1194         }
1195     }
1196 }  
1197
1198
1199 static void
1200 store_validation_status (int depth, KBNODE keyblock)
1201 {
1202   KBNODE node;
1203   byte namehash[20];
1204   int status;
1205   int any = 0;
1206
1207   for (node=keyblock; node; node = node->next)
1208     {
1209       if (node->pkt->pkttype == PKT_USER_ID)
1210         {
1211           PKT_user_id *uid = node->pkt->pkt.user_id;
1212
1213           if (node->flag & 4)
1214             status = TRUST_FULLY;
1215           else if (node->flag & 2)
1216             status = TRUST_MARGINAL;
1217           else if (node->flag & 1)
1218             status = TRUST_UNDEFINED;
1219           else
1220             status = 0;
1221           
1222           if (status)
1223             {
1224               if( uid->attrib_data )
1225                 rmd160_hash_buffer (namehash,uid->attrib_data,uid->attrib_len);
1226               else
1227                 rmd160_hash_buffer (namehash, uid->name, uid->len );
1228               
1229               update_validity (keyblock->pkt->pkt.public_key,
1230                                namehash, depth, status);
1231               any = 1;
1232             }
1233         }
1234     }
1235
1236   if (any)
1237     do_sync ();
1238 }  
1239
1240 /*
1241  * check whether the signature sig is in the klist k
1242  */
1243 static struct key_item *
1244 is_in_klist (struct key_item *k, PKT_signature *sig)
1245 {
1246   for (; k; k = k->next)
1247     {
1248       if (k->kid[0] == sig->keyid[0] && k->kid[1] == sig->keyid[1])
1249         return k;
1250     }
1251   return NULL;
1252 }
1253
1254 /*
1255  * Mark the signature of the given UID which are used to certify it.
1256  * To do this, we first revmove all signatures which are not valid and
1257  * from the remain ones we look for the latest one.  If this is not a
1258  * certification revocation signature we mark the signature by setting
1259  * node flag bit 8.  Note that flag bits 9 and 10 are used for internal
1260  * purposes.  
1261  */
1262 static void
1263 mark_usable_uid_certs (KBNODE keyblock, KBNODE uidnode,
1264                        u32 *main_kid, struct key_item *klist,
1265                        u32 curtime, u32 *next_expire)
1266 {
1267   KBNODE node;
1268   PKT_signature *sig;
1269   
1270   /* first check all signatures */
1271   for (node=uidnode->next; node; node = node->next)
1272     {
1273       node->flag &= ~(1<<8 | 1<<9 | 1<<10);
1274       if (node->pkt->pkttype == PKT_USER_ID
1275           || node->pkt->pkttype == PKT_PUBLIC_SUBKEY)
1276         break; /* ready */
1277       if (node->pkt->pkttype != PKT_SIGNATURE)
1278         continue;
1279       
1280       sig = node->pkt->pkt.signature;
1281       if (sig->keyid[0] == main_kid[0] && sig->keyid[1] == main_kid[1])
1282         continue; /* ignore self-signatures */
1283       if (!IS_UID_SIG(sig) && !IS_UID_REV(sig))
1284         continue; /* we only look at these signature classes */
1285       if (!is_in_klist (klist, sig))
1286         continue;  /* no need to check it then */
1287       if (check_key_signature (keyblock, node, NULL))
1288         continue; /* ignore invalid signatures */
1289       node->flag |= 1<<9;
1290     }      
1291   /* reset the remaining flags */
1292   for (; node; node = node->next)
1293       node->flag &= ~(1<<8 | 1<<9 | 1 << 10);
1294
1295   /* kbnode flag usage: bit 9 is here set for signatures to consider,
1296    * bit 10 will be set by the loop to keep track of keyIDs already
1297    * processed, bit 8 will be set for the usable signatures */
1298
1299   /* for each cert figure out the latest valid one */
1300   for (node=uidnode->next; node; node = node->next)
1301     {
1302       KBNODE n, signode;
1303       u32 kid[2];
1304       u32 sigdate;
1305       
1306       if (node->pkt->pkttype == PKT_PUBLIC_SUBKEY)
1307         break;
1308       if ( !(node->flag & (1<<9)) )
1309         continue; /* not a node to look at */
1310       if ( (node->flag & (1<<10)) )
1311         continue; /* signature with a keyID already processed */
1312       node->flag |= (1<<10); /* mark this node as processed */
1313       sig = node->pkt->pkt.signature;
1314       signode = node;
1315       sigdate = sig->timestamp;
1316       kid[0] = sig->keyid[0]; kid[1] = sig->keyid[1];
1317       for (n=uidnode->next; n; n = n->next)
1318         {
1319           if (n->pkt->pkttype == PKT_PUBLIC_SUBKEY)
1320             break;
1321           if ( !(n->flag & (1<<9)) )
1322             continue;
1323           if ( (n->flag & (1<<10)) )
1324             continue; /* shortcut already processed signatures */
1325           sig = n->pkt->pkt.signature;
1326           if (kid[0] != sig->keyid[0] || kid[1] != sig->keyid[1])
1327             continue;
1328           n->flag |= (1<<10); /* mark this node as processed */
1329
1330           /* If signode is nonrevocable and unexpired and n isn't,
1331              then take signode (skip).  It doesn't matter which is
1332              older: if signode was older then we don't want to take n
1333              as signode is nonrevocable.  If n was older then we're
1334              automatically fine. */
1335           
1336           if(((IS_UID_SIG(signode->pkt->pkt.signature) &&
1337                !signode->pkt->pkt.signature->flags.revocable &&
1338                (signode->pkt->pkt.signature->expiredate==0 ||
1339                 signode->pkt->pkt.signature->expiredate>curtime))) &&
1340              (!(IS_UID_SIG(n->pkt->pkt.signature) &&
1341                 !n->pkt->pkt.signature->flags.revocable &&
1342                 (n->pkt->pkt.signature->expiredate==0 ||
1343                  n->pkt->pkt.signature->expiredate>curtime))))
1344             continue;
1345
1346           /* If n is nonrevocable and unexpired and signode isn't,
1347              then take n.  Again, it doesn't matter which is older: if
1348              n was older then we don't want to take signode as n is
1349              nonrevocable.  If signode was older then we're
1350              automatically fine. */
1351           
1352           if((!(IS_UID_SIG(signode->pkt->pkt.signature) &&
1353                 !signode->pkt->pkt.signature->flags.revocable &&
1354                 (signode->pkt->pkt.signature->expiredate==0 ||
1355                  signode->pkt->pkt.signature->expiredate>curtime))) &&
1356              ((IS_UID_SIG(n->pkt->pkt.signature) &&
1357                !n->pkt->pkt.signature->flags.revocable &&
1358                (n->pkt->pkt.signature->expiredate==0 ||
1359                 n->pkt->pkt.signature->expiredate>curtime))))
1360             {
1361               signode = n;
1362               sigdate = sig->timestamp;
1363               continue;
1364             }
1365
1366           /* At this point, if it's newer, it goes in as the only
1367              remaining possibilities are signode and n are both either
1368              revocable or expired or both nonrevocable and unexpired.
1369              If the timestamps are equal take the later ordered
1370              packet, presuming that the key packets are hopefully in
1371              their original order. */
1372
1373           if (sig->timestamp >= sigdate)
1374             {
1375               signode = n;
1376               sigdate = sig->timestamp;
1377             }
1378         }
1379       sig = signode->pkt->pkt.signature;
1380       if (IS_UID_SIG (sig))
1381         { /* this seems to be a usable one which is not revoked. 
1382            * Just need to check whether there is an expiration time,
1383            * We do the expired certification after finding a suitable
1384            * certification, the assumption is that a signator does not
1385            * want that after the expiration of his certificate the
1386            * system falls back to an older certification which has a
1387            * different expiration time */
1388           const byte *p;
1389           u32 expire;
1390                     
1391           p = parse_sig_subpkt (sig->hashed, SIGSUBPKT_SIG_EXPIRE, NULL );
1392           expire = p? sig->timestamp + buffer_to_u32(p) : 0;
1393
1394           if (expire==0 || expire > curtime )
1395             {
1396               signode->flag |= (1<<8); /* yeah, found a good cert */
1397               if (expire && expire < *next_expire)
1398                 *next_expire = expire;
1399             }
1400         }
1401     }
1402 }
1403
1404 /* Used by validate_one_keyblock to confirm a regexp within a trust
1405    signature.  Returns 1 for match, and 0 for no match or regex
1406    error. */
1407 static int
1408 check_regexp(const char *exp,const char *string)
1409 {
1410 #ifdef DISABLE_REGEXP
1411   /* When DISABLE_REGEXP is defined, assume all regexps do not
1412      match. */
1413   return 0;
1414 #elif defined(__riscos__)
1415   return riscos_check_regexp(exp, string, DBG_TRUST);
1416 #else
1417   int ret;
1418   regex_t pat;
1419
1420   if(regcomp(&pat,exp,REG_ICASE|REG_NOSUB|REG_EXTENDED)!=0)
1421     return 0;
1422
1423   ret=regexec(&pat,string,0,NULL,0);
1424
1425   regfree(&pat);
1426
1427   if(DBG_TRUST)
1428     log_debug("regexp \"%s\" on \"%s\": %s\n",exp,string,ret==0?"YES":"NO");
1429
1430   return (ret==0);
1431 #endif
1432 }
1433
1434 /*
1435  * Return true if the key is signed by one of the keys in the given
1436  * key ID list.  User IDs with a valid signature are marked by node
1437  * flags as follows:
1438  *  flag bit 0: There is at least one signature
1439  *           1: There is marginal confidence that this is a legitimate uid
1440  *           2: There is full confidence that this is a legitimate uid.
1441  *           8: Used for internal purposes.
1442  *           9: Ditto (in mark_usable_uid_certs())
1443  *          10: Ditto (ditto)
1444  * This function assumes that all kbnode flags are cleared on entry.
1445  */
1446 static int
1447 validate_one_keyblock (KBNODE kb, struct key_item *klist,
1448                        u32 curtime, u32 *next_expire)
1449 {
1450   struct key_item *kr;
1451   KBNODE node, uidnode=NULL;
1452   PKT_public_key *pk = kb->pkt->pkt.public_key;
1453   u32 main_kid[2];
1454   int issigned=0, any_signed = 0, fully_count =0, marginal_count = 0;
1455
1456   keyid_from_pk(pk, main_kid);
1457   for (node=kb; node; node = node->next)
1458     {
1459       if (node->pkt->pkttype == PKT_USER_ID)
1460         {
1461           if (uidnode && issigned)
1462             {
1463               if (fully_count >= opt.completes_needed
1464                   || marginal_count >= opt.marginals_needed )
1465                 uidnode->flag |= 4; 
1466               else if (fully_count || marginal_count)
1467                 uidnode->flag |= 2;
1468               uidnode->flag |= 1;
1469               any_signed = 1;
1470             }
1471           uidnode = node;
1472           issigned = 0;
1473           fully_count = marginal_count = 0;
1474           mark_usable_uid_certs (kb, uidnode, main_kid, klist, 
1475                                  curtime, next_expire);
1476         }
1477       else if (node->pkt->pkttype == PKT_SIGNATURE 
1478                && (node->flag & (1<<8)) )
1479         {
1480           /* Note that we are only seeing unrevoked sigs here */
1481           PKT_signature *sig = node->pkt->pkt.signature;
1482           
1483           kr = is_in_klist (klist, sig);
1484           /* If the trust_regexp does not match, it's as if the sig
1485              did not exist.  This is safe for non-trust sigs as well
1486              since we don't accept a regexp on the sig unless it's a
1487              trust sig. */
1488           if (kr && (kr->trust_regexp==NULL || opt.trust_model!=TM_OPENPGP ||
1489                      (uidnode && check_regexp(kr->trust_regexp,
1490                                             uidnode->pkt->pkt.user_id->name))))
1491             {
1492               if(DBG_TRUST && opt.trust_model==TM_OPENPGP && sig->trust_depth)
1493                 log_debug("trust sig on %s, sig depth is %d, kr depth is %d\n",
1494                           uidnode->pkt->pkt.user_id->name,sig->trust_depth,
1495                           kr->trust_depth);
1496
1497               /* Are we part of a trust sig chain?  We always favor
1498                  the latest trust sig, rather than the greater or
1499                  lesser trust sig or value.  I could make a decent
1500                  argument for any of these cases, but this seems to be
1501                  what PGP does, and I'd like to be compatible. -dms */
1502               if(opt.trust_model==TM_OPENPGP && sig->trust_depth
1503                  && pk->trust_timestamp<=sig->timestamp
1504                  && (sig->trust_depth<=kr->trust_depth
1505                      || kr->ownertrust==TRUST_ULTIMATE))
1506                 {
1507                   /* If we got here, we know that:
1508
1509                      this is a trust sig.
1510
1511                      it's a newer trust sig than any previous trust
1512                      sig on this key (not uid).
1513
1514                      it is legal in that it was either generated by an
1515                      ultimate key, or a key that was part of a trust
1516                      chain, and the depth does not violate the
1517                      original trust sig.
1518
1519                      if there is a regexp attached, it matched
1520                      successfully.
1521                   */
1522
1523                   if(DBG_TRUST)
1524                     log_debug("replacing trust value %d with %d and "
1525                               "depth %d with %d\n",
1526                               pk->trust_value,sig->trust_value,
1527                               pk->trust_depth,sig->trust_depth);
1528
1529                   pk->trust_value=sig->trust_value;
1530                   pk->trust_depth=sig->trust_depth-1;
1531
1532                   /* If the trust sig contains a regexp, record it
1533                      on the pk for the next round. */
1534                   if(sig->trust_regexp)
1535                     pk->trust_regexp=sig->trust_regexp;
1536                 }
1537
1538               if (kr->ownertrust == TRUST_ULTIMATE)
1539                 fully_count = opt.completes_needed;
1540               else if (kr->ownertrust == TRUST_FULLY)
1541                 fully_count++;
1542               else if (kr->ownertrust == TRUST_MARGINAL)
1543                 marginal_count++;
1544               issigned = 1;
1545             }
1546         }
1547     }
1548
1549   if (uidnode && issigned)
1550     {
1551       if (fully_count >= opt.completes_needed
1552                || marginal_count >= opt.marginals_needed )
1553         uidnode->flag |= 4; 
1554       else if (fully_count || marginal_count)
1555         uidnode->flag |= 2;
1556       uidnode->flag |= 1;
1557       any_signed = 1;
1558     }
1559
1560   return any_signed;
1561 }
1562
1563
1564 static int
1565 search_skipfnc (void *opaque, u32 *kid)
1566 {
1567   return test_key_hash_table ((KeyHashTable)opaque, kid);
1568 }
1569
1570
1571 /*
1572  * Scan all keys and return a key_array of all suitable keys from
1573  * kllist.  The caller has to pass keydb handle so that we don't use
1574  * to create our own.  Returns either a key_array or NULL in case of
1575  * an error.  No results found are indicated by an empty array.
1576  * Caller hast to release the returned array.  
1577  */
1578 static struct key_array *
1579 validate_key_list (KEYDB_HANDLE hd, KeyHashTable visited,
1580                    struct key_item *klist, u32 curtime, u32 *next_expire)
1581 {
1582   KBNODE keyblock = NULL;
1583   struct key_array *keys = NULL;
1584   size_t nkeys, maxkeys;
1585   int rc;
1586   KEYDB_SEARCH_DESC desc;
1587   
1588   maxkeys = 1000;
1589   keys = m_alloc ((maxkeys+1) * sizeof *keys);
1590   nkeys = 0;
1591   
1592   rc = keydb_search_reset (hd);
1593   if (rc)
1594     {
1595       log_error ("keydb_search_reset failed: %s\n", g10_errstr(rc));
1596       m_free (keys);
1597       return NULL;
1598     }
1599
1600   memset (&desc, 0, sizeof desc);
1601   desc.mode = KEYDB_SEARCH_MODE_FIRST;
1602   desc.skipfnc = search_skipfnc;
1603   desc.skipfncvalue = visited;
1604   rc = keydb_search (hd, &desc, 1);
1605   if (rc == -1)
1606     {
1607       keys[nkeys].keyblock = NULL;
1608       return keys;
1609     }
1610   if (rc)
1611     {
1612       log_error ("keydb_search_first failed: %s\n", g10_errstr(rc));
1613       m_free (keys);
1614       return NULL;
1615     }
1616   
1617   desc.mode = KEYDB_SEARCH_MODE_NEXT; /* change mode */
1618   do
1619     {
1620       PKT_public_key *pk;
1621         
1622       rc = keydb_get_keyblock (hd, &keyblock);
1623       if (rc) 
1624         {
1625           log_error ("keydb_get_keyblock failed: %s\n", g10_errstr(rc));
1626           m_free (keys);
1627           return NULL;
1628         }
1629       
1630       if ( keyblock->pkt->pkttype != PKT_PUBLIC_KEY) 
1631         {
1632           log_debug ("ooops: invalid pkttype %d encountered\n",
1633                      keyblock->pkt->pkttype);
1634           dump_kbnode (keyblock);
1635           release_kbnode(keyblock);
1636           continue;
1637         }
1638
1639       /* prepare the keyblock for further processing */
1640       merge_keys_and_selfsig (keyblock); 
1641       clear_kbnode_flags (keyblock);
1642       pk = keyblock->pkt->pkt.public_key;
1643       if (pk->has_expired || pk->is_revoked)
1644         {
1645           /* it does not make sense to look further at those keys */
1646           mark_keyblock_seen (visited, keyblock);
1647         }
1648       else if (validate_one_keyblock (keyblock, klist, curtime, next_expire))
1649         {
1650           if (pk->expiredate && pk->expiredate >= curtime
1651               && pk->expiredate < *next_expire)
1652             *next_expire = pk->expiredate;
1653
1654           if (nkeys == maxkeys) {
1655             maxkeys += 1000;
1656             keys = m_realloc (keys, (maxkeys+1) * sizeof *keys);
1657           }
1658           keys[nkeys++].keyblock = keyblock;
1659           /* this key is signed - don't check it again */
1660           mark_keyblock_seen (visited, keyblock);
1661           keyblock = NULL;
1662         }
1663
1664       release_kbnode (keyblock);
1665       keyblock = NULL;
1666     } 
1667   while ( !(rc = keydb_search (hd, &desc, 1)) );
1668   if (rc && rc != -1) 
1669     {
1670       log_error ("keydb_search_next failed: %s\n", g10_errstr(rc));
1671       m_free (keys);
1672       return NULL;
1673     }
1674
1675   keys[nkeys].keyblock = NULL;
1676   return keys;
1677
1678
1679
1680 static void
1681 reset_unconnected_keys (KEYDB_HANDLE hd, KeyHashTable visited)
1682 {
1683   int rc;
1684   KBNODE keyblock = NULL;
1685   KEYDB_SEARCH_DESC desc;
1686   int count = 0, nreset = 0;
1687   
1688   rc = keydb_search_reset (hd);
1689   if (rc)
1690     {
1691       log_error ("keydb_search_reset failed: %s\n", g10_errstr(rc));
1692       return;
1693     }
1694
1695   memset (&desc, 0, sizeof desc);
1696   desc.mode = KEYDB_SEARCH_MODE_FIRST;
1697   desc.skipfnc = search_skipfnc;
1698   desc.skipfncvalue = visited;
1699   rc = keydb_search (hd, &desc, 1);
1700   if (rc && rc != -1 )
1701     log_error ("keydb_search_first failed: %s\n", g10_errstr(rc));
1702   else if (!rc)
1703     {
1704       desc.mode = KEYDB_SEARCH_MODE_NEXT; /* change mode */
1705       do
1706         {
1707           rc = keydb_get_keyblock (hd, &keyblock);
1708           if (rc) 
1709             {
1710               log_error ("keydb_get_keyblock failed: %s\n", g10_errstr(rc));
1711               break;
1712             }
1713           count++;
1714
1715           if (keyblock->pkt->pkttype == PKT_PUBLIC_KEY) /* paranoid assertion*/
1716             {
1717               nreset += clear_validity (keyblock->pkt->pkt.public_key);
1718               release_kbnode (keyblock);
1719             } 
1720         }
1721       while ( !(rc = keydb_search (hd, &desc, 1)) );
1722       if (rc && rc != -1) 
1723         log_error ("keydb_search_next failed: %s\n", g10_errstr(rc));
1724     }
1725   if (opt.verbose)
1726     log_info ("%d unconnected keys (%d trust records cleared)\n",
1727               count, nreset);
1728   do_sync ();
1729
1730
1731
1732 /*
1733  * Run the key validation procedure.
1734  *
1735  * This works this way:
1736  * Step 1: Find all ultimately trusted keys (UTK).
1737  *         mark them all as seen and put them into klist.
1738  * Step 2: loop max_cert_times
1739  * Step 3:   if OWNERTRUST of any key in klist is undefined
1740  *             ask user to assign ownertrust
1741  * Step 4:   Loop over all keys in the keyDB which are not marked seen 
1742  * Step 5:     if key is revoked or expired
1743  *                mark key as seen
1744  *                continue loop at Step 4
1745  * Step 6:     For each user ID of that key signed by a key in klist
1746  *                Calculate validity by counting trusted signatures.
1747  *                Set validity of user ID
1748  * Step 7:     If any signed user ID was found
1749  *                mark key as seen
1750  *             End Loop
1751  * Step 8:   Build a new klist from all fully trusted keys from step 6
1752  *           End Loop
1753  *         Ready  
1754  *
1755  */
1756 static int
1757 validate_keys (int interactive)
1758 {
1759   int rc = 0;
1760   int quit=0;
1761   struct key_item *klist = NULL;
1762   struct key_item *k;
1763   struct key_array *keys = NULL;
1764   struct key_array *kar;
1765   KEYDB_HANDLE kdb = NULL;
1766   KBNODE node;
1767   int depth;
1768   int key_count;
1769   int ot_unknown, ot_undefined, ot_never, ot_marginal, ot_full, ot_ultimate;
1770   KeyHashTable visited;
1771   u32 start_time, next_expire;
1772
1773   start_time = make_timestamp ();
1774   next_expire = 0xffffffff; /* set next expire to the year 2106 */
1775   visited = new_key_hash_table ();
1776   /* Fixme: Instead of always building a UTK list, we could just build it
1777    * here when needed */
1778   if (!utk_list)
1779     {
1780       log_info ("no ultimately trusted keys found\n");
1781       goto leave;
1782     }
1783
1784   /* mark all UTKs as visited and set validity to ultimate */
1785   for (k=utk_list; k; k = k->next)
1786     {
1787       KBNODE keyblock;
1788       PKT_public_key *pk;
1789
1790       keyblock = get_pubkeyblock (k->kid);
1791       if (!keyblock)
1792         {
1793           log_error (_("public key of ultimately"
1794                        " trusted key %08lX not found\n"), (ulong)k->kid[1]);
1795           continue;
1796         }
1797       mark_keyblock_seen (visited, keyblock);
1798       pk = keyblock->pkt->pkt.public_key;
1799       for (node=keyblock; node; node = node->next)
1800         {
1801           if (node->pkt->pkttype == PKT_USER_ID)
1802             {
1803               byte namehash[20];
1804               PKT_user_id *uid = node->pkt->pkt.user_id;
1805               
1806               if( uid->attrib_data )
1807                 rmd160_hash_buffer (namehash,uid->attrib_data,uid->attrib_len);
1808               else
1809                 rmd160_hash_buffer (namehash, uid->name, uid->len );
1810               update_validity (pk, namehash, 0, TRUST_ULTIMATE);
1811             }
1812         }
1813       if ( pk->expiredate && pk->expiredate >= start_time
1814            && pk->expiredate < next_expire)
1815         next_expire = pk->expiredate;
1816       
1817       release_kbnode (keyblock);
1818       do_sync ();
1819     }
1820
1821   klist = utk_list;
1822   kdb = keydb_new (0);
1823
1824   log_info(_("%d marginal(s) needed, %d complete(s) needed, %s trust model\n"),
1825            opt.marginals_needed,opt.completes_needed,
1826            opt.trust_model==TM_CLASSIC?"Classic":
1827                           opt.trust_model==TM_OPENPGP?"OpenPGP":"unknown");
1828
1829   for (depth=0; depth < opt.max_cert_depth; depth++)
1830     {
1831       /* See whether we should assign ownertrust values to the keys in
1832          utk_list.  */
1833       ot_unknown = ot_undefined = ot_never = 0;
1834       ot_marginal = ot_full = ot_ultimate = 0;
1835       for (k=klist; k; k = k->next)
1836         {
1837           int min=0;
1838
1839           /* 120 and 60 are as per RFC2440 */
1840           if(k->trust_value>=120)
1841             min=TRUST_FULLY;
1842           else if(k->trust_value>=60)
1843             min=TRUST_MARGINAL;
1844
1845           if(min!=k->min_ownertrust)
1846             update_min_ownertrust(k->kid,min);
1847
1848           if (interactive && k->ownertrust == TRUST_UNKNOWN)
1849             {
1850               k->ownertrust = ask_ownertrust (k->kid,min);
1851
1852               if (k->ownertrust == -1)
1853                 {
1854                   quit=1;
1855                   goto leave;
1856                 }
1857             }
1858
1859           /* This can happen during transition from an old trustdb
1860              before trust sigs.  It can also happen if a user uses two
1861              different versions of GnuPG or changes the --trust-model
1862              setting. */
1863           if(k->ownertrust<min)
1864             {
1865               if(DBG_TRUST)
1866                 log_debug("key %08lX: "
1867                           "overriding ownertrust \"%s\" with \"%s\"\n",
1868                           (ulong)k->kid[1],
1869                           trust_string(k->ownertrust),trust_string(min));
1870
1871               k->ownertrust=min;
1872             }
1873
1874           if (k->ownertrust == TRUST_UNKNOWN)
1875             ot_unknown++;
1876           else if (k->ownertrust == TRUST_UNDEFINED)
1877             ot_undefined++;
1878           else if (k->ownertrust == TRUST_NEVER)
1879             ot_never++;
1880           else if (k->ownertrust == TRUST_MARGINAL)
1881             ot_marginal++;
1882           else if (k->ownertrust == TRUST_FULLY)
1883             ot_full++;
1884           else if (k->ownertrust == TRUST_ULTIMATE)
1885             ot_ultimate++;
1886         }
1887
1888       /* Find all keys which are signed by a key in kdlist */
1889       keys = validate_key_list (kdb, visited, klist, start_time, &next_expire);
1890       if (!keys) 
1891         {
1892           log_error ("validate_key_list failed\n");
1893           rc = G10ERR_GENERAL;
1894           goto leave;
1895         }
1896
1897       for (key_count=0, kar=keys; kar->keyblock; kar++, key_count++)
1898         ;
1899
1900       /* Store the calculated valididation status somewhere */
1901       if (opt.verbose > 1)
1902         dump_key_array (depth, keys);
1903
1904       log_info (_("checking at depth %d signed=%d"
1905                   " ot(-/q/n/m/f/u)=%d/%d/%d/%d/%d/%d\n"), 
1906                 depth, key_count, ot_unknown, ot_undefined,
1907                 ot_never, ot_marginal, ot_full, ot_ultimate ); 
1908
1909       for (kar=keys; kar->keyblock; kar++)
1910           store_validation_status (depth, kar->keyblock);
1911
1912       /* Build a new kdlist from all fully valid keys in KEYS */
1913       if (klist != utk_list)
1914         release_key_items (klist);
1915       klist = NULL;
1916       for (kar=keys; kar->keyblock; kar++)
1917         {
1918           for (node=kar->keyblock; node; node = node->next)
1919             {
1920               if (node->pkt->pkttype == PKT_USER_ID && (node->flag & 4))
1921                 {
1922                   k = new_key_item ();
1923                   keyid_from_pk (kar->keyblock->pkt->pkt.public_key, k->kid);
1924                   k->ownertrust = get_ownertrust (kar->keyblock
1925                                                   ->pkt->pkt.public_key);
1926                   k->min_ownertrust = get_min_ownertrust (kar->keyblock
1927                                                         ->pkt->pkt.public_key);
1928                   k->trust_depth=
1929                     kar->keyblock->pkt->pkt.public_key->trust_depth;
1930                   k->trust_value=
1931                     kar->keyblock->pkt->pkt.public_key->trust_value;
1932                   if(kar->keyblock->pkt->pkt.public_key->trust_regexp)
1933                     k->trust_regexp=
1934                       m_strdup(kar->keyblock->pkt->
1935                                pkt.public_key->trust_regexp);
1936                   k->next = klist;
1937                   klist = k;
1938                   break;
1939                 }
1940             }
1941         }
1942       release_key_array (keys);
1943       keys = NULL;
1944       if (!klist)
1945         break; /* no need to dive in deeper */
1946     }
1947
1948   reset_unconnected_keys (kdb, visited);
1949
1950  leave:
1951   keydb_release (kdb);
1952   release_key_array (keys);
1953   release_key_items (klist);
1954   release_key_hash_table (visited);
1955   if (!rc && !quit) /* mark trustDB as checked */
1956     {
1957       if (next_expire == 0xffffffff || next_expire < start_time )
1958         tdbio_write_nextcheck (0); 
1959       else
1960         {
1961           tdbio_write_nextcheck (next_expire); 
1962           log_info (_("next trustdb check due at %s\n"),
1963                     strtimestamp (next_expire));
1964         }
1965
1966       if(tdbio_update_version_record()!=0)
1967         {
1968           log_error(_("unable to update trustdb version record: "
1969                       "write failed: %s\n"), g10_errstr(rc));
1970           tdbio_invalid();
1971         }
1972
1973       do_sync ();
1974       pending_check_trustdb = 0;
1975     }
1976   return rc;
1977 }