* armor.c (armor_filter): Comment about PGP's end of line tab problem.
[gnupg.git] / g10 / trustdb.c
1 /* trustdb.c
2  * Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003
3  *                                             Free Software Foundation, Inc.
4  *
5  * This file is part of GnuPG.
6  *
7  * GnuPG is free software; you can redistribute it and/or modify
8  * it under the terms of the GNU General Public License as published by
9  * the Free Software Foundation; either version 2 of the License, or
10  * (at your option) any later version.
11  *
12  * GnuPG is distributed in the hope that it will be useful,
13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15  * GNU General Public License for more details.
16  *
17  * You should have received a copy of the GNU General Public License
18  * along with this program; if not, write to the Free Software
19  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
20  */
21
22 #include <config.h>
23 #include <stdio.h>
24 #include <stdlib.h>
25 #include <string.h>
26 #include <assert.h>
27
28 #ifndef DISABLE_REGEX
29 #include <sys/types.h>
30 #ifdef USE_GNU_REGEX
31 #include "_regex.h"
32 #else
33 #include <regex.h>
34 #endif
35 #endif /* !DISABLE_REGEX */
36
37 #include "errors.h"
38 #include "iobuf.h"
39 #include "keydb.h"
40 #include "memory.h"
41 #include "util.h"
42 #include "options.h"
43 #include "packet.h"
44 #include "main.h"
45 #include "i18n.h"
46 #include "tdbio.h"
47 #include "trustdb.h"
48
49
50 /*
51  * A structure to store key identification as well as some stuff needed
52  * for validation 
53  */
54 struct key_item {
55   struct key_item *next;
56   unsigned int ownertrust,min_ownertrust;
57   byte trust_depth;
58   byte trust_value;
59   char *trust_regexp;
60   u32 kid[2];
61 };
62
63
64 typedef struct key_item **KeyHashTable; /* see new_key_hash_table() */
65
66 /*
67  * Structure to keep track of keys, this is used as an array wherre
68  * the item right after the last one has a keyblock set to NULL. 
69  * Maybe we can drop this thing and replace it by key_item
70  */
71 struct key_array {
72   KBNODE keyblock;
73 };
74
75
76 /* control information for the trust DB */
77 static struct {
78     int init;
79     int level;
80     char *dbname;
81 } trustdb_args;
82
83 /* some globals */
84 static struct key_item *user_utk_list; /* temp. used to store --trusted-keys */
85 static struct key_item *utk_list;      /* all ultimately trusted keys */
86
87 static int pending_check_trustdb;
88
89 static int validate_keys (int interactive);
90
91 \f
92 /**********************************************
93  ************* some helpers *******************
94  **********************************************/
95
96 static struct key_item *
97 new_key_item (void)
98 {
99   struct key_item *k;
100   
101   k = m_alloc_clear (sizeof *k);
102   return k;
103 }
104
105 static void
106 release_key_items (struct key_item *k)
107 {
108   struct key_item *k2;
109
110   for (; k; k = k2)
111     {
112       k2 = k->next;
113       m_free (k->trust_regexp);
114       m_free (k);
115     }
116 }
117
118 /*
119  * For fast keylook up we need a hash table.  Each byte of a KeyIDs
120  * should be distributed equally over the 256 possible values (except
121  * for v3 keyIDs but we consider them as not important here). So we
122  * can just use 10 bits to index a table of 1024 key items. 
123  * Possible optimization: Don not use key_items but other hash_table when the
124  * duplicates lists gets too large. 
125  */
126 static KeyHashTable 
127 new_key_hash_table (void)
128 {
129   struct key_item **tbl;
130
131   tbl = m_alloc_clear (1024 * sizeof *tbl);
132   return tbl;
133 }
134
135 static void
136 release_key_hash_table (KeyHashTable tbl)
137 {
138   int i;
139
140   if (!tbl)
141     return;
142   for (i=0; i < 1024; i++)
143     release_key_items (tbl[i]);
144   m_free (tbl);
145 }
146
147 /* 
148  * Returns: True if the keyID is in the given hash table
149  */
150 static int
151 test_key_hash_table (KeyHashTable tbl, u32 *kid)
152 {
153   struct key_item *k;
154
155   for (k = tbl[(kid[1] & 0x03ff)]; k; k = k->next)
156     if (k->kid[0] == kid[0] && k->kid[1] == kid[1])
157       return 1;
158   return 0;
159 }
160
161 /*
162  * Add a new key to the hash table.  The key is identified by its key ID.
163  */
164 static void
165 add_key_hash_table (KeyHashTable tbl, u32 *kid)
166 {
167   struct key_item *k, *kk;
168
169   for (k = tbl[(kid[1] & 0x03ff)]; k; k = k->next)
170     if (k->kid[0] == kid[0] && k->kid[1] == kid[1])
171       return; /* already in table */
172   
173   kk = new_key_item ();
174   kk->kid[0] = kid[0];
175   kk->kid[1] = kid[1];
176   kk->next = tbl[(kid[1] & 0x03ff)];
177   tbl[(kid[1] & 0x03ff)] = kk;
178 }
179
180 /*
181  * Release a key_array
182  */
183 static void
184 release_key_array ( struct key_array *keys )
185 {
186     struct key_array *k;
187
188     if (keys) {
189         for (k=keys; k->keyblock; k++)
190             release_kbnode (k->keyblock);
191         m_free (keys);
192     }
193 }
194
195 \f
196 /*********************************************
197  **********  Initialization  *****************
198  *********************************************/
199
200
201
202 /*
203  * Used to register extra ultimately trusted keys - this has to be done
204  * before initializing the validation module.
205  * FIXME: Should be replaced by a function to add those keys to the trustdb.
206  */
207 void
208 register_trusted_key( const char *string )
209 {
210   KEYDB_SEARCH_DESC desc;
211   struct key_item *k;
212
213   if (classify_user_id (string, &desc) != KEYDB_SEARCH_MODE_LONG_KID ) {
214     log_error(_("`%s' is not a valid long keyID\n"), string );
215     return;
216   }
217
218   k = new_key_item ();
219   k->kid[0] = desc.u.kid[0];
220   k->kid[1] = desc.u.kid[1];
221   k->next = user_utk_list;
222   user_utk_list = k;
223 }
224
225 /*
226  * Helper to add a key to the global list of ultimately trusted keys.
227  * Retruns: true = inserted, false = already in in list.
228  */
229 static int
230 add_utk (u32 *kid)
231 {
232   struct key_item *k;
233
234   for (k = utk_list; k; k = k->next) 
235     {
236       if (k->kid[0] == kid[0] && k->kid[1] == kid[1])
237         {
238           return 0;
239         }
240     }
241
242   k = new_key_item ();
243   k->kid[0] = kid[0];
244   k->kid[1] = kid[1];
245   k->ownertrust = TRUST_ULTIMATE;
246   k->next = utk_list;
247   utk_list = k;
248   if( opt.verbose > 1 )
249     log_info(_("key %08lX: accepted as trusted key\n"), (ulong)kid[1]);
250   return 1;
251 }
252
253
254 /****************
255  * Verify that all our secret keys are usable and put them into the utk_list.
256  */
257 static void
258 verify_own_keys(void)
259 {
260   TRUSTREC rec;
261   ulong recnum;
262   int rc;
263   struct key_item *k;
264
265   if (utk_list)
266     return;
267
268   /* scan the trustdb to find all ultimately trusted keys */
269   for (recnum=1; !tdbio_read_record (recnum, &rec, 0); recnum++ ) 
270     {
271       if ( rec.rectype == RECTYPE_TRUST 
272            && (rec.r.trust.ownertrust & TRUST_MASK) == TRUST_ULTIMATE)
273         {
274             byte *fpr = rec.r.trust.fingerprint;
275             int fprlen;
276             u32 kid[2];
277             
278             /* Problem: We do only use fingerprints in the trustdb but
279              * we need the keyID here to indetify the key; we can only
280              * use that ugly hack to distinguish between 16 and 20
281              * butes fpr - it does not work always so we better change
282              * the whole validation code to only work with
283              * fingerprints */
284             fprlen = (!fpr[16] && !fpr[17] && !fpr[18] && !fpr[19])? 16:20;
285             keyid_from_fingerprint (fpr, fprlen, kid);
286             if (!add_utk (kid))
287                 log_info(_("key %08lX occurs more than once in the trustdb\n"),
288                             (ulong)kid[1]);
289         }
290     }
291
292   /* Put any --trusted-key keys into 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 static 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 );
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, PKT_user_id *uid,
800                  int depth, int validity)
801 {
802   TRUSTREC trec, vrec;
803   int rc;
804   ulong recno;
805   byte namehash[20];
806
807   if(uid->attrib_data)
808     rmd160_hash_buffer (namehash,uid->attrib_data,uid->attrib_len);
809   else
810     rmd160_hash_buffer (namehash, uid->name, uid->len );
811
812   rc = read_trust_record (pk, &trec);
813   if (rc && rc != -1)
814     {
815       tdbio_invalid ();
816       return;
817     }
818   if (rc == -1) /* no record yet - create a new one */
819     { 
820       size_t dummy;
821
822       rc = 0;
823       memset (&trec, 0, sizeof trec);
824       trec.recnum = tdbio_new_recnum ();
825       trec.rectype = RECTYPE_TRUST;
826       fingerprint_from_pk (pk, trec.r.trust.fingerprint, &dummy);
827       trec.r.trust.ownertrust = 0;
828       }
829
830   /* locate an existing one */
831   recno = trec.r.trust.validlist;
832   while (recno)
833     {
834       read_record (recno, &vrec, RECTYPE_VALID);
835       if ( !memcmp (vrec.r.valid.namehash, namehash, 20) )
836         break;
837       recno = vrec.r.valid.next;
838     }
839
840   if (!recno) /* insert a new validity record */
841     {
842       memset (&vrec, 0, sizeof vrec);
843       vrec.recnum = tdbio_new_recnum ();
844       vrec.rectype = RECTYPE_VALID;
845       memcpy (vrec.r.valid.namehash, namehash, 20);
846       vrec.r.valid.next = trec.r.trust.validlist;
847     }
848   vrec.r.valid.validity = validity;
849   vrec.r.valid.full_count = uid->help_full_count;
850   vrec.r.valid.marginal_count = uid->help_marginal_count;
851   write_record (&vrec);
852   trec.r.trust.depth = depth;
853   trec.r.trust.validlist = vrec.recnum;
854   write_record (&trec);
855 }
856
857
858 /* reset validity for all user IDs.  Caller must sync. */
859 static int
860 clear_validity (PKT_public_key *pk)
861 {
862   TRUSTREC trec, vrec;
863   int rc;
864   ulong recno;
865   int any = 0;
866   
867   rc = read_trust_record (pk, &trec);
868   if (rc && rc != -1)
869     {
870       tdbio_invalid ();
871       return 0;
872     }
873   if (rc == -1) /* no record yet - no need to clear it then ;-) */
874     return 0;
875
876   /* Clear minimum ownertrust, if any */
877   if(trec.r.trust.min_ownertrust)
878     {
879       trec.r.trust.min_ownertrust=0;
880       write_record(&trec);
881     }
882
883   recno = trec.r.trust.validlist;
884   while (recno)
885     {
886       read_record (recno, &vrec, RECTYPE_VALID);
887       if ((vrec.r.valid.validity & TRUST_MASK)
888           || vrec.r.valid.marginal_count || vrec.r.valid.full_count)
889         {
890           vrec.r.valid.validity &= ~TRUST_MASK;
891           vrec.r.valid.marginal_count = vrec.r.valid.full_count = 0;
892           write_record (&vrec);
893           any = 1;
894         }
895       recno = vrec.r.valid.next;
896     }
897
898   return any;
899 }
900
901 /***********************************************
902  *********  Query trustdb values  **************
903  ***********************************************/
904
905 /* Return true if key is disabled */
906 int
907 is_disabled(void *dummy,u32 *keyid)
908 {
909   int rc;
910   TRUSTREC trec;
911   int disabled=0; /* default to not disabled */
912   PKT_public_key *pk=m_alloc_clear(sizeof(PKT_public_key));
913
914   init_trustdb ();
915
916   rc = get_pubkey(pk, keyid);
917   if(rc)
918     {
919       log_error("error checking disabled status of %08lX: %s\n",
920                 (ulong)keyid[1],g10_errstr(rc));
921       goto leave;
922     }
923  
924   rc = read_trust_record (pk, &trec);
925   if (rc && rc != -1)
926     {
927       tdbio_invalid ();
928       goto leave;
929     }
930   if (rc == -1) /* no record found, so assume not disabled */
931     goto leave;
932  
933   if(trec.r.trust.ownertrust & TRUST_FLAG_DISABLED)
934     disabled=1;
935  
936  leave:
937   free_public_key(pk);
938   return disabled;
939 }
940
941 /*
942  * Return the validity information for PK.  If the namehash is not
943  * NULL, the validity of the corresponsing user ID is returned,
944  * otherwise, a reasonable value for the entire key is returned. 
945  */
946 unsigned int
947 get_validity (PKT_public_key *pk, PKT_user_id *uid)
948 {
949   static int did_nextcheck;
950   TRUSTREC trec, vrec;
951   int rc;
952   ulong recno;
953   unsigned int validity;
954   u32 kid[2];
955   PKT_public_key *main_pk;
956   byte namehash[20];
957
958   if(uid)
959     {
960       if(uid->attrib_data)
961         rmd160_hash_buffer (namehash,uid->attrib_data,uid->attrib_len);
962       else
963         rmd160_hash_buffer (namehash, uid->name, uid->len );
964     }
965   
966   init_trustdb ();
967   if (!did_nextcheck)
968     {
969       ulong scheduled;
970
971       did_nextcheck = 1;
972       scheduled = tdbio_read_nextcheck ();
973       if (scheduled && scheduled <= make_timestamp ())
974         {
975           if (opt.no_auto_check_trustdb) 
976             {
977               pending_check_trustdb = 1;
978               log_info ("please do a --check-trustdb\n");
979             }
980           else
981             {
982               log_info (_("checking the trustdb\n"));
983               validate_keys (0);
984             }
985         }
986     }
987
988   keyid_from_pk (pk, kid);
989   if (pk->main_keyid[0] != kid[0] || pk->main_keyid[1] != kid[1])
990     { /* this is a subkey - get the mainkey */
991       main_pk = m_alloc_clear (sizeof *main_pk);
992       rc = get_pubkey (main_pk, pk->main_keyid);
993       if (rc)
994         {
995           log_error ("error getting main key %08lX of subkey %08lX: %s\n",
996                      (ulong)pk->main_keyid[1], (ulong)kid[1], g10_errstr(rc));
997           validity = TRUST_UNKNOWN; 
998           goto leave;
999         }
1000     }
1001   else
1002     main_pk = pk;
1003
1004   rc = read_trust_record (main_pk, &trec);
1005   if (rc && rc != -1)
1006     {
1007       tdbio_invalid ();
1008       return 0;
1009     }
1010   if (rc == -1) /* no record found */
1011     {
1012       validity = TRUST_UNKNOWN; 
1013       goto leave;
1014     }
1015
1016   /* loop over all user IDs */
1017   recno = trec.r.trust.validlist;
1018   validity = 0;
1019   while (recno)
1020     {
1021       read_record (recno, &vrec, RECTYPE_VALID);
1022       if ( validity < (vrec.r.valid.validity & TRUST_MASK) )
1023         validity = (vrec.r.valid.validity & TRUST_MASK);
1024       if ( uid && !memcmp (vrec.r.valid.namehash, namehash, 20) )
1025         break;
1026       recno = vrec.r.valid.next;
1027     }
1028   
1029   if (recno) /* okay, use the user ID associated one */
1030     validity = (vrec.r.valid.validity & TRUST_MASK);
1031
1032   if ( (trec.r.trust.ownertrust & TRUST_FLAG_DISABLED) )
1033     validity |= TRUST_FLAG_DISABLED;
1034
1035  leave:
1036   /* set some flags direct from the key */
1037   if (main_pk->is_revoked)
1038     validity |= TRUST_FLAG_REVOKED;
1039   if (main_pk != pk && pk->is_revoked)
1040     validity |= TRUST_FLAG_SUB_REVOKED;
1041   /* Note: expiration is a trust value and not a flag - don't know why
1042    * I initially designed it that way */
1043   if (main_pk->has_expired || pk->has_expired)
1044     validity = (validity & ~TRUST_MASK) | TRUST_EXPIRED;
1045   
1046   if (pending_check_trustdb)
1047     validity |= TRUST_FLAG_PENDING_CHECK;
1048
1049   if (main_pk != pk)
1050     free_public_key (main_pk);
1051   return validity;
1052 }
1053
1054 int
1055 get_validity_info (PKT_public_key *pk, PKT_user_id *uid)
1056 {
1057     int trustlevel;
1058     int c;
1059
1060     trustlevel = get_validity (pk, uid);
1061     if( trustlevel & TRUST_FLAG_REVOKED )
1062         return 'r';
1063     c = trust_letter ( trustlevel );
1064     if( !c )
1065         c = '?';
1066     return c;
1067 }
1068
1069 static void
1070 get_validity_counts (PKT_public_key *pk, PKT_user_id *uid)
1071 {
1072   TRUSTREC trec, vrec;
1073   ulong recno;
1074   byte namehash[20];
1075
1076   if(pk==NULL || uid==NULL)
1077     BUG();
1078
1079   if(uid->attrib_data)
1080     rmd160_hash_buffer (namehash,uid->attrib_data,uid->attrib_len);
1081   else
1082     rmd160_hash_buffer (namehash, uid->name, uid->len );
1083
1084   uid->help_marginal_count=uid->help_full_count=0;
1085
1086   init_trustdb ();
1087
1088   if(read_trust_record (pk, &trec)!=0)
1089     return;
1090
1091   /* loop over all user IDs */
1092   recno = trec.r.trust.validlist;
1093   while (recno)
1094     {
1095       read_record (recno, &vrec, RECTYPE_VALID);
1096
1097       if(memcmp(vrec.r.valid.namehash,namehash,20)==0)
1098         {
1099           uid->help_marginal_count=vrec.r.valid.marginal_count;
1100           uid->help_full_count=vrec.r.valid.full_count;
1101           /*  printf("Fetched marginal %d, full %d\n",uid->help_marginal_count,uid->help_full_count); */
1102           break;
1103         }
1104
1105       recno = vrec.r.valid.next;
1106     }
1107 }
1108
1109 void
1110 list_trust_path( const char *username )
1111 {
1112 }
1113
1114 /****************
1115  * Enumerate all keys, which are needed to build all trust paths for
1116  * the given key.  This function does not return the key itself or
1117  * the ultimate key (the last point in cerificate chain).  Only
1118  * certificate chains which ends up at an ultimately trusted key
1119  * are listed.  If ownertrust or validity is not NULL, the corresponding
1120  * value for the returned LID is also returned in these variable(s).
1121  *
1122  *  1) create a void pointer and initialize it to NULL
1123  *  2) pass this void pointer by reference to this function.
1124  *     Set lid to the key you want to enumerate and pass it by reference.
1125  *  3) call this function as long as it does not return -1
1126  *     to indicate EOF. LID does contain the next key used to build the web
1127  *  4) Always call this function a last time with LID set to NULL,
1128  *     so that it can free its context.
1129  *
1130  * Returns: -1 on EOF or the level of the returned LID
1131  */
1132 int
1133 enum_cert_paths( void **context, ulong *lid,
1134                  unsigned *ownertrust, unsigned *validity )
1135 {
1136     return -1;
1137 }
1138
1139
1140 /****************
1141  * Print the current path
1142  */
1143 void
1144 enum_cert_paths_print( void **context, FILE *fp,
1145                                        int refresh, ulong selected_lid )
1146 {
1147     return;
1148 }
1149
1150
1151 \f
1152 /****************************************
1153  *********** NEW NEW NEW ****************
1154  ****************************************/
1155
1156 static int
1157 ask_ownertrust (u32 *kid,int minimum)
1158 {
1159   PKT_public_key *pk;
1160   int rc;
1161   int ot;
1162
1163   pk = m_alloc_clear (sizeof *pk);
1164   rc = get_pubkey (pk, kid);
1165   if (rc)
1166     {
1167       log_error (_("public key %08lX not found: %s\n"),
1168                  (ulong)kid[1], g10_errstr(rc) );
1169       return TRUST_UNKNOWN;
1170     }
1171  
1172   if(opt.force_ownertrust)
1173     {
1174       log_info("force trust for key %08lX to %s\n",(ulong)kid[1],
1175                trust_string(opt.force_ownertrust));
1176       update_ownertrust(pk,opt.force_ownertrust);
1177       ot=opt.force_ownertrust;
1178     }
1179   else
1180     {
1181       ot=edit_ownertrust(pk,0);
1182       if(ot>0)
1183         ot = get_ownertrust (pk);
1184       else if(ot==0)
1185         ot = minimum?minimum:TRUST_UNDEFINED;
1186       else
1187         ot = -1; /* quit */
1188     }
1189
1190   free_public_key( pk );
1191
1192   return ot;
1193 }
1194
1195
1196 static void
1197 mark_keyblock_seen (KeyHashTable tbl, KBNODE node)
1198 {
1199   for ( ;node; node = node->next )
1200     if (node->pkt->pkttype == PKT_PUBLIC_KEY
1201         || node->pkt->pkttype == PKT_PUBLIC_SUBKEY)
1202       {
1203         u32 aki[2];
1204
1205         keyid_from_pk (node->pkt->pkt.public_key, aki);
1206         add_key_hash_table (tbl, aki);
1207       }
1208 }
1209
1210
1211 static void
1212 dump_key_array (int depth, struct key_array *keys)
1213 {
1214   struct key_array *kar;
1215
1216   for (kar=keys; kar->keyblock; kar++)
1217     {
1218       KBNODE node = kar->keyblock;
1219       u32 kid[2];
1220
1221       keyid_from_pk(node->pkt->pkt.public_key, kid);
1222       printf ("%d:%08lX%08lX:K::%c::::\n",
1223               depth, (ulong)kid[0], (ulong)kid[1], '?');
1224
1225       for (; node; node = node->next)
1226         {
1227           if (node->pkt->pkttype == PKT_USER_ID)
1228             {
1229               int len = node->pkt->pkt.user_id->len;
1230
1231               if (len > 30)
1232                 len = 30;
1233               printf ("%d:%08lX%08lX:U:::%c:::",
1234                       depth, (ulong)kid[0], (ulong)kid[1],
1235                       (node->flag & 4)? 'f':
1236                       (node->flag & 2)? 'm':
1237                       (node->flag & 1)? 'q':'-');
1238               print_string (stdout,  node->pkt->pkt.user_id->name, len, ':');
1239               putchar (':');
1240               putchar ('\n');
1241             }
1242         }
1243     }
1244 }  
1245
1246
1247 static void
1248 store_validation_status (int depth, KBNODE keyblock, KeyHashTable stored)
1249 {
1250   KBNODE node;
1251   int status;
1252   int any = 0;
1253
1254   for (node=keyblock; node; node = node->next)
1255     {
1256       if (node->pkt->pkttype == PKT_USER_ID)
1257         {
1258           PKT_user_id *uid = node->pkt->pkt.user_id;
1259           if (node->flag & 4)
1260             status = TRUST_FULLY;
1261           else if (node->flag & 2)
1262             status = TRUST_MARGINAL;
1263           else if (node->flag & 1)
1264             status = TRUST_UNDEFINED;
1265           else
1266             status = 0;
1267           
1268           if (status)
1269             {
1270               update_validity (keyblock->pkt->pkt.public_key,
1271                                uid, depth, status);
1272
1273               mark_keyblock_seen(stored,keyblock);
1274
1275               any = 1;
1276             }
1277         }
1278     }
1279
1280   if (any)
1281     do_sync ();
1282 }  
1283
1284 /*
1285  * check whether the signature sig is in the klist k
1286  */
1287 static struct key_item *
1288 is_in_klist (struct key_item *k, PKT_signature *sig)
1289 {
1290   for (; k; k = k->next)
1291     {
1292       if (k->kid[0] == sig->keyid[0] && k->kid[1] == sig->keyid[1])
1293         return k;
1294     }
1295   return NULL;
1296 }
1297
1298 /*
1299  * Mark the signature of the given UID which are used to certify it.
1300  * To do this, we first revmove all signatures which are not valid and
1301  * from the remain ones we look for the latest one.  If this is not a
1302  * certification revocation signature we mark the signature by setting
1303  * node flag bit 8.  Note that flag bits 9 and 10 are used for internal
1304  * purposes.  
1305  */
1306 static void
1307 mark_usable_uid_certs (KBNODE keyblock, KBNODE uidnode,
1308                        u32 *main_kid, struct key_item *klist,
1309                        u32 curtime, u32 *next_expire)
1310 {
1311   KBNODE node;
1312   PKT_signature *sig;
1313   
1314   /* first check all signatures */
1315   for (node=uidnode->next; node; node = node->next)
1316     {
1317       node->flag &= ~(1<<8 | 1<<9 | 1<<10);
1318       if (node->pkt->pkttype == PKT_USER_ID
1319           || node->pkt->pkttype == PKT_PUBLIC_SUBKEY)
1320         break; /* ready */
1321       if (node->pkt->pkttype != PKT_SIGNATURE)
1322         continue;
1323       
1324       sig = node->pkt->pkt.signature;
1325       if (sig->keyid[0] == main_kid[0] && sig->keyid[1] == main_kid[1])
1326         continue; /* ignore self-signatures */
1327       if (!IS_UID_SIG(sig) && !IS_UID_REV(sig))
1328         continue; /* we only look at these signature classes */
1329       if (!is_in_klist (klist, sig))
1330         continue;  /* no need to check it then */
1331       if (check_key_signature (keyblock, node, NULL))
1332         continue; /* ignore invalid signatures */
1333       node->flag |= 1<<9;
1334     }      
1335   /* reset the remaining flags */
1336   for (; node; node = node->next)
1337       node->flag &= ~(1<<8 | 1<<9 | 1 << 10);
1338
1339   /* kbnode flag usage: bit 9 is here set for signatures to consider,
1340    * bit 10 will be set by the loop to keep track of keyIDs already
1341    * processed, bit 8 will be set for the usable signatures */
1342
1343   /* for each cert figure out the latest valid one */
1344   for (node=uidnode->next; node; node = node->next)
1345     {
1346       KBNODE n, signode;
1347       u32 kid[2];
1348       u32 sigdate;
1349       
1350       if (node->pkt->pkttype == PKT_PUBLIC_SUBKEY)
1351         break;
1352       if ( !(node->flag & (1<<9)) )
1353         continue; /* not a node to look at */
1354       if ( (node->flag & (1<<10)) )
1355         continue; /* signature with a keyID already processed */
1356       node->flag |= (1<<10); /* mark this node as processed */
1357       sig = node->pkt->pkt.signature;
1358       signode = node;
1359       sigdate = sig->timestamp;
1360       kid[0] = sig->keyid[0]; kid[1] = sig->keyid[1];
1361       for (n=uidnode->next; n; n = n->next)
1362         {
1363           if (n->pkt->pkttype == PKT_PUBLIC_SUBKEY)
1364             break;
1365           if ( !(n->flag & (1<<9)) )
1366             continue;
1367           if ( (n->flag & (1<<10)) )
1368             continue; /* shortcut already processed signatures */
1369           sig = n->pkt->pkt.signature;
1370           if (kid[0] != sig->keyid[0] || kid[1] != sig->keyid[1])
1371             continue;
1372           n->flag |= (1<<10); /* mark this node as processed */
1373
1374           /* If signode is nonrevocable and unexpired and n isn't,
1375              then take signode (skip).  It doesn't matter which is
1376              older: if signode was older then we don't want to take n
1377              as signode is nonrevocable.  If n was older then we're
1378              automatically fine. */
1379           
1380           if(((IS_UID_SIG(signode->pkt->pkt.signature) &&
1381                !signode->pkt->pkt.signature->flags.revocable &&
1382                (signode->pkt->pkt.signature->expiredate==0 ||
1383                 signode->pkt->pkt.signature->expiredate>curtime))) &&
1384              (!(IS_UID_SIG(n->pkt->pkt.signature) &&
1385                 !n->pkt->pkt.signature->flags.revocable &&
1386                 (n->pkt->pkt.signature->expiredate==0 ||
1387                  n->pkt->pkt.signature->expiredate>curtime))))
1388             continue;
1389
1390           /* If n is nonrevocable and unexpired and signode isn't,
1391              then take n.  Again, it doesn't matter which is older: if
1392              n was older then we don't want to take signode as n is
1393              nonrevocable.  If signode was older then we're
1394              automatically fine. */
1395           
1396           if((!(IS_UID_SIG(signode->pkt->pkt.signature) &&
1397                 !signode->pkt->pkt.signature->flags.revocable &&
1398                 (signode->pkt->pkt.signature->expiredate==0 ||
1399                  signode->pkt->pkt.signature->expiredate>curtime))) &&
1400              ((IS_UID_SIG(n->pkt->pkt.signature) &&
1401                !n->pkt->pkt.signature->flags.revocable &&
1402                (n->pkt->pkt.signature->expiredate==0 ||
1403                 n->pkt->pkt.signature->expiredate>curtime))))
1404             {
1405               signode = n;
1406               sigdate = sig->timestamp;
1407               continue;
1408             }
1409
1410           /* At this point, if it's newer, it goes in as the only
1411              remaining possibilities are signode and n are both either
1412              revocable or expired or both nonrevocable and unexpired.
1413              If the timestamps are equal take the later ordered
1414              packet, presuming that the key packets are hopefully in
1415              their original order. */
1416
1417           if (sig->timestamp >= sigdate)
1418             {
1419               signode = n;
1420               sigdate = sig->timestamp;
1421             }
1422         }
1423       sig = signode->pkt->pkt.signature;
1424       if (IS_UID_SIG (sig))
1425         { /* this seems to be a usable one which is not revoked. 
1426            * Just need to check whether there is an expiration time,
1427            * We do the expired certification after finding a suitable
1428            * certification, the assumption is that a signator does not
1429            * want that after the expiration of his certificate the
1430            * system falls back to an older certification which has a
1431            * different expiration time */
1432           const byte *p;
1433           u32 expire;
1434                     
1435           p = parse_sig_subpkt (sig->hashed, SIGSUBPKT_SIG_EXPIRE, NULL );
1436           expire = p? sig->timestamp + buffer_to_u32(p) : 0;
1437
1438           if (expire==0 || expire > curtime )
1439             {
1440               signode->flag |= (1<<8); /* yeah, found a good cert */
1441               if (expire && expire < *next_expire)
1442                 *next_expire = expire;
1443             }
1444         }
1445     }
1446 }
1447
1448 /* Used by validate_one_keyblock to confirm a regexp within a trust
1449    signature.  Returns 1 for match, and 0 for no match or regex
1450    error. */
1451 static int
1452 check_regexp(const char *exp,const char *string)
1453 {
1454 #ifdef DISABLE_REGEXP
1455   /* When DISABLE_REGEXP is defined, assume all regexps do not
1456      match. */
1457   return 0;
1458 #elif defined(__riscos__)
1459   return riscos_check_regexp(exp, string, DBG_TRUST);
1460 #else
1461   int ret;
1462   regex_t pat;
1463
1464   if(regcomp(&pat,exp,REG_ICASE|REG_NOSUB|REG_EXTENDED)!=0)
1465     return 0;
1466
1467   ret=regexec(&pat,string,0,NULL,0);
1468
1469   regfree(&pat);
1470
1471   if(DBG_TRUST)
1472     log_debug("regexp \"%s\" on \"%s\": %s\n",exp,string,ret==0?"YES":"NO");
1473
1474   return (ret==0);
1475 #endif
1476 }
1477
1478 /*
1479  * Return true if the key is signed by one of the keys in the given
1480  * key ID list.  User IDs with a valid signature are marked by node
1481  * flags as follows:
1482  *  flag bit 0: There is at least one signature
1483  *           1: There is marginal confidence that this is a legitimate uid
1484  *           2: There is full confidence that this is a legitimate uid.
1485  *           8: Used for internal purposes.
1486  *           9: Ditto (in mark_usable_uid_certs())
1487  *          10: Ditto (ditto)
1488  * This function assumes that all kbnode flags are cleared on entry.
1489  */
1490 static int
1491 validate_one_keyblock (KBNODE kb, struct key_item *klist,
1492                        u32 curtime, u32 *next_expire)
1493 {
1494   struct key_item *kr;
1495   KBNODE node, uidnode=NULL;
1496   PKT_user_id *uid=NULL;
1497   PKT_public_key *pk = kb->pkt->pkt.public_key;
1498   u32 main_kid[2];
1499   int issigned=0, any_signed = 0;
1500
1501   keyid_from_pk(pk, main_kid);
1502   for (node=kb; node; node = node->next)
1503     {
1504       if (node->pkt->pkttype == PKT_USER_ID)
1505         {
1506           if (uidnode && issigned)
1507             {
1508               if (uid->help_full_count >= opt.completes_needed
1509                   || uid->help_marginal_count >= opt.marginals_needed )
1510                 uidnode->flag |= 4; 
1511               else if (uid->help_full_count || uid->help_marginal_count)
1512                 uidnode->flag |= 2;
1513               uidnode->flag |= 1;
1514               any_signed = 1;
1515             }
1516           uidnode = node;
1517           uid=uidnode->pkt->pkt.user_id;
1518           issigned = 0;
1519           get_validity_counts(pk,uid);
1520           mark_usable_uid_certs (kb, uidnode, main_kid, klist, 
1521                                  curtime, next_expire);
1522         }
1523       else if (node->pkt->pkttype == PKT_SIGNATURE 
1524                && (node->flag & (1<<8)) && uid)
1525         {
1526           /* Note that we are only seeing unrevoked sigs here */
1527           PKT_signature *sig = node->pkt->pkt.signature;
1528           
1529           kr = is_in_klist (klist, sig);
1530           /* If the trust_regexp does not match, it's as if the sig
1531              did not exist.  This is safe for non-trust sigs as well
1532              since we don't accept a regexp on the sig unless it's a
1533              trust sig. */
1534           if (kr && (kr->trust_regexp==NULL || opt.trust_model!=TM_OPENPGP ||
1535                      (uidnode && check_regexp(kr->trust_regexp,
1536                                             uidnode->pkt->pkt.user_id->name))))
1537             {
1538               if(DBG_TRUST && opt.trust_model==TM_OPENPGP && sig->trust_depth)
1539                 log_debug("trust sig on %s, sig depth is %d, kr depth is %d\n",
1540                           uidnode->pkt->pkt.user_id->name,sig->trust_depth,
1541                           kr->trust_depth);
1542
1543               /* Are we part of a trust sig chain?  We always favor
1544                  the latest trust sig, rather than the greater or
1545                  lesser trust sig or value.  I could make a decent
1546                  argument for any of these cases, but this seems to be
1547                  what PGP does, and I'd like to be compatible. -dms */
1548               if(opt.trust_model==TM_OPENPGP && sig->trust_depth
1549                  && pk->trust_timestamp<=sig->timestamp
1550                  && (sig->trust_depth<=kr->trust_depth
1551                      || kr->ownertrust==TRUST_ULTIMATE))
1552                 {
1553                   /* If we got here, we know that:
1554
1555                      this is a trust sig.
1556
1557                      it's a newer trust sig than any previous trust
1558                      sig on this key (not uid).
1559
1560                      it is legal in that it was either generated by an
1561                      ultimate key, or a key that was part of a trust
1562                      chain, and the depth does not violate the
1563                      original trust sig.
1564
1565                      if there is a regexp attached, it matched
1566                      successfully.
1567                   */
1568
1569                   if(DBG_TRUST)
1570                     log_debug("replacing trust value %d with %d and "
1571                               "depth %d with %d\n",
1572                               pk->trust_value,sig->trust_value,
1573                               pk->trust_depth,sig->trust_depth);
1574
1575                   pk->trust_value=sig->trust_value;
1576                   pk->trust_depth=sig->trust_depth-1;
1577
1578                   /* If the trust sig contains a regexp, record it
1579                      on the pk for the next round. */
1580                   if(sig->trust_regexp)
1581                     pk->trust_regexp=sig->trust_regexp;
1582                 }
1583
1584               if (kr->ownertrust == TRUST_ULTIMATE)
1585                 uid->help_full_count = opt.completes_needed;
1586               else if (kr->ownertrust == TRUST_FULLY)
1587                 uid->help_full_count++;
1588               else if (kr->ownertrust == TRUST_MARGINAL)
1589                 uid->help_marginal_count++;
1590               issigned = 1;
1591             }
1592         }
1593     }
1594
1595   if (uidnode && issigned)
1596     {
1597       if (uid->help_full_count >= opt.completes_needed
1598           || uid->help_marginal_count >= opt.marginals_needed )
1599         uidnode->flag |= 4; 
1600       else if (uid->help_full_count || uid->help_marginal_count)
1601         uidnode->flag |= 2;
1602       uidnode->flag |= 1;
1603       any_signed = 1;
1604     }
1605
1606   return any_signed;
1607 }
1608
1609
1610 static int
1611 search_skipfnc (void *opaque, u32 *kid)
1612 {
1613   return test_key_hash_table ((KeyHashTable)opaque, kid);
1614 }
1615
1616
1617 /*
1618  * Scan all keys and return a key_array of all suitable keys from
1619  * kllist.  The caller has to pass keydb handle so that we don't use
1620  * to create our own.  Returns either a key_array or NULL in case of
1621  * an error.  No results found are indicated by an empty array.
1622  * Caller hast to release the returned array.  
1623  */
1624 static struct key_array *
1625 validate_key_list (KEYDB_HANDLE hd, KeyHashTable full_trust,
1626                    struct key_item *klist, u32 curtime, u32 *next_expire)
1627 {
1628   KBNODE keyblock = NULL;
1629   struct key_array *keys = NULL;
1630   size_t nkeys, maxkeys;
1631   int rc;
1632   KEYDB_SEARCH_DESC desc;
1633   
1634   maxkeys = 1000;
1635   keys = m_alloc ((maxkeys+1) * sizeof *keys);
1636   nkeys = 0;
1637   
1638   rc = keydb_search_reset (hd);
1639   if (rc)
1640     {
1641       log_error ("keydb_search_reset failed: %s\n", g10_errstr(rc));
1642       m_free (keys);
1643       return NULL;
1644     }
1645
1646   memset (&desc, 0, sizeof desc);
1647   desc.mode = KEYDB_SEARCH_MODE_FIRST;
1648   desc.skipfnc = search_skipfnc;
1649   desc.skipfncvalue = full_trust;
1650   rc = keydb_search (hd, &desc, 1);
1651   if (rc == -1)
1652     {
1653       keys[nkeys].keyblock = NULL;
1654       return keys;
1655     }
1656   if (rc)
1657     {
1658       log_error ("keydb_search_first failed: %s\n", g10_errstr(rc));
1659       m_free (keys);
1660       return NULL;
1661     }
1662   
1663   desc.mode = KEYDB_SEARCH_MODE_NEXT; /* change mode */
1664   do
1665     {
1666       PKT_public_key *pk;
1667         
1668       rc = keydb_get_keyblock (hd, &keyblock);
1669       if (rc) 
1670         {
1671           log_error ("keydb_get_keyblock failed: %s\n", g10_errstr(rc));
1672           m_free (keys);
1673           return NULL;
1674         }
1675       
1676       if ( keyblock->pkt->pkttype != PKT_PUBLIC_KEY) 
1677         {
1678           log_debug ("ooops: invalid pkttype %d encountered\n",
1679                      keyblock->pkt->pkttype);
1680           dump_kbnode (keyblock);
1681           release_kbnode(keyblock);
1682           continue;
1683         }
1684
1685       /* prepare the keyblock for further processing */
1686       merge_keys_and_selfsig (keyblock); 
1687       clear_kbnode_flags (keyblock);
1688       pk = keyblock->pkt->pkt.public_key;
1689       if (pk->has_expired || pk->is_revoked)
1690         {
1691           /* it does not make sense to look further at those keys */
1692           mark_keyblock_seen (full_trust, keyblock);
1693         }
1694       else if (validate_one_keyblock (keyblock, klist, curtime, next_expire))
1695         {
1696           KBNODE node;
1697
1698           if (pk->expiredate && pk->expiredate >= curtime
1699               && pk->expiredate < *next_expire)
1700             *next_expire = pk->expiredate;
1701
1702           if (nkeys == maxkeys) {
1703             maxkeys += 1000;
1704             keys = m_realloc (keys, (maxkeys+1) * sizeof *keys);
1705           }
1706           keys[nkeys++].keyblock = keyblock;
1707
1708           /* Optimization - if all uids are fully trusted, then we
1709              never need to consider this key as a candidate again. */
1710
1711           for (node=keyblock; node; node = node->next)
1712             if (node->pkt->pkttype == PKT_USER_ID && !(node->flag & 4))
1713               break;
1714
1715           if(node==NULL)
1716             mark_keyblock_seen (full_trust, keyblock);
1717
1718           keyblock = NULL;
1719         }
1720
1721       release_kbnode (keyblock);
1722       keyblock = NULL;
1723     } 
1724   while ( !(rc = keydb_search (hd, &desc, 1)) );
1725   if (rc && rc != -1) 
1726     {
1727       log_error ("keydb_search_next failed: %s\n", g10_errstr(rc));
1728       m_free (keys);
1729       return NULL;
1730     }
1731
1732   keys[nkeys].keyblock = NULL;
1733   return keys;
1734
1735
1736 /* Caller must sync */
1737 static void
1738 reset_trust_records (KEYDB_HANDLE hd, KeyHashTable exclude)
1739 {
1740   int rc;
1741   KBNODE keyblock = NULL;
1742   KEYDB_SEARCH_DESC desc;
1743   int count = 0, nreset = 0;
1744   
1745   rc = keydb_search_reset (hd);
1746   if (rc)
1747     {
1748       log_error ("keydb_search_reset failed: %s\n", g10_errstr(rc));
1749       return;
1750     }
1751
1752   memset (&desc, 0, sizeof desc);
1753   desc.mode = KEYDB_SEARCH_MODE_FIRST;
1754   if(exclude)
1755     {
1756       desc.skipfnc = search_skipfnc;
1757       desc.skipfncvalue = exclude;
1758     }
1759   rc = keydb_search (hd, &desc, 1);
1760   if (rc && rc != -1 )
1761     log_error ("keydb_search_first failed: %s\n", g10_errstr(rc));
1762   else if (!rc)
1763     {
1764       desc.mode = KEYDB_SEARCH_MODE_NEXT; /* change mode */
1765       do
1766         {
1767           rc = keydb_get_keyblock (hd, &keyblock);
1768           if (rc) 
1769             {
1770               log_error ("keydb_get_keyblock failed: %s\n", g10_errstr(rc));
1771               break;
1772             }
1773           count++;
1774
1775           if (keyblock->pkt->pkttype == PKT_PUBLIC_KEY) /* paranoid assertion*/
1776             {
1777               nreset += clear_validity (keyblock->pkt->pkt.public_key);
1778               release_kbnode (keyblock);
1779             } 
1780         }
1781       while ( !(rc = keydb_search (hd, &desc, 1)) );
1782       if (rc && rc != -1) 
1783         log_error ("keydb_search_next failed: %s\n", g10_errstr(rc));
1784     }
1785   if (opt.verbose)
1786     log_info ("%d keys processed (%d validity counts cleared)\n",
1787               count, nreset);
1788 }
1789
1790 /*
1791  * Run the key validation procedure.
1792  *
1793  * This works this way:
1794  * Step 1: Find all ultimately trusted keys (UTK).
1795  *         mark them all as seen and put them into klist.
1796  * Step 2: loop max_cert_times
1797  * Step 3:   if OWNERTRUST of any key in klist is undefined
1798  *             ask user to assign ownertrust
1799  * Step 4:   Loop over all keys in the keyDB which are not marked seen 
1800  * Step 5:     if key is revoked or expired
1801  *                mark key as seen
1802  *                continue loop at Step 4
1803  * Step 6:     For each user ID of that key signed by a key in klist
1804  *                Calculate validity by counting trusted signatures.
1805  *                Set validity of user ID
1806  * Step 7:     If any signed user ID was found
1807  *                mark key as seen
1808  *             End Loop
1809  * Step 8:   Build a new klist from all fully trusted keys from step 6
1810  *           End Loop
1811  *         Ready  
1812  *
1813  */
1814 static int
1815 validate_keys (int interactive)
1816 {
1817   int rc = 0;
1818   int quit=0;
1819   struct key_item *klist = NULL;
1820   struct key_item *k;
1821   struct key_array *keys = NULL;
1822   struct key_array *kar;
1823   KEYDB_HANDLE kdb = NULL;
1824   KBNODE node;
1825   int depth;
1826   int key_count;
1827   int ot_unknown, ot_undefined, ot_never, ot_marginal, ot_full, ot_ultimate;
1828   KeyHashTable stored,used,full_trust;
1829   u32 start_time, next_expire;
1830
1831   start_time = make_timestamp ();
1832   next_expire = 0xffffffff; /* set next expire to the year 2106 */
1833   stored = new_key_hash_table ();
1834   used = new_key_hash_table ();
1835   full_trust = new_key_hash_table ();
1836   /* Fixme: Instead of always building a UTK list, we could just build it
1837    * here when needed */
1838   if (!utk_list)
1839     {
1840       log_info ("no ultimately trusted keys found\n");
1841       goto leave;
1842     }
1843
1844   kdb = keydb_new (0);
1845
1846   reset_trust_records (kdb,NULL);
1847
1848   /* mark all UTKs as used and fully_trusted and set validity to
1849      ultimate */
1850   for (k=utk_list; k; k = k->next)
1851     {
1852       KBNODE keyblock;
1853       PKT_public_key *pk;
1854
1855       keyblock = get_pubkeyblock (k->kid);
1856       if (!keyblock)
1857         {
1858           log_error (_("public key of ultimately"
1859                        " trusted key %08lX not found\n"), (ulong)k->kid[1]);
1860           continue;
1861         }
1862       mark_keyblock_seen (used, keyblock);
1863       mark_keyblock_seen (stored, keyblock);
1864       mark_keyblock_seen (full_trust, keyblock);
1865       pk = keyblock->pkt->pkt.public_key;
1866       for (node=keyblock; node; node = node->next)
1867         {
1868           if (node->pkt->pkttype == PKT_USER_ID)
1869             update_validity (pk, node->pkt->pkt.user_id, 0, TRUST_ULTIMATE);
1870         }
1871       if ( pk->expiredate && pk->expiredate >= start_time
1872            && pk->expiredate < next_expire)
1873         next_expire = pk->expiredate;
1874       
1875       release_kbnode (keyblock);
1876       do_sync ();
1877     }
1878
1879   klist = utk_list;
1880
1881   log_info(_("%d marginal(s) needed, %d complete(s) needed, %s trust model\n"),
1882            opt.marginals_needed,opt.completes_needed,
1883            opt.trust_model==TM_CLASSIC?"Classic":
1884                           opt.trust_model==TM_OPENPGP?"OpenPGP":"unknown");
1885
1886   for (depth=0; depth < opt.max_cert_depth; depth++)
1887     {
1888       /* See whether we should assign ownertrust values to the keys in
1889          utk_list.  */
1890       ot_unknown = ot_undefined = ot_never = 0;
1891       ot_marginal = ot_full = ot_ultimate = 0;
1892       for (k=klist; k; k = k->next)
1893         {
1894           int min=0;
1895
1896           /* 120 and 60 are as per RFC2440 */
1897           if(k->trust_value>=120)
1898             min=TRUST_FULLY;
1899           else if(k->trust_value>=60)
1900             min=TRUST_MARGINAL;
1901
1902           if(min!=k->min_ownertrust)
1903             update_min_ownertrust(k->kid,min);
1904
1905           if (interactive && k->ownertrust == TRUST_UNKNOWN)
1906             {
1907               k->ownertrust = ask_ownertrust (k->kid,min);
1908
1909               if (k->ownertrust == -1)
1910                 {
1911                   quit=1;
1912                   goto leave;
1913                 }
1914             }
1915
1916           /* This can happen during transition from an old trustdb
1917              before trust sigs.  It can also happen if a user uses two
1918              different versions of GnuPG or changes the --trust-model
1919              setting. */
1920           if(k->ownertrust<min)
1921             {
1922               if(DBG_TRUST)
1923                 log_debug("key %08lX: "
1924                           "overriding ownertrust \"%s\" with \"%s\"\n",
1925                           (ulong)k->kid[1],
1926                           trust_string(k->ownertrust),trust_string(min));
1927
1928               k->ownertrust=min;
1929             }
1930
1931           if (k->ownertrust == TRUST_UNKNOWN)
1932             ot_unknown++;
1933           else if (k->ownertrust == TRUST_UNDEFINED)
1934             ot_undefined++;
1935           else if (k->ownertrust == TRUST_NEVER)
1936             ot_never++;
1937           else if (k->ownertrust == TRUST_MARGINAL)
1938             ot_marginal++;
1939           else if (k->ownertrust == TRUST_FULLY)
1940             ot_full++;
1941           else if (k->ownertrust == TRUST_ULTIMATE)
1942             ot_ultimate++;
1943         }
1944
1945       /* Find all keys which are signed by a key in kdlist */
1946       keys = validate_key_list (kdb, full_trust, klist,
1947                                 start_time, &next_expire);
1948       if (!keys) 
1949         {
1950           log_error ("validate_key_list failed\n");
1951           rc = G10ERR_GENERAL;
1952           goto leave;
1953         }
1954
1955       for (key_count=0, kar=keys; kar->keyblock; kar++, key_count++)
1956         ;
1957
1958       /* Store the calculated valididation status somewhere */
1959       if (opt.verbose > 1)
1960         dump_key_array (depth, keys);
1961
1962       for (kar=keys; kar->keyblock; kar++)
1963           store_validation_status (depth, kar->keyblock, stored);
1964
1965       log_info (_("checking at depth %d valid=%d"
1966                   " ot(-/q/n/m/f/u)=%d/%d/%d/%d/%d/%d\n"), 
1967                 depth, key_count, ot_unknown, ot_undefined,
1968                 ot_never, ot_marginal, ot_full, ot_ultimate ); 
1969
1970       /* Build a new kdlist from all fully valid keys in KEYS */
1971       if (klist != utk_list)
1972         release_key_items (klist);
1973       klist = NULL;
1974       for (kar=keys; kar->keyblock; kar++)
1975         {
1976           for (node=kar->keyblock; node; node = node->next)
1977             {
1978               if (node->pkt->pkttype == PKT_USER_ID && (node->flag & 4))
1979                 {
1980                   u32 kid[2];
1981
1982                   /* have we used this key already? */
1983                   keyid_from_pk (kar->keyblock->pkt->pkt.public_key, kid);
1984                   if(test_key_hash_table(used,kid)==0)
1985                     {
1986                       /* Normally we add both the primary and subkey
1987                          ids to the hash via mark_keyblock_seen, but
1988                          since we aren't using this hash as a skipfnc,
1989                          that doesn't matter here. */
1990                       add_key_hash_table (used,kid);
1991                       k = new_key_item ();
1992                       k->kid[0]=kid[0];
1993                       k->kid[1]=kid[1];
1994                       k->ownertrust =
1995                         get_ownertrust (kar->keyblock->pkt->pkt.public_key);
1996                       k->min_ownertrust =
1997                         get_min_ownertrust(kar->keyblock->pkt->pkt.public_key);
1998                       k->trust_depth=
1999                         kar->keyblock->pkt->pkt.public_key->trust_depth;
2000                       k->trust_value=
2001                         kar->keyblock->pkt->pkt.public_key->trust_value;
2002                       if(kar->keyblock->pkt->pkt.public_key->trust_regexp)
2003                         k->trust_regexp=
2004                           m_strdup(kar->keyblock->pkt->
2005                                    pkt.public_key->trust_regexp);
2006                       k->next = klist;
2007                       klist = k;
2008                       break;
2009                     }
2010                 }
2011             }
2012         }
2013       release_key_array (keys);
2014       keys = NULL;
2015       if (!klist)
2016         break; /* no need to dive in deeper */
2017     }
2018
2019  leave:
2020   keydb_release (kdb);
2021   release_key_array (keys);
2022   release_key_items (klist);
2023   release_key_hash_table (full_trust);
2024   release_key_hash_table (used);
2025   release_key_hash_table (stored);
2026   if (!rc && !quit) /* mark trustDB as checked */
2027     {
2028       if (next_expire == 0xffffffff || next_expire < start_time )
2029         tdbio_write_nextcheck (0); 
2030       else
2031         {
2032           tdbio_write_nextcheck (next_expire); 
2033           log_info (_("next trustdb check due at %s\n"),
2034                     strtimestamp (next_expire));
2035         }
2036
2037       if(tdbio_update_version_record()!=0)
2038         {
2039           log_error(_("unable to update trustdb version record: "
2040                       "write failed: %s\n"), g10_errstr(rc));
2041           tdbio_invalid();
2042         }
2043
2044       do_sync ();
2045       pending_check_trustdb = 0;
2046     }
2047   return rc;
2048 }