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