* trustdb.c (uid_trust_string_fixed): Use a string that can be atoi-ed,
[gnupg.git] / g10 / trustdb.c
1 /* trustdb.c
2  * Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003,
3  *               2004 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_keyid(u32 *keyid)
209 {
210   struct key_item *k;
211
212   k = new_key_item ();
213   k->kid[0] = keyid[0];
214   k->kid[1] = keyid[1];
215   k->next = user_utk_list;
216   user_utk_list = k;
217 }
218
219 void
220 register_trusted_key( const char *string )
221 {
222   KEYDB_SEARCH_DESC desc;
223
224   if (classify_user_id (string, &desc) != KEYDB_SEARCH_MODE_LONG_KID )
225     {
226       log_error(_("`%s' is not a valid long keyID\n"), string );
227       return;
228     }
229
230   register_trusted_keyid(desc.u.kid);
231 }
232
233 /*
234  * Helper to add a key to the global list of ultimately trusted keys.
235  * Retruns: true = inserted, false = already in in list.
236  */
237 static int
238 add_utk (u32 *kid)
239 {
240   struct key_item *k;
241
242   for (k = utk_list; k; k = k->next) 
243     {
244       if (k->kid[0] == kid[0] && k->kid[1] == kid[1])
245         {
246           return 0;
247         }
248     }
249
250   k = new_key_item ();
251   k->kid[0] = kid[0];
252   k->kid[1] = kid[1];
253   k->ownertrust = TRUST_ULTIMATE;
254   k->next = utk_list;
255   utk_list = k;
256   if( opt.verbose > 1 )
257     log_info(_("key %s: accepted as trusted key\n"), keystr(kid));
258   return 1;
259 }
260
261
262 /****************
263  * Verify that all our secret keys are usable and put them into the utk_list.
264  */
265 static void
266 verify_own_keys(void)
267 {
268   TRUSTREC rec;
269   ulong recnum;
270   int rc;
271   struct key_item *k;
272
273   if (utk_list)
274     return;
275
276   /* scan the trustdb to find all ultimately trusted keys */
277   for (recnum=1; !tdbio_read_record (recnum, &rec, 0); recnum++ ) 
278     {
279       if ( rec.rectype == RECTYPE_TRUST 
280            && (rec.r.trust.ownertrust & TRUST_MASK) == TRUST_ULTIMATE)
281         {
282             byte *fpr = rec.r.trust.fingerprint;
283             int fprlen;
284             u32 kid[2];
285             
286             /* Problem: We do only use fingerprints in the trustdb but
287              * we need the keyID here to indetify the key; we can only
288              * use that ugly hack to distinguish between 16 and 20
289              * butes fpr - it does not work always so we better change
290              * the whole validation code to only work with
291              * fingerprints */
292             fprlen = (!fpr[16] && !fpr[17] && !fpr[18] && !fpr[19])? 16:20;
293             keyid_from_fingerprint (fpr, fprlen, kid);
294             if (!add_utk (kid))
295               log_info(_("key %s occurs more than once in the trustdb\n"),
296                        keystr(kid));
297         }
298     }
299
300   /* Put any --trusted-key keys into the trustdb */
301   for (k = user_utk_list; k; k = k->next) 
302     {
303       if ( add_utk (k->kid) ) 
304         { /* not yet in trustDB as ultimately trusted */
305           PKT_public_key pk;
306
307           memset (&pk, 0, sizeof pk);
308           rc = get_pubkey (&pk, k->kid);
309           if (rc)
310             log_info(_("key %s: no public key for trusted key - skipped\n"),
311                      keystr(k->kid));
312           else
313             {
314               update_ownertrust (&pk,
315                                  ((get_ownertrust (&pk) & ~TRUST_MASK)
316                                   | TRUST_ULTIMATE ));
317               release_public_key_parts (&pk);
318             }
319
320           log_info (_("key %s marked as ultimately trusted\n"),keystr(k->kid));
321         }
322     }
323
324   /* release the helper table table */
325   release_key_items (user_utk_list);
326   user_utk_list = NULL;
327   return;
328 }
329
330 \f
331 /*********************************************
332  *********** TrustDB stuff *******************
333  *********************************************/
334
335 /*
336  * Read a record but die if it does not exist
337  */
338 static void
339 read_record (ulong recno, TRUSTREC *rec, int rectype )
340 {
341   int rc = tdbio_read_record (recno, rec, rectype);
342   if (rc)
343     {
344       log_error(_("trust record %lu, req type %d: read failed: %s\n"),
345                 recno, rec->rectype, g10_errstr(rc) );
346       tdbio_invalid();
347     }
348   if (rectype != rec->rectype)
349     {
350       log_error(_("trust record %lu is not of requested type %d\n"),
351                 rec->recnum, rectype);
352       tdbio_invalid();
353     }
354 }
355
356 /*
357  * Write a record and die on error
358  */
359 static void
360 write_record (TRUSTREC *rec)
361 {
362   int rc = tdbio_write_record (rec);
363   if (rc)
364     {
365       log_error(_("trust record %lu, type %d: write failed: %s\n"),
366                             rec->recnum, rec->rectype, g10_errstr(rc) );
367       tdbio_invalid();
368     }
369 }
370
371 /*
372  * sync the TrustDb and die on error
373  */
374 static void
375 do_sync(void)
376 {
377     int rc = tdbio_sync ();
378     if(rc)
379       {
380         log_error (_("trustdb: sync failed: %s\n"), g10_errstr(rc) );
381         g10_exit(2);
382       }
383 }
384
385 static const char *
386 trust_model_string(void)
387 {
388   switch(opt.trust_model)
389     {
390     case TM_CLASSIC:  return "classic";
391     case TM_PGP:      return "PGP";
392     case TM_EXTERNAL: return "external";
393     case TM_ALWAYS:   return "always";
394     case TM_DIRECT:   return "direct";
395     default:          return "unknown";
396     }
397 }
398
399 /****************
400  * Perform some checks over the trustdb
401  *  level 0: only open the db
402  *        1: used for initial program startup
403  */
404 int
405 setup_trustdb( int level, const char *dbname )
406 {
407     /* just store the args */
408     if( trustdb_args.init )
409         return 0;
410     trustdb_args.level = level;
411     trustdb_args.dbname = dbname? m_strdup(dbname): NULL;
412     return 0;
413 }
414
415 void
416 init_trustdb()
417 {
418   int level = trustdb_args.level;
419   const char* dbname = trustdb_args.dbname;
420
421   if( trustdb_args.init )
422     return;
423
424   trustdb_args.init = 1;
425
426   if(level==0 || level==1)
427     {
428       int rc = tdbio_set_dbname( dbname, !!level );
429       if( rc )
430         log_fatal("can't init trustdb: %s\n", g10_errstr(rc) );
431     }
432   else
433     BUG();
434
435   if(opt.trust_model==TM_AUTO)
436     {
437       /* Try and set the trust model off of whatever the trustdb says
438          it is. */
439       opt.trust_model=tdbio_read_model();
440
441       /* Sanity check this ;) */
442       if(opt.trust_model!=TM_CLASSIC
443          && opt.trust_model!=TM_PGP
444          && opt.trust_model!=TM_EXTERNAL)
445         {
446           log_info(_("unable to use unknown trust model (%d) - "
447                      "assuming %s trust model\n"),opt.trust_model,"PGP");
448           opt.trust_model=TM_PGP;
449         }
450
451       if(opt.verbose)
452         log_info(_("using %s trust model\n"),trust_model_string());
453     }
454
455   if(opt.trust_model==TM_PGP || opt.trust_model==TM_CLASSIC)
456     {
457       /* Verify the list of ultimately trusted keys and move the
458          --trusted-keys list there as well. */
459       if(level==1)
460         verify_own_keys();
461
462       if(!tdbio_db_matches_options())
463         pending_check_trustdb=1;
464     }
465 }
466
467
468 /***********************************************
469  *************  Print helpers   ****************
470  ***********************************************/
471
472 /****************
473  * This function returns a letter for a trustvalue  Trust flags
474  * are ignore.
475  */
476 static int
477 trust_letter (unsigned int value)
478 {
479   switch( (value & TRUST_MASK) ) 
480     {
481     case TRUST_UNKNOWN:   return '-';
482     case TRUST_EXPIRED:   return 'e';
483     case TRUST_UNDEFINED: return 'q';
484     case TRUST_NEVER:     return 'n';
485     case TRUST_MARGINAL:  return 'm';
486     case TRUST_FULLY:     return 'f';
487     case TRUST_ULTIMATE:  return 'u';
488     default:              return '?';
489     }
490 }
491
492 /* NOTE TO TRANSLATOR: these strings are similar to those in
493    trust_value_to_string(), but are a fixed length.  This is needed to
494    make attractive information listings where columns line up
495    properly.  The value "10" should be the length of the strings you
496    choose to translate to.  This is the length in printable columns.
497    It gets passed to atoi() so everything after the number is
498    essentially a comment and need not be translated. */
499 const char *
500 uid_trust_string_fixed(PKT_public_key *key,PKT_user_id *uid)
501 {
502   if(!key && !uid)
503     return _("10 translator see trustdb.c:uid_trust_string_fixed");
504   else if(uid->is_revoked)
505     return                         _("[ revoked]");
506   else if(uid->is_expired)
507     return                         _("[ expired]");
508   else if(key)
509     switch(get_validity(key,uid)&TRUST_MASK)
510       {
511       case TRUST_UNKNOWN:   return _("[ unknown]");
512       case TRUST_UNDEFINED: return _("[  undef ]");
513       case TRUST_MARGINAL:  return _("[marginal]");
514       case TRUST_FULLY:     return _("[  full  ]");
515       case TRUST_ULTIMATE:  return _("[ultimate]");
516       }
517
518   return "err";
519 }
520
521 /* The strings here are similar to those in
522    pkclist.c:do_edit_ownertrust() */
523 const char *
524 trust_value_to_string (unsigned int value)
525 {
526   switch( (value & TRUST_MASK) ) 
527     {
528     case TRUST_UNKNOWN:   return _("unknown");
529     case TRUST_EXPIRED:   return _("expired");
530     case TRUST_UNDEFINED: return _("undefined");
531     case TRUST_NEVER:     return _("never");
532     case TRUST_MARGINAL:  return _("marginal");
533     case TRUST_FULLY:     return _("full");
534     case TRUST_ULTIMATE:  return _("ultimate");
535     default:              return "err";
536     }
537 }
538
539 int
540 string_to_trust_value (const char *str)
541 {
542   if(ascii_strcasecmp(str,"undefined")==0)
543     return TRUST_UNDEFINED;
544   else if(ascii_strcasecmp(str,"never")==0)
545     return TRUST_NEVER;
546   else if(ascii_strcasecmp(str,"marginal")==0)
547     return TRUST_MARGINAL;
548   else if(ascii_strcasecmp(str,"full")==0)
549     return TRUST_FULLY;
550   else if(ascii_strcasecmp(str,"ultimate")==0)
551     return TRUST_ULTIMATE;
552   else
553     return -1;
554 }
555
556 /****************
557  * Recreate the WoT but do not ask for new ownertrusts.  Special
558  * feature: In batch mode and without a forced yes, this is only done
559  * when a check is due.  This can be used to run the check from a crontab
560  */
561 void
562 check_trustdb ()
563 {
564   init_trustdb();
565   if(opt.trust_model==TM_PGP || opt.trust_model==TM_CLASSIC)
566     {
567       if (opt.batch && !opt.answer_yes)
568         {
569           ulong scheduled;
570
571           scheduled = tdbio_read_nextcheck ();
572           if (!scheduled)
573             {
574               log_info (_("no need for a trustdb check\n"));
575               return;
576             }
577
578           if (scheduled > make_timestamp ())
579             {
580               log_info (_("next trustdb check due at %s\n"),
581                         strtimestamp (scheduled));
582               return;
583             }
584         }
585
586       validate_keys (0);
587     }
588   else
589     log_info (_("no need for a trustdb check with `%s' trust model\n"),
590               trust_model_string());
591 }
592
593
594 /*
595  * Recreate the WoT. 
596  */
597 void
598 update_trustdb()
599 {
600   init_trustdb();
601   if(opt.trust_model==TM_PGP || opt.trust_model==TM_CLASSIC)
602     validate_keys (1);
603   else
604     log_info (_("no need for a trustdb update with `%s' trust model\n"),
605               trust_model_string());
606 }
607
608 void
609 revalidation_mark (void)
610 {
611   init_trustdb();
612   /* we simply set the time for the next check to 1 (far back in 1970)
613    * so that a --update-trustdb will be scheduled */
614   if (tdbio_write_nextcheck (1))
615       do_sync ();
616   pending_check_trustdb = 1;
617 }
618
619 int
620 trustdb_pending_check(void)
621 {
622   return pending_check_trustdb;
623 }
624
625 void
626 read_trust_options(byte *trust_model,ulong *created,ulong *nextcheck,
627                    byte *marginals,byte *completes,byte *cert_depth)
628 {
629   TRUSTREC opts;
630
631   init_trustdb();
632
633   read_record(0,&opts,RECTYPE_VER);
634
635   if(trust_model)
636     *trust_model=opts.r.ver.trust_model;
637   if(created)
638     *created=opts.r.ver.created;
639   if(nextcheck)
640     *nextcheck=opts.r.ver.nextcheck;
641   if(marginals)
642     *marginals=opts.r.ver.marginals;
643   if(completes)
644     *completes=opts.r.ver.completes;
645   if(cert_depth)
646     *cert_depth=opts.r.ver.cert_depth;
647 }
648
649 /***********************************************
650  ***********  Ownertrust et al. ****************
651  ***********************************************/
652
653 static int 
654 read_trust_record (PKT_public_key *pk, TRUSTREC *rec)
655 {
656   int rc;
657   
658   init_trustdb();
659   rc = tdbio_search_trust_bypk (pk, rec);
660   if (rc == -1)
661     return -1; /* no record yet */
662   if (rc) 
663     {
664       log_error ("trustdb: searching trust record failed: %s\n",
665                  g10_errstr (rc));
666       return rc; 
667     }
668       
669   if (rec->rectype != RECTYPE_TRUST)
670     {
671       log_error ("trustdb: record %lu is not a trust record\n",
672                  rec->recnum);
673       return G10ERR_TRUSTDB; 
674     }      
675   
676   return 0;
677 }
678
679 /****************
680  * Return the assigned ownertrust value for the given public key.
681  * The key should be the primary key.
682  */
683 unsigned int 
684 get_ownertrust ( PKT_public_key *pk)
685 {
686   TRUSTREC rec;
687   int rc;
688   
689   rc = read_trust_record (pk, &rec);
690   if (rc == -1)
691     return TRUST_UNKNOWN; /* no record yet */
692   if (rc) 
693     {
694       tdbio_invalid ();
695       return rc; /* actually never reached */
696     }
697
698   return rec.r.trust.ownertrust;
699 }
700
701 unsigned int 
702 get_min_ownertrust (PKT_public_key *pk)
703 {
704   TRUSTREC rec;
705   int rc;
706   
707   rc = read_trust_record (pk, &rec);
708   if (rc == -1)
709     return TRUST_UNKNOWN; /* no record yet */
710   if (rc) 
711     {
712       tdbio_invalid ();
713       return rc; /* actually never reached */
714     }
715
716   return rec.r.trust.min_ownertrust;
717 }
718
719 /*
720  * Same as get_ownertrust but this takes the minimum ownertrust value
721  * into into account, and will bump up the value as needed.
722  */
723 static int
724 get_ownertrust_with_min (PKT_public_key *pk)
725 {
726   unsigned int otrust,otrust_min;
727
728   otrust = (get_ownertrust (pk) & TRUST_MASK);
729   otrust_min = get_min_ownertrust (pk);
730   if(otrust<otrust_min)
731     {
732       /* If the trust that the user has set is less than the trust
733          that was calculated from a trust signature chain, use the
734          higher of the two.  We do this here and not in
735          get_ownertrust since the underlying ownertrust should not
736          really be set - just the appearance of the ownertrust. */
737
738       otrust=otrust_min;
739     }
740
741   return otrust;
742 }
743
744 /*
745  * Same as get_ownertrust but return a trust letter instead of an
746  * value.  This takes the minimum ownertrust value into account.
747  */
748 int
749 get_ownertrust_info (PKT_public_key *pk)
750 {
751   return trust_letter(get_ownertrust_with_min(pk));
752 }
753
754 /*
755  * Same as get_ownertrust but return a trust string instead of an
756  * value.  This takes the minimum ownertrust value into account.
757  */
758 const char *
759 get_ownertrust_string (PKT_public_key *pk)
760 {
761   return trust_value_to_string(get_ownertrust_with_min(pk));
762 }
763
764 /*
765  * Set the trust value of the given public key to the new value.
766  * The key should be a primary one.
767  */
768 void
769 update_ownertrust (PKT_public_key *pk, unsigned int new_trust )
770 {
771   TRUSTREC rec;
772   int rc;
773   
774   rc = read_trust_record (pk, &rec);
775   if (!rc)
776     {
777       if (DBG_TRUST)
778         log_debug ("update ownertrust from %u to %u\n",
779                    (unsigned int)rec.r.trust.ownertrust, new_trust );
780       if (rec.r.trust.ownertrust != new_trust)
781         {
782           rec.r.trust.ownertrust = new_trust;
783           write_record( &rec );
784           revalidation_mark ();
785           do_sync ();
786         }
787     }
788   else if (rc == -1)
789     { /* no record yet - create a new one */
790       size_t dummy;
791
792       if (DBG_TRUST)
793         log_debug ("insert ownertrust %u\n", new_trust );
794
795       memset (&rec, 0, sizeof rec);
796       rec.recnum = tdbio_new_recnum ();
797       rec.rectype = RECTYPE_TRUST;
798       fingerprint_from_pk (pk, rec.r.trust.fingerprint, &dummy);
799       rec.r.trust.ownertrust = new_trust;
800       write_record (&rec);
801       revalidation_mark ();
802       do_sync ();
803       rc = 0;
804     }
805   else 
806     {
807       tdbio_invalid ();
808     }
809 }
810
811 static void
812 update_min_ownertrust (u32 *kid, unsigned int new_trust )
813 {
814   PKT_public_key *pk;
815   TRUSTREC rec;
816   int rc;
817
818   pk = m_alloc_clear (sizeof *pk);
819   rc = get_pubkey (pk, kid);
820   if (rc)
821     {
822       log_error(_("public key %s not found: %s\n"),keystr(kid),g10_errstr(rc));
823       return;
824     }
825
826   rc = read_trust_record (pk, &rec);
827   if (!rc)
828     {
829       if (DBG_TRUST)
830         log_debug ("key %08lX%08lX: update min_ownertrust from %u to %u\n",
831                    (ulong)kid[0],(ulong)kid[1],
832                    (unsigned int)rec.r.trust.min_ownertrust,
833                    new_trust );
834       if (rec.r.trust.min_ownertrust != new_trust)
835         {
836           rec.r.trust.min_ownertrust = new_trust;
837           write_record( &rec );
838           revalidation_mark ();
839           do_sync ();
840         }
841     }
842   else if (rc == -1)
843     { /* no record yet - create a new one */
844       size_t dummy;
845
846       if (DBG_TRUST)
847         log_debug ("insert min_ownertrust %u\n", new_trust );
848
849       memset (&rec, 0, sizeof rec);
850       rec.recnum = tdbio_new_recnum ();
851       rec.rectype = RECTYPE_TRUST;
852       fingerprint_from_pk (pk, rec.r.trust.fingerprint, &dummy);
853       rec.r.trust.min_ownertrust = new_trust;
854       write_record (&rec);
855       revalidation_mark ();
856       do_sync ();
857       rc = 0;
858     }
859   else 
860     {
861       tdbio_invalid ();
862     }
863 }
864
865 /* Clear the ownertrust and min_ownertrust values.  Return true if a
866    change actually happened. */
867 int
868 clear_ownertrusts (PKT_public_key *pk)
869 {
870   TRUSTREC rec;
871   int rc;
872   
873   rc = read_trust_record (pk, &rec);
874   if (!rc)
875     {
876       if (DBG_TRUST)
877         {
878           log_debug ("clearing ownertrust (old value %u)\n",
879                      (unsigned int)rec.r.trust.ownertrust);
880           log_debug ("clearing min_ownertrust (old value %u)\n",
881                      (unsigned int)rec.r.trust.min_ownertrust);
882         }
883       if (rec.r.trust.ownertrust || rec.r.trust.min_ownertrust)
884         {
885           rec.r.trust.ownertrust = 0;
886           rec.r.trust.min_ownertrust = 0;
887           write_record( &rec );
888           revalidation_mark ();
889           do_sync ();
890           return 1;
891         }
892     }
893   else if (rc != -1)
894     {
895       tdbio_invalid ();
896     }
897   return 0;
898 }
899
900 /* 
901  * Note: Caller has to do a sync 
902  */
903 static void
904 update_validity (PKT_public_key *pk, PKT_user_id *uid,
905                  int depth, int validity)
906 {
907   TRUSTREC trec, vrec;
908   int rc;
909   ulong recno;
910
911   namehash_from_uid(uid);
912
913   rc = read_trust_record (pk, &trec);
914   if (rc && rc != -1)
915     {
916       tdbio_invalid ();
917       return;
918     }
919   if (rc == -1) /* no record yet - create a new one */
920     { 
921       size_t dummy;
922
923       rc = 0;
924       memset (&trec, 0, sizeof trec);
925       trec.recnum = tdbio_new_recnum ();
926       trec.rectype = RECTYPE_TRUST;
927       fingerprint_from_pk (pk, trec.r.trust.fingerprint, &dummy);
928       trec.r.trust.ownertrust = 0;
929       }
930
931   /* locate an existing one */
932   recno = trec.r.trust.validlist;
933   while (recno)
934     {
935       read_record (recno, &vrec, RECTYPE_VALID);
936       if ( !memcmp (vrec.r.valid.namehash, uid->namehash, 20) )
937         break;
938       recno = vrec.r.valid.next;
939     }
940
941   if (!recno) /* insert a new validity record */
942     {
943       memset (&vrec, 0, sizeof vrec);
944       vrec.recnum = tdbio_new_recnum ();
945       vrec.rectype = RECTYPE_VALID;
946       memcpy (vrec.r.valid.namehash, uid->namehash, 20);
947       vrec.r.valid.next = trec.r.trust.validlist;
948       trec.r.trust.validlist = vrec.recnum;
949     }
950   vrec.r.valid.validity = validity;
951   vrec.r.valid.full_count = uid->help_full_count;
952   vrec.r.valid.marginal_count = uid->help_marginal_count;
953   write_record (&vrec);
954   trec.r.trust.depth = depth;
955   write_record (&trec);
956 }
957
958
959 /***********************************************
960  *********  Query trustdb values  **************
961  ***********************************************/
962
963 /* Return true if key is disabled */
964 int
965 cache_disabled_value(PKT_public_key *pk)
966 {
967   int rc;
968   TRUSTREC trec;
969   int disabled=0;
970
971   if(pk->is_disabled)
972     return (pk->is_disabled==2);
973
974   init_trustdb();
975
976   rc = read_trust_record (pk, &trec);
977   if (rc && rc != -1)
978     {
979       tdbio_invalid ();
980       goto leave;
981     }
982   if (rc == -1) /* no record found, so assume not disabled */
983     goto leave;
984  
985   if(trec.r.trust.ownertrust & TRUST_FLAG_DISABLED)
986     disabled=1;
987  
988   /* Cache it for later so we don't need to look at the trustdb every
989      time */
990   if(disabled)
991     pk->is_disabled=2;
992   else
993     pk->is_disabled=1;
994
995  leave:
996    return disabled;
997 }
998
999 void
1000 check_trustdb_stale(void)
1001 {
1002   static int did_nextcheck=0;
1003
1004   init_trustdb ();
1005   if (!did_nextcheck
1006       && (opt.trust_model==TM_PGP || opt.trust_model==TM_CLASSIC))
1007     {
1008       ulong scheduled;
1009
1010       did_nextcheck = 1;
1011       scheduled = tdbio_read_nextcheck ();
1012       if (scheduled && scheduled <= make_timestamp ())
1013         {
1014           if (opt.no_auto_check_trustdb) 
1015             {
1016               pending_check_trustdb = 1;
1017               log_info (_("please do a --check-trustdb\n"));
1018             }
1019           else
1020             {
1021               log_info (_("checking the trustdb\n"));
1022               validate_keys (0);
1023             }
1024         }
1025     }
1026 }
1027
1028 /*
1029  * Return the validity information for PK.  If the namehash is not
1030  * NULL, the validity of the corresponsing user ID is returned,
1031  * otherwise, a reasonable value for the entire key is returned. 
1032  */
1033 unsigned int
1034 get_validity (PKT_public_key *pk, PKT_user_id *uid)
1035 {
1036   TRUSTREC trec, vrec;
1037   int rc;
1038   ulong recno;
1039   unsigned int validity;
1040   u32 kid[2];
1041   PKT_public_key *main_pk;
1042
1043   if(uid)
1044     namehash_from_uid(uid);
1045
1046   init_trustdb ();
1047   check_trustdb_stale();
1048
1049   keyid_from_pk (pk, kid);
1050   if (pk->main_keyid[0] != kid[0] || pk->main_keyid[1] != kid[1])
1051     { /* this is a subkey - get the mainkey */
1052       main_pk = m_alloc_clear (sizeof *main_pk);
1053       rc = get_pubkey (main_pk, pk->main_keyid);
1054       if (rc)
1055         {
1056           char *tempkeystr=m_strdup(keystr(pk->main_keyid));
1057           log_error ("error getting main key %s of subkey %s: %s\n",
1058                      tempkeystr, keystr(kid), g10_errstr(rc));
1059           m_free(tempkeystr);
1060           validity = TRUST_UNKNOWN; 
1061           goto leave;
1062         }
1063     }
1064   else
1065     main_pk = pk;
1066
1067   if(opt.trust_model==TM_DIRECT)
1068     {
1069       /* Note that this happens BEFORE any user ID stuff is checked.
1070          The direct trust model applies to keys as a whole. */
1071       validity=get_ownertrust(main_pk);
1072       goto leave;
1073     }
1074
1075   rc = read_trust_record (main_pk, &trec);
1076   if (rc && rc != -1)
1077     {
1078       tdbio_invalid ();
1079       return 0;
1080     }
1081   if (rc == -1) /* no record found */
1082     {
1083       validity = TRUST_UNKNOWN; 
1084       goto leave;
1085     }
1086
1087   /* loop over all user IDs */
1088   recno = trec.r.trust.validlist;
1089   validity = 0;
1090   while (recno)
1091     {
1092       read_record (recno, &vrec, RECTYPE_VALID);
1093
1094       if(uid)
1095         {
1096           /* If a user ID is given we return the validity for that
1097              user ID ONLY.  If the namehash is not found, then there
1098              is no validity at all (i.e. the user ID wasn't
1099              signed). */
1100           if(memcmp(vrec.r.valid.namehash,uid->namehash,20)==0)
1101             {
1102               validity=(vrec.r.valid.validity & TRUST_MASK);
1103               break;
1104             }
1105         }
1106       else
1107         {
1108           /* If no namehash is given, we take the maximum validity
1109              over all user IDs */
1110           if ( validity < (vrec.r.valid.validity & TRUST_MASK) )
1111             validity = (vrec.r.valid.validity & TRUST_MASK);
1112         }
1113
1114       recno = vrec.r.valid.next;
1115     }
1116   
1117   if ( (trec.r.trust.ownertrust & TRUST_FLAG_DISABLED) )
1118     {
1119       validity |= TRUST_FLAG_DISABLED;
1120       pk->is_disabled=2;
1121     }
1122   else
1123     pk->is_disabled=1;
1124
1125  leave:
1126   /* set some flags direct from the key */
1127   if (main_pk->is_revoked)
1128     validity |= TRUST_FLAG_REVOKED;
1129   if (main_pk != pk && pk->is_revoked)
1130     validity |= TRUST_FLAG_SUB_REVOKED;
1131   /* Note: expiration is a trust value and not a flag - don't know why
1132    * I initially designed it that way */
1133   if (main_pk->has_expired || pk->has_expired)
1134     validity = (validity & ~TRUST_MASK) | TRUST_EXPIRED;
1135   
1136   if (pending_check_trustdb)
1137     validity |= TRUST_FLAG_PENDING_CHECK;
1138
1139   if (main_pk != pk)
1140     free_public_key (main_pk);
1141   return validity;
1142 }
1143
1144 int
1145 get_validity_info (PKT_public_key *pk, PKT_user_id *uid)
1146 {
1147     int trustlevel;
1148
1149     trustlevel = get_validity (pk, uid);
1150     if( trustlevel & TRUST_FLAG_REVOKED )
1151         return 'r';
1152     return trust_letter ( trustlevel );
1153 }
1154
1155 const char *
1156 get_validity_string (PKT_public_key *pk, PKT_user_id *uid)
1157 {
1158   int trustlevel;
1159
1160   trustlevel = get_validity (pk, uid);
1161   if( trustlevel & TRUST_FLAG_REVOKED )
1162     return _("revoked");
1163   return trust_value_to_string(trustlevel);
1164 }
1165
1166 static void
1167 get_validity_counts (PKT_public_key *pk, PKT_user_id *uid)
1168 {
1169   TRUSTREC trec, vrec;
1170   ulong recno;
1171
1172   if(pk==NULL || uid==NULL)
1173     BUG();
1174
1175   namehash_from_uid(uid);
1176
1177   uid->help_marginal_count=uid->help_full_count=0;
1178
1179   init_trustdb ();
1180
1181   if(read_trust_record (pk, &trec)!=0)
1182     return;
1183
1184   /* loop over all user IDs */
1185   recno = trec.r.trust.validlist;
1186   while (recno)
1187     {
1188       read_record (recno, &vrec, RECTYPE_VALID);
1189
1190       if(memcmp(vrec.r.valid.namehash,uid->namehash,20)==0)
1191         {
1192           uid->help_marginal_count=vrec.r.valid.marginal_count;
1193           uid->help_full_count=vrec.r.valid.full_count;
1194           /*  printf("Fetched marginal %d, full %d\n",uid->help_marginal_count,uid->help_full_count); */
1195           break;
1196         }
1197
1198       recno = vrec.r.valid.next;
1199     }
1200 }
1201
1202 void
1203 list_trust_path( const char *username )
1204 {
1205 }
1206
1207 /****************
1208  * Enumerate all keys, which are needed to build all trust paths for
1209  * the given key.  This function does not return the key itself or
1210  * the ultimate key (the last point in cerificate chain).  Only
1211  * certificate chains which ends up at an ultimately trusted key
1212  * are listed.  If ownertrust or validity is not NULL, the corresponding
1213  * value for the returned LID is also returned in these variable(s).
1214  *
1215  *  1) create a void pointer and initialize it to NULL
1216  *  2) pass this void pointer by reference to this function.
1217  *     Set lid to the key you want to enumerate and pass it by reference.
1218  *  3) call this function as long as it does not return -1
1219  *     to indicate EOF. LID does contain the next key used to build the web
1220  *  4) Always call this function a last time with LID set to NULL,
1221  *     so that it can free its context.
1222  *
1223  * Returns: -1 on EOF or the level of the returned LID
1224  */
1225 int
1226 enum_cert_paths( void **context, ulong *lid,
1227                  unsigned *ownertrust, unsigned *validity )
1228 {
1229     return -1;
1230 }
1231
1232
1233 /****************
1234  * Print the current path
1235  */
1236 void
1237 enum_cert_paths_print( void **context, FILE *fp,
1238                                        int refresh, ulong selected_lid )
1239 {
1240     return;
1241 }
1242
1243
1244 \f
1245 /****************************************
1246  *********** NEW NEW NEW ****************
1247  ****************************************/
1248
1249 static int
1250 ask_ownertrust (u32 *kid,int minimum)
1251 {
1252   PKT_public_key *pk;
1253   int rc;
1254   int ot;
1255
1256   pk = m_alloc_clear (sizeof *pk);
1257   rc = get_pubkey (pk, kid);
1258   if (rc)
1259     {
1260       log_error (_("public key %s not found: %s\n"),
1261                  keystr(kid), g10_errstr(rc) );
1262       return TRUST_UNKNOWN;
1263     }
1264  
1265   if(opt.force_ownertrust)
1266     {
1267       log_info("force trust for key %s to %s\n",
1268                keystr(kid),trust_value_to_string(opt.force_ownertrust));
1269       update_ownertrust(pk,opt.force_ownertrust);
1270       ot=opt.force_ownertrust;
1271     }
1272   else
1273     {
1274       ot=edit_ownertrust(pk,0);
1275       if(ot>0)
1276         ot = get_ownertrust (pk);
1277       else if(ot==0)
1278         ot = minimum?minimum:TRUST_UNDEFINED;
1279       else
1280         ot = -1; /* quit */
1281     }
1282
1283   free_public_key( pk );
1284
1285   return ot;
1286 }
1287
1288
1289 static void
1290 mark_keyblock_seen (KeyHashTable tbl, KBNODE node)
1291 {
1292   for ( ;node; node = node->next )
1293     if (node->pkt->pkttype == PKT_PUBLIC_KEY
1294         || node->pkt->pkttype == PKT_PUBLIC_SUBKEY)
1295       {
1296         u32 aki[2];
1297
1298         keyid_from_pk (node->pkt->pkt.public_key, aki);
1299         add_key_hash_table (tbl, aki);
1300       }
1301 }
1302
1303
1304 static void
1305 dump_key_array (int depth, struct key_array *keys)
1306 {
1307   struct key_array *kar;
1308
1309   for (kar=keys; kar->keyblock; kar++)
1310     {
1311       KBNODE node = kar->keyblock;
1312       u32 kid[2];
1313
1314       keyid_from_pk(node->pkt->pkt.public_key, kid);
1315       printf ("%d:%08lX%08lX:K::%c::::\n",
1316               depth, (ulong)kid[0], (ulong)kid[1], '?');
1317
1318       for (; node; node = node->next)
1319         {
1320           if (node->pkt->pkttype == PKT_USER_ID)
1321             {
1322               int len = node->pkt->pkt.user_id->len;
1323
1324               if (len > 30)
1325                 len = 30;
1326               printf ("%d:%08lX%08lX:U:::%c:::",
1327                       depth, (ulong)kid[0], (ulong)kid[1],
1328                       (node->flag & 4)? 'f':
1329                       (node->flag & 2)? 'm':
1330                       (node->flag & 1)? 'q':'-');
1331               print_string (stdout,  node->pkt->pkt.user_id->name, len, ':');
1332               putchar (':');
1333               putchar ('\n');
1334             }
1335         }
1336     }
1337 }  
1338
1339
1340 static void
1341 store_validation_status (int depth, KBNODE keyblock, KeyHashTable stored)
1342 {
1343   KBNODE node;
1344   int status;
1345   int any = 0;
1346
1347   for (node=keyblock; node; node = node->next)
1348     {
1349       if (node->pkt->pkttype == PKT_USER_ID)
1350         {
1351           PKT_user_id *uid = node->pkt->pkt.user_id;
1352           if (node->flag & 4)
1353             status = TRUST_FULLY;
1354           else if (node->flag & 2)
1355             status = TRUST_MARGINAL;
1356           else if (node->flag & 1)
1357             status = TRUST_UNDEFINED;
1358           else
1359             status = 0;
1360           
1361           if (status)
1362             {
1363               update_validity (keyblock->pkt->pkt.public_key,
1364                                uid, depth, status);
1365
1366               mark_keyblock_seen(stored,keyblock);
1367
1368               any = 1;
1369             }
1370         }
1371     }
1372
1373   if (any)
1374     do_sync ();
1375 }  
1376
1377 /*
1378  * check whether the signature sig is in the klist k
1379  */
1380 static struct key_item *
1381 is_in_klist (struct key_item *k, PKT_signature *sig)
1382 {
1383   for (; k; k = k->next)
1384     {
1385       if (k->kid[0] == sig->keyid[0] && k->kid[1] == sig->keyid[1])
1386         return k;
1387     }
1388   return NULL;
1389 }
1390
1391 /*
1392  * Mark the signature of the given UID which are used to certify it.
1393  * To do this, we first revmove all signatures which are not valid and
1394  * from the remain ones we look for the latest one.  If this is not a
1395  * certification revocation signature we mark the signature by setting
1396  * node flag bit 8.  Note that flag bits 9 and 10 are used for internal
1397  * purposes.  
1398  */
1399 static void
1400 mark_usable_uid_certs (KBNODE keyblock, KBNODE uidnode,
1401                        u32 *main_kid, struct key_item *klist,
1402                        u32 curtime, u32 *next_expire)
1403 {
1404   KBNODE node;
1405   PKT_signature *sig;
1406   
1407   /* first check all signatures */
1408   for (node=uidnode->next; node; node = node->next)
1409     {
1410       node->flag &= ~(1<<8 | 1<<9 | 1<<10);
1411       if (node->pkt->pkttype == PKT_USER_ID
1412           || node->pkt->pkttype == PKT_PUBLIC_SUBKEY)
1413         break; /* ready */
1414       if (node->pkt->pkttype != PKT_SIGNATURE)
1415         continue;
1416       
1417       sig = node->pkt->pkt.signature;
1418       if (sig->keyid[0] == main_kid[0] && sig->keyid[1] == main_kid[1])
1419         continue; /* ignore self-signatures */
1420       if (!IS_UID_SIG(sig) && !IS_UID_REV(sig))
1421         continue; /* we only look at these signature classes */
1422       if(sig->sig_class>=0x11 && sig->sig_class<=0x13 &&
1423          sig->sig_class-0x10<opt.min_cert_level)
1424         continue;
1425       if (!is_in_klist (klist, sig))
1426         continue;  /* no need to check it then */
1427       if (check_key_signature (keyblock, node, NULL))
1428         continue; /* ignore invalid signatures */
1429       node->flag |= 1<<9;
1430     }      
1431   /* reset the remaining flags */
1432   for (; node; node = node->next)
1433       node->flag &= ~(1<<8 | 1<<9 | 1 << 10);
1434
1435   /* kbnode flag usage: bit 9 is here set for signatures to consider,
1436    * bit 10 will be set by the loop to keep track of keyIDs already
1437    * processed, bit 8 will be set for the usable signatures */
1438
1439   /* for each cert figure out the latest valid one */
1440   for (node=uidnode->next; node; node = node->next)
1441     {
1442       KBNODE n, signode;
1443       u32 kid[2];
1444       u32 sigdate;
1445       
1446       if (node->pkt->pkttype == PKT_PUBLIC_SUBKEY)
1447         break;
1448       if ( !(node->flag & (1<<9)) )
1449         continue; /* not a node to look at */
1450       if ( (node->flag & (1<<10)) )
1451         continue; /* signature with a keyID already processed */
1452       node->flag |= (1<<10); /* mark this node as processed */
1453       sig = node->pkt->pkt.signature;
1454       signode = node;
1455       sigdate = sig->timestamp;
1456       kid[0] = sig->keyid[0]; kid[1] = sig->keyid[1];
1457       for (n=uidnode->next; n; n = n->next)
1458         {
1459           if (n->pkt->pkttype == PKT_PUBLIC_SUBKEY)
1460             break;
1461           if ( !(n->flag & (1<<9)) )
1462             continue;
1463           if ( (n->flag & (1<<10)) )
1464             continue; /* shortcut already processed signatures */
1465           sig = n->pkt->pkt.signature;
1466           if (kid[0] != sig->keyid[0] || kid[1] != sig->keyid[1])
1467             continue;
1468           n->flag |= (1<<10); /* mark this node as processed */
1469
1470           /* If signode is nonrevocable and unexpired and n isn't,
1471              then take signode (skip).  It doesn't matter which is
1472              older: if signode was older then we don't want to take n
1473              as signode is nonrevocable.  If n was older then we're
1474              automatically fine. */
1475           
1476           if(((IS_UID_SIG(signode->pkt->pkt.signature) &&
1477                !signode->pkt->pkt.signature->flags.revocable &&
1478                (signode->pkt->pkt.signature->expiredate==0 ||
1479                 signode->pkt->pkt.signature->expiredate>curtime))) &&
1480              (!(IS_UID_SIG(n->pkt->pkt.signature) &&
1481                 !n->pkt->pkt.signature->flags.revocable &&
1482                 (n->pkt->pkt.signature->expiredate==0 ||
1483                  n->pkt->pkt.signature->expiredate>curtime))))
1484             continue;
1485
1486           /* If n is nonrevocable and unexpired and signode isn't,
1487              then take n.  Again, it doesn't matter which is older: if
1488              n was older then we don't want to take signode as n is
1489              nonrevocable.  If signode was older then we're
1490              automatically fine. */
1491           
1492           if((!(IS_UID_SIG(signode->pkt->pkt.signature) &&
1493                 !signode->pkt->pkt.signature->flags.revocable &&
1494                 (signode->pkt->pkt.signature->expiredate==0 ||
1495                  signode->pkt->pkt.signature->expiredate>curtime))) &&
1496              ((IS_UID_SIG(n->pkt->pkt.signature) &&
1497                !n->pkt->pkt.signature->flags.revocable &&
1498                (n->pkt->pkt.signature->expiredate==0 ||
1499                 n->pkt->pkt.signature->expiredate>curtime))))
1500             {
1501               signode = n;
1502               sigdate = sig->timestamp;
1503               continue;
1504             }
1505
1506           /* At this point, if it's newer, it goes in as the only
1507              remaining possibilities are signode and n are both either
1508              revocable or expired or both nonrevocable and unexpired.
1509              If the timestamps are equal take the later ordered
1510              packet, presuming that the key packets are hopefully in
1511              their original order. */
1512
1513           if (sig->timestamp >= sigdate)
1514             {
1515               signode = n;
1516               sigdate = sig->timestamp;
1517             }
1518         }
1519       sig = signode->pkt->pkt.signature;
1520       if (IS_UID_SIG (sig))
1521         { /* this seems to be a usable one which is not revoked. 
1522            * Just need to check whether there is an expiration time,
1523            * We do the expired certification after finding a suitable
1524            * certification, the assumption is that a signator does not
1525            * want that after the expiration of his certificate the
1526            * system falls back to an older certification which has a
1527            * different expiration time */
1528           const byte *p;
1529           u32 expire;
1530                     
1531           p = parse_sig_subpkt (sig->hashed, SIGSUBPKT_SIG_EXPIRE, NULL );
1532           expire = p? sig->timestamp + buffer_to_u32(p) : 0;
1533
1534           if (expire==0 || expire > curtime )
1535             {
1536               signode->flag |= (1<<8); /* yeah, found a good cert */
1537               if (expire && expire < *next_expire)
1538                 *next_expire = expire;
1539             }
1540         }
1541     }
1542 }
1543
1544 /* Used by validate_one_keyblock to confirm a regexp within a trust
1545    signature.  Returns 1 for match, and 0 for no match or regex
1546    error. */
1547 static int
1548 check_regexp(const char *expr,const char *string)
1549 {
1550 #ifdef DISABLE_REGEX
1551   /* When DISABLE_REGEX is defined, assume all regexps do not
1552      match. */
1553   return 0;
1554 #elif defined(__riscos__)
1555   return riscos_check_regexp(expr, string, DBG_TRUST);
1556 #else
1557   int ret;
1558   regex_t pat;
1559
1560   if(regcomp(&pat,expr,REG_ICASE|REG_NOSUB|REG_EXTENDED)!=0)
1561     return 0;
1562
1563   ret=regexec(&pat,string,0,NULL,0);
1564
1565   regfree(&pat);
1566
1567   if(DBG_TRUST)
1568     log_debug("regexp `%s' on `%s': %s\n",expr,string,ret==0?"YES":"NO");
1569
1570   return (ret==0);
1571 #endif
1572 }
1573
1574 /*
1575  * Return true if the key is signed by one of the keys in the given
1576  * key ID list.  User IDs with a valid signature are marked by node
1577  * flags as follows:
1578  *  flag bit 0: There is at least one signature
1579  *           1: There is marginal confidence that this is a legitimate uid
1580  *           2: There is full confidence that this is a legitimate uid.
1581  *           8: Used for internal purposes.
1582  *           9: Ditto (in mark_usable_uid_certs())
1583  *          10: Ditto (ditto)
1584  * This function assumes that all kbnode flags are cleared on entry.
1585  */
1586 static int
1587 validate_one_keyblock (KBNODE kb, struct key_item *klist,
1588                        u32 curtime, u32 *next_expire)
1589 {
1590   struct key_item *kr;
1591   KBNODE node, uidnode=NULL;
1592   PKT_user_id *uid=NULL;
1593   PKT_public_key *pk = kb->pkt->pkt.public_key;
1594   u32 main_kid[2];
1595   int issigned=0, any_signed = 0;
1596
1597   keyid_from_pk(pk, main_kid);
1598   for (node=kb; node; node = node->next)
1599     {
1600       /* A bit of discussion here: is it better for the web of trust
1601          to be built among only self-signed uids?  On the one hand, a
1602          self-signed uid is a statement that the key owner definitely
1603          intended that uid to be there, but on the other hand, a
1604          signed (but not self-signed) uid does carry trust, of a sort,
1605          even if it is a statement being made by people other than the
1606          key owner "through" the uids on the key owner's key.  I'm
1607          going with the latter.  However, if the user ID was
1608          explicitly revoked, or passively allowed to expire, that
1609          should stop validity through the user ID until it is
1610          resigned.  -dshaw */
1611
1612       if (node->pkt->pkttype == PKT_USER_ID
1613           && !node->pkt->pkt.user_id->is_revoked
1614           && !node->pkt->pkt.user_id->is_expired)
1615         {
1616           if (uidnode && issigned)
1617             {
1618               if (uid->help_full_count >= opt.completes_needed
1619                   || uid->help_marginal_count >= opt.marginals_needed )
1620                 uidnode->flag |= 4; 
1621               else if (uid->help_full_count || uid->help_marginal_count)
1622                 uidnode->flag |= 2;
1623               uidnode->flag |= 1;
1624               any_signed = 1;
1625             }
1626           uidnode = node;
1627           uid=uidnode->pkt->pkt.user_id;
1628
1629           /* If the selfsig is going to expire... */
1630           if(uid->expiredate && uid->expiredate<*next_expire)
1631             *next_expire = uid->expiredate;
1632
1633           issigned = 0;
1634           get_validity_counts(pk,uid);
1635           mark_usable_uid_certs (kb, uidnode, main_kid, klist, 
1636                                  curtime, next_expire);
1637         }
1638       else if (node->pkt->pkttype == PKT_SIGNATURE
1639                && (node->flag & (1<<8)) && uid)
1640         {
1641           /* Note that we are only seeing unrevoked sigs here */
1642           PKT_signature *sig = node->pkt->pkt.signature;
1643           
1644           kr = is_in_klist (klist, sig);
1645           /* If the trust_regexp does not match, it's as if the sig
1646              did not exist.  This is safe for non-trust sigs as well
1647              since we don't accept a regexp on the sig unless it's a
1648              trust sig. */
1649           if (kr && (kr->trust_regexp==NULL || opt.trust_model!=TM_PGP ||
1650                      (uidnode && check_regexp(kr->trust_regexp,
1651                                             uidnode->pkt->pkt.user_id->name))))
1652             {
1653               if(DBG_TRUST && opt.trust_model==TM_PGP && sig->trust_depth)
1654                 log_debug("trust sig on %s, sig depth is %d, kr depth is %d\n",
1655                           uidnode->pkt->pkt.user_id->name,sig->trust_depth,
1656                           kr->trust_depth);
1657
1658               /* Are we part of a trust sig chain?  We always favor
1659                  the latest trust sig, rather than the greater or
1660                  lesser trust sig or value.  I could make a decent
1661                  argument for any of these cases, but this seems to be
1662                  what PGP does, and I'd like to be compatible. -dms */
1663               if(opt.trust_model==TM_PGP && sig->trust_depth
1664                  && pk->trust_timestamp<=sig->timestamp
1665                  && (sig->trust_depth<=kr->trust_depth
1666                      || kr->ownertrust==TRUST_ULTIMATE))
1667                 {
1668                   /* If we got here, we know that:
1669
1670                      this is a trust sig.
1671
1672                      it's a newer trust sig than any previous trust
1673                      sig on this key (not uid).
1674
1675                      it is legal in that it was either generated by an
1676                      ultimate key, or a key that was part of a trust
1677                      chain, and the depth does not violate the
1678                      original trust sig.
1679
1680                      if there is a regexp attached, it matched
1681                      successfully.
1682                   */
1683
1684                   if(DBG_TRUST)
1685                     log_debug("replacing trust value %d with %d and "
1686                               "depth %d with %d\n",
1687                               pk->trust_value,sig->trust_value,
1688                               pk->trust_depth,sig->trust_depth);
1689
1690                   pk->trust_value=sig->trust_value;
1691                   pk->trust_depth=sig->trust_depth-1;
1692
1693                   /* If the trust sig contains a regexp, record it
1694                      on the pk for the next round. */
1695                   if(sig->trust_regexp)
1696                     pk->trust_regexp=sig->trust_regexp;
1697                 }
1698
1699               if (kr->ownertrust == TRUST_ULTIMATE)
1700                 uid->help_full_count = opt.completes_needed;
1701               else if (kr->ownertrust == TRUST_FULLY)
1702                 uid->help_full_count++;
1703               else if (kr->ownertrust == TRUST_MARGINAL)
1704                 uid->help_marginal_count++;
1705               issigned = 1;
1706             }
1707         }
1708     }
1709
1710   if (uidnode && issigned)
1711     {
1712       if (uid->help_full_count >= opt.completes_needed
1713           || uid->help_marginal_count >= opt.marginals_needed )
1714         uidnode->flag |= 4; 
1715       else if (uid->help_full_count || uid->help_marginal_count)
1716         uidnode->flag |= 2;
1717       uidnode->flag |= 1;
1718       any_signed = 1;
1719     }
1720
1721   return any_signed;
1722 }
1723
1724
1725 static int
1726 search_skipfnc (void *opaque, u32 *kid, PKT_user_id *dummy)
1727 {
1728   return test_key_hash_table ((KeyHashTable)opaque, kid);
1729 }
1730
1731
1732 /*
1733  * Scan all keys and return a key_array of all suitable keys from
1734  * kllist.  The caller has to pass keydb handle so that we don't use
1735  * to create our own.  Returns either a key_array or NULL in case of
1736  * an error.  No results found are indicated by an empty array.
1737  * Caller hast to release the returned array.  
1738  */
1739 static struct key_array *
1740 validate_key_list (KEYDB_HANDLE hd, KeyHashTable full_trust,
1741                    struct key_item *klist, u32 curtime, u32 *next_expire)
1742 {
1743   KBNODE keyblock = NULL;
1744   struct key_array *keys = NULL;
1745   size_t nkeys, maxkeys;
1746   int rc;
1747   KEYDB_SEARCH_DESC desc;
1748   
1749   maxkeys = 1000;
1750   keys = m_alloc ((maxkeys+1) * sizeof *keys);
1751   nkeys = 0;
1752   
1753   rc = keydb_search_reset (hd);
1754   if (rc)
1755     {
1756       log_error ("keydb_search_reset failed: %s\n", g10_errstr(rc));
1757       m_free (keys);
1758       return NULL;
1759     }
1760
1761   memset (&desc, 0, sizeof desc);
1762   desc.mode = KEYDB_SEARCH_MODE_FIRST;
1763   desc.skipfnc = search_skipfnc;
1764   desc.skipfncvalue = full_trust;
1765   rc = keydb_search (hd, &desc, 1);
1766   if (rc == -1)
1767     {
1768       keys[nkeys].keyblock = NULL;
1769       return keys;
1770     }
1771   if (rc)
1772     {
1773       log_error ("keydb_search_first failed: %s\n", g10_errstr(rc));
1774       m_free (keys);
1775       return NULL;
1776     }
1777   
1778   desc.mode = KEYDB_SEARCH_MODE_NEXT; /* change mode */
1779   do
1780     {
1781       PKT_public_key *pk;
1782         
1783       rc = keydb_get_keyblock (hd, &keyblock);
1784       if (rc) 
1785         {
1786           log_error ("keydb_get_keyblock failed: %s\n", g10_errstr(rc));
1787           m_free (keys);
1788           return NULL;
1789         }
1790       
1791       if ( keyblock->pkt->pkttype != PKT_PUBLIC_KEY) 
1792         {
1793           log_debug ("ooops: invalid pkttype %d encountered\n",
1794                      keyblock->pkt->pkttype);
1795           dump_kbnode (keyblock);
1796           release_kbnode(keyblock);
1797           continue;
1798         }
1799
1800       /* prepare the keyblock for further processing */
1801       merge_keys_and_selfsig (keyblock); 
1802       clear_kbnode_flags (keyblock);
1803       pk = keyblock->pkt->pkt.public_key;
1804       if (pk->has_expired || pk->is_revoked)
1805         {
1806           /* it does not make sense to look further at those keys */
1807           mark_keyblock_seen (full_trust, keyblock);
1808         }
1809       else if (validate_one_keyblock (keyblock, klist, curtime, next_expire))
1810         {
1811           KBNODE node;
1812
1813           if (pk->expiredate && pk->expiredate >= curtime
1814               && pk->expiredate < *next_expire)
1815             *next_expire = pk->expiredate;
1816
1817           if (nkeys == maxkeys) {
1818             maxkeys += 1000;
1819             keys = m_realloc (keys, (maxkeys+1) * sizeof *keys);
1820           }
1821           keys[nkeys++].keyblock = keyblock;
1822
1823           /* Optimization - if all uids are fully trusted, then we
1824              never need to consider this key as a candidate again. */
1825
1826           for (node=keyblock; node; node = node->next)
1827             if (node->pkt->pkttype == PKT_USER_ID && !(node->flag & 4))
1828               break;
1829
1830           if(node==NULL)
1831             mark_keyblock_seen (full_trust, keyblock);
1832
1833           keyblock = NULL;
1834         }
1835
1836       release_kbnode (keyblock);
1837       keyblock = NULL;
1838     } 
1839   while ( !(rc = keydb_search (hd, &desc, 1)) );
1840   if (rc && rc != -1) 
1841     {
1842       log_error ("keydb_search_next failed: %s\n", g10_errstr(rc));
1843       m_free (keys);
1844       return NULL;
1845     }
1846
1847   keys[nkeys].keyblock = NULL;
1848   return keys;
1849
1850
1851 /* Caller must sync */
1852 static void
1853 reset_trust_records(void)
1854 {
1855   TRUSTREC rec;
1856   ulong recnum;
1857   int count = 0, nreset = 0;
1858
1859   for (recnum=1; !tdbio_read_record (recnum, &rec, 0); recnum++ ) 
1860     {
1861       if(rec.rectype==RECTYPE_TRUST)
1862         {
1863           count++;
1864           if(rec.r.trust.min_ownertrust)
1865             {
1866               rec.r.trust.min_ownertrust=0;
1867               write_record(&rec);
1868             }
1869
1870         }
1871       else if(rec.rectype==RECTYPE_VALID
1872               && ((rec.r.valid.validity&TRUST_MASK)
1873                   || rec.r.valid.marginal_count
1874                   || rec.r.valid.full_count))
1875         {
1876           rec.r.valid.validity &= ~TRUST_MASK;
1877           rec.r.valid.marginal_count=rec.r.valid.full_count=0;
1878           nreset++;
1879           write_record(&rec);
1880         }
1881
1882     }
1883
1884   if (opt.verbose)
1885     log_info (_("%d keys processed (%d validity counts cleared)\n"),
1886               count, nreset);
1887 }
1888
1889 /*
1890  * Run the key validation procedure.
1891  *
1892  * This works this way:
1893  * Step 1: Find all ultimately trusted keys (UTK).
1894  *         mark them all as seen and put them into klist.
1895  * Step 2: loop max_cert_times
1896  * Step 3:   if OWNERTRUST of any key in klist is undefined
1897  *             ask user to assign ownertrust
1898  * Step 4:   Loop over all keys in the keyDB which are not marked seen 
1899  * Step 5:     if key is revoked or expired
1900  *                mark key as seen
1901  *                continue loop at Step 4
1902  * Step 6:     For each user ID of that key signed by a key in klist
1903  *                Calculate validity by counting trusted signatures.
1904  *                Set validity of user ID
1905  * Step 7:     If any signed user ID was found
1906  *                mark key as seen
1907  *             End Loop
1908  * Step 8:   Build a new klist from all fully trusted keys from step 6
1909  *           End Loop
1910  *         Ready  
1911  *
1912  */
1913 static int
1914 validate_keys (int interactive)
1915 {
1916   int rc = 0;
1917   int quit=0;
1918   struct key_item *klist = NULL;
1919   struct key_item *k;
1920   struct key_array *keys = NULL;
1921   struct key_array *kar;
1922   KEYDB_HANDLE kdb = NULL;
1923   KBNODE node;
1924   int depth;
1925   int ot_unknown, ot_undefined, ot_never, ot_marginal, ot_full, ot_ultimate;
1926   KeyHashTable stored,used,full_trust;
1927   u32 start_time, next_expire;
1928
1929   /* Make sure we have all sigs cached.  TODO: This is going to
1930      require some architectual re-thinking, as it is agonizingly slow.
1931      Perhaps combine this with reset_trust_records(), or only check
1932      the caches on keys that are actually involved in the web of
1933      trust. */
1934   keydb_rebuild_caches(0);
1935
1936   start_time = make_timestamp ();
1937   next_expire = 0xffffffff; /* set next expire to the year 2106 */
1938   stored = new_key_hash_table ();
1939   used = new_key_hash_table ();
1940   full_trust = new_key_hash_table ();
1941
1942   kdb = keydb_new (0);
1943   reset_trust_records();
1944
1945   /* Fixme: Instead of always building a UTK list, we could just build it
1946    * here when needed */
1947   if (!utk_list)
1948     {
1949       log_info (_("no ultimately trusted keys found\n"));
1950       goto leave;
1951     }
1952
1953   /* mark all UTKs as used and fully_trusted and set validity to
1954      ultimate */
1955   for (k=utk_list; k; k = k->next)
1956     {
1957       KBNODE keyblock;
1958       PKT_public_key *pk;
1959
1960       keyblock = get_pubkeyblock (k->kid);
1961       if (!keyblock)
1962         {
1963           log_error (_("public key of ultimately"
1964                        " trusted key %s not found\n"), keystr(k->kid));
1965           continue;
1966         }
1967       mark_keyblock_seen (used, keyblock);
1968       mark_keyblock_seen (stored, keyblock);
1969       mark_keyblock_seen (full_trust, keyblock);
1970       pk = keyblock->pkt->pkt.public_key;
1971       for (node=keyblock; node; node = node->next)
1972         {
1973           if (node->pkt->pkttype == PKT_USER_ID)
1974             update_validity (pk, node->pkt->pkt.user_id, 0, TRUST_ULTIMATE);
1975         }
1976       if ( pk->expiredate && pk->expiredate >= start_time
1977            && pk->expiredate < next_expire)
1978         next_expire = pk->expiredate;
1979       
1980       release_kbnode (keyblock);
1981       do_sync ();
1982     }
1983
1984   klist = utk_list;
1985
1986   log_info(_("%d marginal(s) needed, %d complete(s) needed, %s trust model\n"),
1987            opt.marginals_needed,opt.completes_needed,trust_model_string());
1988
1989   for (depth=0; depth < opt.max_cert_depth; depth++)
1990     {
1991       int valids=0,key_count;
1992       /* See whether we should assign ownertrust values to the keys in
1993          klist.  */
1994       ot_unknown = ot_undefined = ot_never = 0;
1995       ot_marginal = ot_full = ot_ultimate = 0;
1996       for (k=klist; k; k = k->next)
1997         {
1998           int min=0;
1999
2000           /* 120 and 60 are as per RFC2440 */
2001           if(k->trust_value>=120)
2002             min=TRUST_FULLY;
2003           else if(k->trust_value>=60)
2004             min=TRUST_MARGINAL;
2005
2006           if(min!=k->min_ownertrust)
2007             update_min_ownertrust(k->kid,min);
2008
2009           if (interactive && k->ownertrust == TRUST_UNKNOWN)
2010             {
2011               k->ownertrust = ask_ownertrust (k->kid,min);
2012
2013               if (k->ownertrust == -1)
2014                 {
2015                   quit=1;
2016                   goto leave;
2017                 }
2018             }
2019
2020           /* This can happen during transition from an old trustdb
2021              before trust sigs.  It can also happen if a user uses two
2022              different versions of GnuPG or changes the --trust-model
2023              setting. */
2024           if(k->ownertrust<min)
2025             {
2026               if(DBG_TRUST)
2027                 log_debug("key %08lX%08lX:"
2028                           " overriding ownertrust `%s' with `%s'\n",
2029                           (ulong)k->kid[0],(ulong)k->kid[1],
2030                           trust_value_to_string(k->ownertrust),
2031                           trust_value_to_string(min));
2032
2033               k->ownertrust=min;
2034             }
2035
2036           if (k->ownertrust == TRUST_UNKNOWN)
2037             ot_unknown++;
2038           else if (k->ownertrust == TRUST_UNDEFINED)
2039             ot_undefined++;
2040           else if (k->ownertrust == TRUST_NEVER)
2041             ot_never++;
2042           else if (k->ownertrust == TRUST_MARGINAL)
2043             ot_marginal++;
2044           else if (k->ownertrust == TRUST_FULLY)
2045             ot_full++;
2046           else if (k->ownertrust == TRUST_ULTIMATE)
2047             ot_ultimate++;
2048
2049           valids++;
2050         }
2051
2052       /* Find all keys which are signed by a key in kdlist */
2053       keys = validate_key_list (kdb, full_trust, klist,
2054                                 start_time, &next_expire);
2055       if (!keys) 
2056         {
2057           log_error ("validate_key_list failed\n");
2058           rc = G10ERR_GENERAL;
2059           goto leave;
2060         }
2061
2062       for (key_count=0, kar=keys; kar->keyblock; kar++, key_count++)
2063         ;
2064
2065       /* Store the calculated valididation status somewhere */
2066       if (opt.verbose > 1)
2067         dump_key_array (depth, keys);
2068
2069       for (kar=keys; kar->keyblock; kar++)
2070           store_validation_status (depth, kar->keyblock, stored);
2071
2072       log_info (_("depth: %d  valid: %3d  signed: %3d"
2073                   "  trust: %d-, %dq, %dn, %dm, %df, %du\n"), 
2074                 depth, valids, key_count, ot_unknown, ot_undefined,
2075                 ot_never, ot_marginal, ot_full, ot_ultimate ); 
2076
2077       /* Build a new kdlist from all fully valid keys in KEYS */
2078       if (klist != utk_list)
2079         release_key_items (klist);
2080       klist = NULL;
2081       for (kar=keys; kar->keyblock; kar++)
2082         {
2083           for (node=kar->keyblock; node; node = node->next)
2084             {
2085               if (node->pkt->pkttype == PKT_USER_ID && (node->flag & 4))
2086                 {
2087                   u32 kid[2];
2088
2089                   /* have we used this key already? */
2090                   keyid_from_pk (kar->keyblock->pkt->pkt.public_key, kid);
2091                   if(test_key_hash_table(used,kid)==0)
2092                     {
2093                       /* Normally we add both the primary and subkey
2094                          ids to the hash via mark_keyblock_seen, but
2095                          since we aren't using this hash as a skipfnc,
2096                          that doesn't matter here. */
2097                       add_key_hash_table (used,kid);
2098                       k = new_key_item ();
2099                       k->kid[0]=kid[0];
2100                       k->kid[1]=kid[1];
2101                       k->ownertrust =
2102                         (get_ownertrust (kar->keyblock->pkt->pkt.public_key)
2103                          & TRUST_MASK);
2104                       k->min_ownertrust =
2105                         get_min_ownertrust(kar->keyblock->pkt->pkt.public_key);
2106                       k->trust_depth=
2107                         kar->keyblock->pkt->pkt.public_key->trust_depth;
2108                       k->trust_value=
2109                         kar->keyblock->pkt->pkt.public_key->trust_value;
2110                       if(kar->keyblock->pkt->pkt.public_key->trust_regexp)
2111                         k->trust_regexp=
2112                           m_strdup(kar->keyblock->pkt->
2113                                    pkt.public_key->trust_regexp);
2114                       k->next = klist;
2115                       klist = k;
2116                       break;
2117                     }
2118                 }
2119             }
2120         }
2121       release_key_array (keys);
2122       keys = NULL;
2123       if (!klist)
2124         break; /* no need to dive in deeper */
2125     }
2126
2127  leave:
2128   keydb_release (kdb);
2129   release_key_array (keys);
2130   release_key_items (klist);
2131   release_key_hash_table (full_trust);
2132   release_key_hash_table (used);
2133   release_key_hash_table (stored);
2134   if (!rc && !quit) /* mark trustDB as checked */
2135     {
2136       if (next_expire == 0xffffffff || next_expire < start_time )
2137         tdbio_write_nextcheck (0); 
2138       else
2139         {
2140           tdbio_write_nextcheck (next_expire); 
2141           log_info (_("next trustdb check due at %s\n"),
2142                     strtimestamp (next_expire));
2143         }
2144
2145       if(tdbio_update_version_record()!=0)
2146         {
2147           log_error(_("unable to update trustdb version record: "
2148                       "write failed: %s\n"), g10_errstr(rc));
2149           tdbio_invalid();
2150         }
2151
2152       do_sync ();
2153       pending_check_trustdb = 0;
2154     }
2155
2156   return rc;
2157 }