* keydb.h, getkey.c (key_byname): Flag to enable or disable including
[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   /* Note that get_pubkey returns the main key if keyid points to a
908      subkey. That's a good thing here. */
909   rc = get_pubkey(pk, keyid);
910   if(rc)
911     {
912       log_error("error checking disabled status of %08lX: %s\n",
913                 (ulong)keyid[1],g10_errstr(rc));
914       goto leave;
915     }
916  
917   rc = read_trust_record (pk, &trec);
918   if (rc && rc != -1)
919     {
920       tdbio_invalid ();
921       goto leave;
922     }
923   if (rc == -1) /* no record found, so assume not disabled */
924     goto leave;
925  
926   if(trec.r.trust.ownertrust & TRUST_FLAG_DISABLED)
927     disabled=1;
928  
929  leave:
930   free_public_key(pk);
931   return disabled;
932 }
933
934 /*
935  * Return the validity information for PK.  If the namehash is not
936  * NULL, the validity of the corresponsing user ID is returned,
937  * otherwise, a reasonable value for the entire key is returned. 
938  */
939 unsigned int
940 get_validity (PKT_public_key *pk, const byte *namehash)
941 {
942   static int did_nextcheck;
943   TRUSTREC trec, vrec;
944   int rc;
945   ulong recno;
946   unsigned int validity;
947   u32 kid[2];
948   PKT_public_key *main_pk;
949
950   init_trustdb ();
951   if (!did_nextcheck)
952     {
953       ulong scheduled;
954
955       did_nextcheck = 1;
956       scheduled = tdbio_read_nextcheck ();
957       if (scheduled && scheduled <= make_timestamp ())
958         {
959           if (opt.no_auto_check_trustdb) 
960             {
961               pending_check_trustdb = 1;
962               log_info ("please do a --check-trustdb\n");
963             }
964           else
965             {
966               log_info (_("checking the trustdb\n"));
967               validate_keys (0);
968             }
969         }
970     }
971
972   keyid_from_pk (pk, kid);
973   if (pk->main_keyid[0] != kid[0] || pk->main_keyid[1] != kid[1])
974     { /* this is a subkey - get the mainkey */
975       main_pk = m_alloc_clear (sizeof *main_pk);
976       rc = get_pubkey (main_pk, pk->main_keyid);
977       if (rc)
978         {
979           log_error ("error getting main key %08lX of subkey %08lX: %s\n",
980                      (ulong)pk->main_keyid[1], (ulong)kid[1], g10_errstr(rc));
981           validity = TRUST_UNKNOWN; 
982           goto leave;
983         }
984     }
985   else
986     main_pk = pk;
987
988   rc = read_trust_record (main_pk, &trec);
989   if (rc && rc != -1)
990     {
991       tdbio_invalid ();
992       return 0;
993     }
994   if (rc == -1) /* no record found */
995     {
996       validity = TRUST_UNKNOWN; 
997       goto leave;
998     }
999
1000   /* loop over all user IDs */
1001   recno = trec.r.trust.validlist;
1002   validity = 0;
1003   while (recno)
1004     {
1005       read_record (recno, &vrec, RECTYPE_VALID);
1006       if ( validity < (vrec.r.valid.validity & TRUST_MASK) )
1007         validity = (vrec.r.valid.validity & TRUST_MASK);
1008       if ( namehash && !memcmp (vrec.r.valid.namehash, namehash, 20) )
1009         break;
1010       recno = vrec.r.valid.next;
1011     }
1012   
1013   if (recno) /* okay, use the user ID associated one */
1014     validity = (vrec.r.valid.validity & TRUST_MASK);
1015
1016   if ( (trec.r.trust.ownertrust & TRUST_FLAG_DISABLED) )
1017     validity |= TRUST_FLAG_DISABLED;
1018
1019  leave:
1020   /* set some flags direct from the key */
1021   if (main_pk->is_revoked)
1022     validity |= TRUST_FLAG_REVOKED;
1023   if (main_pk != pk && pk->is_revoked)
1024     validity |= TRUST_FLAG_SUB_REVOKED;
1025   /* Note: expiration is a trust value and not a flag - don't know why
1026    * I initially designed it that way */
1027   if (main_pk->has_expired || pk->has_expired)
1028     validity = (validity & ~TRUST_MASK) | TRUST_EXPIRED;
1029   
1030   if (pending_check_trustdb)
1031     validity |= TRUST_FLAG_PENDING_CHECK;
1032
1033   if (main_pk != pk)
1034     free_public_key (main_pk);
1035   return validity;
1036 }
1037
1038
1039 int
1040 get_validity_info (PKT_public_key *pk, const byte *namehash)
1041 {
1042     int trustlevel;
1043     int c;
1044
1045     trustlevel = get_validity (pk, namehash);
1046     if( trustlevel & TRUST_FLAG_DISABLED )
1047         return 'd';
1048     if( trustlevel & TRUST_FLAG_REVOKED )
1049         return 'r';
1050     c = trust_letter ( (trustlevel & TRUST_MASK) );
1051     if( !c )
1052         c = '?';
1053     return c;
1054 }
1055
1056
1057
1058
1059 void
1060 list_trust_path( const char *username )
1061 {
1062 }
1063
1064
1065
1066
1067 /****************
1068  * Enumerate all keys, which are needed to build all trust paths for
1069  * the given key.  This function does not return the key itself or
1070  * the ultimate key (the last point in cerificate chain).  Only
1071  * certificate chains which ends up at an ultimately trusted key
1072  * are listed.  If ownertrust or validity is not NULL, the corresponding
1073  * value for the returned LID is also returned in these variable(s).
1074  *
1075  *  1) create a void pointer and initialize it to NULL
1076  *  2) pass this void pointer by reference to this function.
1077  *     Set lid to the key you want to enumerate and pass it by reference.
1078  *  3) call this function as long as it does not return -1
1079  *     to indicate EOF. LID does contain the next key used to build the web
1080  *  4) Always call this function a last time with LID set to NULL,
1081  *     so that it can free its context.
1082  *
1083  * Returns: -1 on EOF or the level of the returned LID
1084  */
1085 int
1086 enum_cert_paths( void **context, ulong *lid,
1087                  unsigned *ownertrust, unsigned *validity )
1088 {
1089     return -1;
1090 }
1091
1092
1093 /****************
1094  * Print the current path
1095  */
1096 void
1097 enum_cert_paths_print( void **context, FILE *fp,
1098                                        int refresh, ulong selected_lid )
1099 {
1100     return;
1101 }
1102
1103
1104 \f
1105 /****************************************
1106  *********** NEW NEW NEW ****************
1107  ****************************************/
1108
1109 static int
1110 ask_ownertrust (u32 *kid,int minimum)
1111 {
1112   PKT_public_key *pk;
1113   int rc;
1114   int ot;
1115
1116   pk = m_alloc_clear (sizeof *pk);
1117   rc = get_pubkey (pk, kid);
1118   if (rc)
1119     {
1120       log_error (_("public key %08lX not found: %s\n"),
1121                  (ulong)kid[1], g10_errstr(rc) );
1122       return TRUST_UNKNOWN;
1123     }
1124  
1125   if(opt.force_ownertrust)
1126     {
1127       log_info("force trust for key %08lX to %s\n",(ulong)kid[1],
1128                trust_string(opt.force_ownertrust));
1129       update_ownertrust(pk,opt.force_ownertrust);
1130       ot=opt.force_ownertrust;
1131     }
1132   else
1133     {
1134       ot=edit_ownertrust(pk,0);
1135       if(ot>0)
1136         ot = get_ownertrust (pk);
1137       else if(ot==0)
1138         ot = minimum?minimum:TRUST_UNDEFINED;
1139       else
1140         ot = -1; /* quit */
1141     }
1142
1143   free_public_key( pk );
1144
1145   return ot;
1146 }
1147
1148
1149 static void
1150 mark_keyblock_seen (KeyHashTable tbl, KBNODE node)
1151 {
1152   for ( ;node; node = node->next )
1153     if (node->pkt->pkttype == PKT_PUBLIC_KEY
1154         || node->pkt->pkttype == PKT_PUBLIC_SUBKEY)
1155       {
1156         u32 aki[2];
1157
1158         keyid_from_pk (node->pkt->pkt.public_key, aki);
1159         add_key_hash_table (tbl, aki);
1160       }
1161 }
1162
1163
1164
1165 static void
1166 dump_key_array (int depth, struct key_array *keys)
1167 {
1168   struct key_array *kar;
1169
1170   for (kar=keys; kar->keyblock; kar++)
1171     {
1172       KBNODE node = kar->keyblock;
1173       u32 kid[2];
1174
1175       keyid_from_pk(node->pkt->pkt.public_key, kid);
1176       printf ("%d:%08lX%08lX:K::%c::::\n",
1177               depth, (ulong)kid[0], (ulong)kid[1], '?');
1178
1179       for (; node; node = node->next)
1180         {
1181           if (node->pkt->pkttype == PKT_USER_ID)
1182             {
1183               int len = node->pkt->pkt.user_id->len;
1184
1185               if (len > 30)
1186                 len = 30;
1187               printf ("%d:%08lX%08lX:U:::%c:::",
1188                       depth, (ulong)kid[0], (ulong)kid[1],
1189                       (node->flag & 4)? 'f':
1190                       (node->flag & 2)? 'm':
1191                       (node->flag & 1)? 'q':'-');
1192               print_string (stdout,  node->pkt->pkt.user_id->name, len, ':');
1193               putchar (':');
1194               putchar ('\n');
1195             }
1196         }
1197     }
1198 }  
1199
1200
1201 static void
1202 store_validation_status (int depth, KBNODE keyblock)
1203 {
1204   KBNODE node;
1205   byte namehash[20];
1206   int status;
1207   int any = 0;
1208
1209   for (node=keyblock; node; node = node->next)
1210     {
1211       if (node->pkt->pkttype == PKT_USER_ID)
1212         {
1213           PKT_user_id *uid = node->pkt->pkt.user_id;
1214
1215           if (node->flag & 4)
1216             status = TRUST_FULLY;
1217           else if (node->flag & 2)
1218             status = TRUST_MARGINAL;
1219           else if (node->flag & 1)
1220             status = TRUST_UNDEFINED;
1221           else
1222             status = 0;
1223           
1224           if (status)
1225             {
1226               if( uid->attrib_data )
1227                 rmd160_hash_buffer (namehash,uid->attrib_data,uid->attrib_len);
1228               else
1229                 rmd160_hash_buffer (namehash, uid->name, uid->len );
1230               
1231               update_validity (keyblock->pkt->pkt.public_key,
1232                                namehash, depth, status);
1233               any = 1;
1234             }
1235         }
1236     }
1237
1238   if (any)
1239     do_sync ();
1240 }  
1241
1242 /*
1243  * check whether the signature sig is in the klist k
1244  */
1245 static struct key_item *
1246 is_in_klist (struct key_item *k, PKT_signature *sig)
1247 {
1248   for (; k; k = k->next)
1249     {
1250       if (k->kid[0] == sig->keyid[0] && k->kid[1] == sig->keyid[1])
1251         return k;
1252     }
1253   return NULL;
1254 }
1255
1256 /*
1257  * Mark the signature of the given UID which are used to certify it.
1258  * To do this, we first revmove all signatures which are not valid and
1259  * from the remain ones we look for the latest one.  If this is not a
1260  * certification revocation signature we mark the signature by setting
1261  * node flag bit 8.  Note that flag bits 9 and 10 are used for internal
1262  * purposes.  
1263  */
1264 static void
1265 mark_usable_uid_certs (KBNODE keyblock, KBNODE uidnode,
1266                        u32 *main_kid, struct key_item *klist,
1267                        u32 curtime, u32 *next_expire)
1268 {
1269   KBNODE node;
1270   PKT_signature *sig;
1271   
1272   /* first check all signatures */
1273   for (node=uidnode->next; node; node = node->next)
1274     {
1275       node->flag &= ~(1<<8 | 1<<9 | 1<<10);
1276       if (node->pkt->pkttype == PKT_USER_ID
1277           || node->pkt->pkttype == PKT_PUBLIC_SUBKEY)
1278         break; /* ready */
1279       if (node->pkt->pkttype != PKT_SIGNATURE)
1280         continue;
1281       
1282       sig = node->pkt->pkt.signature;
1283       if (sig->keyid[0] == main_kid[0] && sig->keyid[1] == main_kid[1])
1284         continue; /* ignore self-signatures */
1285       if (!IS_UID_SIG(sig) && !IS_UID_REV(sig))
1286         continue; /* we only look at these signature classes */
1287       if (!is_in_klist (klist, sig))
1288         continue;  /* no need to check it then */
1289       if (check_key_signature (keyblock, node, NULL))
1290         continue; /* ignore invalid signatures */
1291       node->flag |= 1<<9;
1292     }      
1293   /* reset the remaining flags */
1294   for (; node; node = node->next)
1295       node->flag &= ~(1<<8 | 1<<9 | 1 << 10);
1296
1297   /* kbnode flag usage: bit 9 is here set for signatures to consider,
1298    * bit 10 will be set by the loop to keep track of keyIDs already
1299    * processed, bit 8 will be set for the usable signatures */
1300
1301   /* for each cert figure out the latest valid one */
1302   for (node=uidnode->next; node; node = node->next)
1303     {
1304       KBNODE n, signode;
1305       u32 kid[2];
1306       u32 sigdate;
1307       
1308       if (node->pkt->pkttype == PKT_PUBLIC_SUBKEY)
1309         break;
1310       if ( !(node->flag & (1<<9)) )
1311         continue; /* not a node to look at */
1312       if ( (node->flag & (1<<10)) )
1313         continue; /* signature with a keyID already processed */
1314       node->flag |= (1<<10); /* mark this node as processed */
1315       sig = node->pkt->pkt.signature;
1316       signode = node;
1317       sigdate = sig->timestamp;
1318       kid[0] = sig->keyid[0]; kid[1] = sig->keyid[1];
1319       for (n=uidnode->next; n; n = n->next)
1320         {
1321           if (n->pkt->pkttype == PKT_PUBLIC_SUBKEY)
1322             break;
1323           if ( !(n->flag & (1<<9)) )
1324             continue;
1325           if ( (n->flag & (1<<10)) )
1326             continue; /* shortcut already processed signatures */
1327           sig = n->pkt->pkt.signature;
1328           if (kid[0] != sig->keyid[0] || kid[1] != sig->keyid[1])
1329             continue;
1330           n->flag |= (1<<10); /* mark this node as processed */
1331
1332           /* If signode is nonrevocable and unexpired and n isn't,
1333              then take signode (skip).  It doesn't matter which is
1334              older: if signode was older then we don't want to take n
1335              as signode is nonrevocable.  If n was older then we're
1336              automatically fine. */
1337           
1338           if(((IS_UID_SIG(signode->pkt->pkt.signature) &&
1339                !signode->pkt->pkt.signature->flags.revocable &&
1340                (signode->pkt->pkt.signature->expiredate==0 ||
1341                 signode->pkt->pkt.signature->expiredate>curtime))) &&
1342              (!(IS_UID_SIG(n->pkt->pkt.signature) &&
1343                 !n->pkt->pkt.signature->flags.revocable &&
1344                 (n->pkt->pkt.signature->expiredate==0 ||
1345                  n->pkt->pkt.signature->expiredate>curtime))))
1346             continue;
1347
1348           /* If n is nonrevocable and unexpired and signode isn't,
1349              then take n.  Again, it doesn't matter which is older: if
1350              n was older then we don't want to take signode as n is
1351              nonrevocable.  If signode was older then we're
1352              automatically fine. */
1353           
1354           if((!(IS_UID_SIG(signode->pkt->pkt.signature) &&
1355                 !signode->pkt->pkt.signature->flags.revocable &&
1356                 (signode->pkt->pkt.signature->expiredate==0 ||
1357                  signode->pkt->pkt.signature->expiredate>curtime))) &&
1358              ((IS_UID_SIG(n->pkt->pkt.signature) &&
1359                !n->pkt->pkt.signature->flags.revocable &&
1360                (n->pkt->pkt.signature->expiredate==0 ||
1361                 n->pkt->pkt.signature->expiredate>curtime))))
1362             {
1363               signode = n;
1364               sigdate = sig->timestamp;
1365               continue;
1366             }
1367
1368           /* At this point, if it's newer, it goes in as the only
1369              remaining possibilities are signode and n are both either
1370              revocable or expired or both nonrevocable and unexpired.
1371              If the timestamps are equal take the later ordered
1372              packet, presuming that the key packets are hopefully in
1373              their original order. */
1374
1375           if (sig->timestamp >= sigdate)
1376             {
1377               signode = n;
1378               sigdate = sig->timestamp;
1379             }
1380         }
1381       sig = signode->pkt->pkt.signature;
1382       if (IS_UID_SIG (sig))
1383         { /* this seems to be a usable one which is not revoked. 
1384            * Just need to check whether there is an expiration time,
1385            * We do the expired certification after finding a suitable
1386            * certification, the assumption is that a signator does not
1387            * want that after the expiration of his certificate the
1388            * system falls back to an older certification which has a
1389            * different expiration time */
1390           const byte *p;
1391           u32 expire;
1392                     
1393           p = parse_sig_subpkt (sig->hashed, SIGSUBPKT_SIG_EXPIRE, NULL );
1394           expire = p? sig->timestamp + buffer_to_u32(p) : 0;
1395
1396           if (expire==0 || expire > curtime )
1397             {
1398               signode->flag |= (1<<8); /* yeah, found a good cert */
1399               if (expire && expire < *next_expire)
1400                 *next_expire = expire;
1401             }
1402         }
1403     }
1404 }
1405
1406 /* Used by validate_one_keyblock to confirm a regexp within a trust
1407    signature.  Returns 1 for match, and 0 for no match or regex
1408    error. */
1409 static int
1410 check_regexp(const char *exp,const char *string)
1411 {
1412 #ifdef DISABLE_REGEXP
1413   /* When DISABLE_REGEXP is defined, assume all regexps do not
1414      match. */
1415   return 0;
1416 #elif defined(__riscos__)
1417   return riscos_check_regexp(exp, string, DBG_TRUST);
1418 #else
1419   int ret;
1420   regex_t pat;
1421
1422   if(regcomp(&pat,exp,REG_ICASE|REG_NOSUB|REG_EXTENDED)!=0)
1423     return 0;
1424
1425   ret=regexec(&pat,string,0,NULL,0);
1426
1427   regfree(&pat);
1428
1429   if(DBG_TRUST)
1430     log_debug("regexp \"%s\" on \"%s\": %s\n",exp,string,ret==0?"YES":"NO");
1431
1432   return (ret==0);
1433 #endif
1434 }
1435
1436 /*
1437  * Return true if the key is signed by one of the keys in the given
1438  * key ID list.  User IDs with a valid signature are marked by node
1439  * flags as follows:
1440  *  flag bit 0: There is at least one signature
1441  *           1: There is marginal confidence that this is a legitimate uid
1442  *           2: There is full confidence that this is a legitimate uid.
1443  *           8: Used for internal purposes.
1444  *           9: Ditto (in mark_usable_uid_certs())
1445  *          10: Ditto (ditto)
1446  * This function assumes that all kbnode flags are cleared on entry.
1447  */
1448 static int
1449 validate_one_keyblock (KBNODE kb, struct key_item *klist,
1450                        u32 curtime, u32 *next_expire)
1451 {
1452   struct key_item *kr;
1453   KBNODE node, uidnode=NULL;
1454   PKT_public_key *pk = kb->pkt->pkt.public_key;
1455   u32 main_kid[2];
1456   int issigned=0, any_signed = 0, fully_count =0, marginal_count = 0;
1457
1458   keyid_from_pk(pk, main_kid);
1459   for (node=kb; node; node = node->next)
1460     {
1461       if (node->pkt->pkttype == PKT_USER_ID)
1462         {
1463           if (uidnode && issigned)
1464             {
1465               if (fully_count >= opt.completes_needed
1466                   || marginal_count >= opt.marginals_needed )
1467                 uidnode->flag |= 4; 
1468               else if (fully_count || marginal_count)
1469                 uidnode->flag |= 2;
1470               uidnode->flag |= 1;
1471               any_signed = 1;
1472             }
1473           uidnode = node;
1474           issigned = 0;
1475           fully_count = marginal_count = 0;
1476           mark_usable_uid_certs (kb, uidnode, main_kid, klist, 
1477                                  curtime, next_expire);
1478         }
1479       else if (node->pkt->pkttype == PKT_SIGNATURE 
1480                && (node->flag & (1<<8)) )
1481         {
1482           /* Note that we are only seeing unrevoked sigs here */
1483           PKT_signature *sig = node->pkt->pkt.signature;
1484           
1485           kr = is_in_klist (klist, sig);
1486           /* If the trust_regexp does not match, it's as if the sig
1487              did not exist.  This is safe for non-trust sigs as well
1488              since we don't accept a regexp on the sig unless it's a
1489              trust sig. */
1490           if (kr && (kr->trust_regexp==NULL || opt.trust_model!=TM_OPENPGP ||
1491                      (uidnode && check_regexp(kr->trust_regexp,
1492                                             uidnode->pkt->pkt.user_id->name))))
1493             {
1494               if(DBG_TRUST && opt.trust_model==TM_OPENPGP && sig->trust_depth)
1495                 log_debug("trust sig on %s, sig depth is %d, kr depth is %d\n",
1496                           uidnode->pkt->pkt.user_id->name,sig->trust_depth,
1497                           kr->trust_depth);
1498
1499               /* Are we part of a trust sig chain?  We always favor
1500                  the latest trust sig, rather than the greater or
1501                  lesser trust sig or value.  I could make a decent
1502                  argument for any of these cases, but this seems to be
1503                  what PGP does, and I'd like to be compatible. -dms */
1504               if(opt.trust_model==TM_OPENPGP && sig->trust_depth
1505                  && pk->trust_timestamp<=sig->timestamp
1506                  && (sig->trust_depth<=kr->trust_depth
1507                      || kr->ownertrust==TRUST_ULTIMATE))
1508                 {
1509                   /* If we got here, we know that:
1510
1511                      this is a trust sig.
1512
1513                      it's a newer trust sig than any previous trust
1514                      sig on this key (not uid).
1515
1516                      it is legal in that it was either generated by an
1517                      ultimate key, or a key that was part of a trust
1518                      chain, and the depth does not violate the
1519                      original trust sig.
1520
1521                      if there is a regexp attached, it matched
1522                      successfully.
1523                   */
1524
1525                   if(DBG_TRUST)
1526                     log_debug("replacing trust value %d with %d and "
1527                               "depth %d with %d\n",
1528                               pk->trust_value,sig->trust_value,
1529                               pk->trust_depth,sig->trust_depth);
1530
1531                   pk->trust_value=sig->trust_value;
1532                   pk->trust_depth=sig->trust_depth-1;
1533
1534                   /* If the trust sig contains a regexp, record it
1535                      on the pk for the next round. */
1536                   if(sig->trust_regexp)
1537                     pk->trust_regexp=sig->trust_regexp;
1538                 }
1539
1540               if (kr->ownertrust == TRUST_ULTIMATE)
1541                 fully_count = opt.completes_needed;
1542               else if (kr->ownertrust == TRUST_FULLY)
1543                 fully_count++;
1544               else if (kr->ownertrust == TRUST_MARGINAL)
1545                 marginal_count++;
1546               issigned = 1;
1547             }
1548         }
1549     }
1550
1551   if (uidnode && issigned)
1552     {
1553       if (fully_count >= opt.completes_needed
1554                || marginal_count >= opt.marginals_needed )
1555         uidnode->flag |= 4; 
1556       else if (fully_count || marginal_count)
1557         uidnode->flag |= 2;
1558       uidnode->flag |= 1;
1559       any_signed = 1;
1560     }
1561
1562   return any_signed;
1563 }
1564
1565
1566 static int
1567 search_skipfnc (void *opaque, u32 *kid)
1568 {
1569   return test_key_hash_table ((KeyHashTable)opaque, kid);
1570 }
1571
1572
1573 /*
1574  * Scan all keys and return a key_array of all suitable keys from
1575  * kllist.  The caller has to pass keydb handle so that we don't use
1576  * to create our own.  Returns either a key_array or NULL in case of
1577  * an error.  No results found are indicated by an empty array.
1578  * Caller hast to release the returned array.  
1579  */
1580 static struct key_array *
1581 validate_key_list (KEYDB_HANDLE hd, KeyHashTable visited,
1582                    struct key_item *klist, u32 curtime, u32 *next_expire)
1583 {
1584   KBNODE keyblock = NULL;
1585   struct key_array *keys = NULL;
1586   size_t nkeys, maxkeys;
1587   int rc;
1588   KEYDB_SEARCH_DESC desc;
1589   
1590   maxkeys = 1000;
1591   keys = m_alloc ((maxkeys+1) * sizeof *keys);
1592   nkeys = 0;
1593   
1594   rc = keydb_search_reset (hd);
1595   if (rc)
1596     {
1597       log_error ("keydb_search_reset failed: %s\n", g10_errstr(rc));
1598       m_free (keys);
1599       return NULL;
1600     }
1601
1602   memset (&desc, 0, sizeof desc);
1603   desc.mode = KEYDB_SEARCH_MODE_FIRST;
1604   desc.skipfnc = search_skipfnc;
1605   desc.skipfncvalue = visited;
1606   rc = keydb_search (hd, &desc, 1);
1607   if (rc == -1)
1608     {
1609       keys[nkeys].keyblock = NULL;
1610       return keys;
1611     }
1612   if (rc)
1613     {
1614       log_error ("keydb_search_first failed: %s\n", g10_errstr(rc));
1615       m_free (keys);
1616       return NULL;
1617     }
1618   
1619   desc.mode = KEYDB_SEARCH_MODE_NEXT; /* change mode */
1620   do
1621     {
1622       PKT_public_key *pk;
1623         
1624       rc = keydb_get_keyblock (hd, &keyblock);
1625       if (rc) 
1626         {
1627           log_error ("keydb_get_keyblock failed: %s\n", g10_errstr(rc));
1628           m_free (keys);
1629           return NULL;
1630         }
1631       
1632       if ( keyblock->pkt->pkttype != PKT_PUBLIC_KEY) 
1633         {
1634           log_debug ("ooops: invalid pkttype %d encountered\n",
1635                      keyblock->pkt->pkttype);
1636           dump_kbnode (keyblock);
1637           release_kbnode(keyblock);
1638           continue;
1639         }
1640
1641       /* prepare the keyblock for further processing */
1642       merge_keys_and_selfsig (keyblock); 
1643       clear_kbnode_flags (keyblock);
1644       pk = keyblock->pkt->pkt.public_key;
1645       if (pk->has_expired || pk->is_revoked)
1646         {
1647           /* it does not make sense to look further at those keys */
1648           mark_keyblock_seen (visited, keyblock);
1649         }
1650       else if (validate_one_keyblock (keyblock, klist, curtime, next_expire))
1651         {
1652           if (pk->expiredate && pk->expiredate >= curtime
1653               && pk->expiredate < *next_expire)
1654             *next_expire = pk->expiredate;
1655
1656           if (nkeys == maxkeys) {
1657             maxkeys += 1000;
1658             keys = m_realloc (keys, (maxkeys+1) * sizeof *keys);
1659           }
1660           keys[nkeys++].keyblock = keyblock;
1661           /* this key is signed - don't check it again */
1662           mark_keyblock_seen (visited, keyblock);
1663           keyblock = NULL;
1664         }
1665
1666       release_kbnode (keyblock);
1667       keyblock = NULL;
1668     } 
1669   while ( !(rc = keydb_search (hd, &desc, 1)) );
1670   if (rc && rc != -1) 
1671     {
1672       log_error ("keydb_search_next failed: %s\n", g10_errstr(rc));
1673       m_free (keys);
1674       return NULL;
1675     }
1676
1677   keys[nkeys].keyblock = NULL;
1678   return keys;
1679
1680
1681
1682 static void
1683 reset_unconnected_keys (KEYDB_HANDLE hd, KeyHashTable visited)
1684 {
1685   int rc;
1686   KBNODE keyblock = NULL;
1687   KEYDB_SEARCH_DESC desc;
1688   int count = 0, nreset = 0;
1689   
1690   rc = keydb_search_reset (hd);
1691   if (rc)
1692     {
1693       log_error ("keydb_search_reset failed: %s\n", g10_errstr(rc));
1694       return;
1695     }
1696
1697   memset (&desc, 0, sizeof desc);
1698   desc.mode = KEYDB_SEARCH_MODE_FIRST;
1699   desc.skipfnc = search_skipfnc;
1700   desc.skipfncvalue = visited;
1701   rc = keydb_search (hd, &desc, 1);
1702   if (rc && rc != -1 )
1703     log_error ("keydb_search_first failed: %s\n", g10_errstr(rc));
1704   else if (!rc)
1705     {
1706       desc.mode = KEYDB_SEARCH_MODE_NEXT; /* change mode */
1707       do
1708         {
1709           rc = keydb_get_keyblock (hd, &keyblock);
1710           if (rc) 
1711             {
1712               log_error ("keydb_get_keyblock failed: %s\n", g10_errstr(rc));
1713               break;
1714             }
1715           count++;
1716
1717           if (keyblock->pkt->pkttype == PKT_PUBLIC_KEY) /* paranoid assertion*/
1718             {
1719               nreset += clear_validity (keyblock->pkt->pkt.public_key);
1720               release_kbnode (keyblock);
1721             } 
1722         }
1723       while ( !(rc = keydb_search (hd, &desc, 1)) );
1724       if (rc && rc != -1) 
1725         log_error ("keydb_search_next failed: %s\n", g10_errstr(rc));
1726     }
1727   if (opt.verbose)
1728     log_info ("%d unconnected keys (%d trust records cleared)\n",
1729               count, nreset);
1730   do_sync ();
1731
1732
1733
1734 /*
1735  * Run the key validation procedure.
1736  *
1737  * This works this way:
1738  * Step 1: Find all ultimately trusted keys (UTK).
1739  *         mark them all as seen and put them into klist.
1740  * Step 2: loop max_cert_times
1741  * Step 3:   if OWNERTRUST of any key in klist is undefined
1742  *             ask user to assign ownertrust
1743  * Step 4:   Loop over all keys in the keyDB which are not marked seen 
1744  * Step 5:     if key is revoked or expired
1745  *                mark key as seen
1746  *                continue loop at Step 4
1747  * Step 6:     For each user ID of that key signed by a key in klist
1748  *                Calculate validity by counting trusted signatures.
1749  *                Set validity of user ID
1750  * Step 7:     If any signed user ID was found
1751  *                mark key as seen
1752  *             End Loop
1753  * Step 8:   Build a new klist from all fully trusted keys from step 6
1754  *           End Loop
1755  *         Ready  
1756  *
1757  */
1758 static int
1759 validate_keys (int interactive)
1760 {
1761   int rc = 0;
1762   int quit=0;
1763   struct key_item *klist = NULL;
1764   struct key_item *k;
1765   struct key_array *keys = NULL;
1766   struct key_array *kar;
1767   KEYDB_HANDLE kdb = NULL;
1768   KBNODE node;
1769   int depth;
1770   int key_count;
1771   int ot_unknown, ot_undefined, ot_never, ot_marginal, ot_full, ot_ultimate;
1772   KeyHashTable visited;
1773   u32 start_time, next_expire;
1774
1775   start_time = make_timestamp ();
1776   next_expire = 0xffffffff; /* set next expire to the year 2106 */
1777   visited = new_key_hash_table ();
1778   /* Fixme: Instead of always building a UTK list, we could just build it
1779    * here when needed */
1780   if (!utk_list)
1781     {
1782       log_info ("no ultimately trusted keys found\n");
1783       goto leave;
1784     }
1785
1786   /* mark all UTKs as visited and set validity to ultimate */
1787   for (k=utk_list; k; k = k->next)
1788     {
1789       KBNODE keyblock;
1790       PKT_public_key *pk;
1791
1792       keyblock = get_pubkeyblock (k->kid);
1793       if (!keyblock)
1794         {
1795           log_error (_("public key of ultimately"
1796                        " trusted key %08lX not found\n"), (ulong)k->kid[1]);
1797           continue;
1798         }
1799       mark_keyblock_seen (visited, keyblock);
1800       pk = keyblock->pkt->pkt.public_key;
1801       for (node=keyblock; node; node = node->next)
1802         {
1803           if (node->pkt->pkttype == PKT_USER_ID)
1804             {
1805               byte namehash[20];
1806               PKT_user_id *uid = node->pkt->pkt.user_id;
1807               
1808               if( uid->attrib_data )
1809                 rmd160_hash_buffer (namehash,uid->attrib_data,uid->attrib_len);
1810               else
1811                 rmd160_hash_buffer (namehash, uid->name, uid->len );
1812               update_validity (pk, namehash, 0, TRUST_ULTIMATE);
1813             }
1814         }
1815       if ( pk->expiredate && pk->expiredate >= start_time
1816            && pk->expiredate < next_expire)
1817         next_expire = pk->expiredate;
1818       
1819       release_kbnode (keyblock);
1820       do_sync ();
1821     }
1822
1823   klist = utk_list;
1824   kdb = keydb_new (0);
1825
1826   log_info(_("%d marginal(s) needed, %d complete(s) needed, %s trust model\n"),
1827            opt.marginals_needed,opt.completes_needed,
1828            opt.trust_model==TM_CLASSIC?"Classic":
1829                           opt.trust_model==TM_OPENPGP?"OpenPGP":"unknown");
1830
1831   for (depth=0; depth < opt.max_cert_depth; depth++)
1832     {
1833       /* See whether we should assign ownertrust values to the keys in
1834          utk_list.  */
1835       ot_unknown = ot_undefined = ot_never = 0;
1836       ot_marginal = ot_full = ot_ultimate = 0;
1837       for (k=klist; k; k = k->next)
1838         {
1839           int min=0;
1840
1841           /* 120 and 60 are as per RFC2440 */
1842           if(k->trust_value>=120)
1843             min=TRUST_FULLY;
1844           else if(k->trust_value>=60)
1845             min=TRUST_MARGINAL;
1846
1847           if(min!=k->min_ownertrust)
1848             update_min_ownertrust(k->kid,min);
1849
1850           if (interactive && k->ownertrust == TRUST_UNKNOWN)
1851             {
1852               k->ownertrust = ask_ownertrust (k->kid,min);
1853
1854               if (k->ownertrust == -1)
1855                 {
1856                   quit=1;
1857                   goto leave;
1858                 }
1859             }
1860
1861           /* This can happen during transition from an old trustdb
1862              before trust sigs.  It can also happen if a user uses two
1863              different versions of GnuPG or changes the --trust-model
1864              setting. */
1865           if(k->ownertrust<min)
1866             {
1867               if(DBG_TRUST)
1868                 log_debug("key %08lX: "
1869                           "overriding ownertrust \"%s\" with \"%s\"\n",
1870                           (ulong)k->kid[1],
1871                           trust_string(k->ownertrust),trust_string(min));
1872
1873               k->ownertrust=min;
1874             }
1875
1876           if (k->ownertrust == TRUST_UNKNOWN)
1877             ot_unknown++;
1878           else if (k->ownertrust == TRUST_UNDEFINED)
1879             ot_undefined++;
1880           else if (k->ownertrust == TRUST_NEVER)
1881             ot_never++;
1882           else if (k->ownertrust == TRUST_MARGINAL)
1883             ot_marginal++;
1884           else if (k->ownertrust == TRUST_FULLY)
1885             ot_full++;
1886           else if (k->ownertrust == TRUST_ULTIMATE)
1887             ot_ultimate++;
1888         }
1889
1890       /* Find all keys which are signed by a key in kdlist */
1891       keys = validate_key_list (kdb, visited, klist, start_time, &next_expire);
1892       if (!keys) 
1893         {
1894           log_error ("validate_key_list failed\n");
1895           rc = G10ERR_GENERAL;
1896           goto leave;
1897         }
1898
1899       for (key_count=0, kar=keys; kar->keyblock; kar++, key_count++)
1900         ;
1901
1902       /* Store the calculated valididation status somewhere */
1903       if (opt.verbose > 1)
1904         dump_key_array (depth, keys);
1905
1906       log_info (_("checking at depth %d signed=%d"
1907                   " ot(-/q/n/m/f/u)=%d/%d/%d/%d/%d/%d\n"), 
1908                 depth, key_count, ot_unknown, ot_undefined,
1909                 ot_never, ot_marginal, ot_full, ot_ultimate ); 
1910
1911       for (kar=keys; kar->keyblock; kar++)
1912           store_validation_status (depth, kar->keyblock);
1913
1914       /* Build a new kdlist from all fully valid keys in KEYS */
1915       if (klist != utk_list)
1916         release_key_items (klist);
1917       klist = NULL;
1918       for (kar=keys; kar->keyblock; kar++)
1919         {
1920           for (node=kar->keyblock; node; node = node->next)
1921             {
1922               if (node->pkt->pkttype == PKT_USER_ID && (node->flag & 4))
1923                 {
1924                   k = new_key_item ();
1925                   keyid_from_pk (kar->keyblock->pkt->pkt.public_key, k->kid);
1926                   k->ownertrust = get_ownertrust (kar->keyblock
1927                                                   ->pkt->pkt.public_key);
1928                   k->min_ownertrust = get_min_ownertrust (kar->keyblock
1929                                                         ->pkt->pkt.public_key);
1930                   k->trust_depth=
1931                     kar->keyblock->pkt->pkt.public_key->trust_depth;
1932                   k->trust_value=
1933                     kar->keyblock->pkt->pkt.public_key->trust_value;
1934                   if(kar->keyblock->pkt->pkt.public_key->trust_regexp)
1935                     k->trust_regexp=
1936                       m_strdup(kar->keyblock->pkt->
1937                                pkt.public_key->trust_regexp);
1938                   k->next = klist;
1939                   klist = k;
1940                   break;
1941                 }
1942             }
1943         }
1944       release_key_array (keys);
1945       keys = NULL;
1946       if (!klist)
1947         break; /* no need to dive in deeper */
1948     }
1949
1950   reset_unconnected_keys (kdb, visited);
1951
1952  leave:
1953   keydb_release (kdb);
1954   release_key_array (keys);
1955   release_key_items (klist);
1956   release_key_hash_table (visited);
1957   if (!rc && !quit) /* mark trustDB as checked */
1958     {
1959       if (next_expire == 0xffffffff || next_expire < start_time )
1960         tdbio_write_nextcheck (0); 
1961       else
1962         {
1963           tdbio_write_nextcheck (next_expire); 
1964           log_info (_("next trustdb check due at %s\n"),
1965                     strtimestamp (next_expire));
1966         }
1967
1968       if(tdbio_update_version_record()!=0)
1969         {
1970           log_error(_("unable to update trustdb version record: "
1971                       "write failed: %s\n"), g10_errstr(rc));
1972           tdbio_invalid();
1973         }
1974
1975       do_sync ();
1976       pending_check_trustdb = 0;
1977     }
1978   return rc;
1979 }