Ask to insert the right OpenPGP card.
[gnupg.git] / g10 / trustdb.c
1 /* trustdb.c
2  * Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007,
3  *               2008 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 3 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, see <http://www.gnu.org/licenses/>.
19  */
20
21 #include <config.h>
22 #include <stdio.h>
23 #include <stdlib.h>
24 #include <string.h>
25 #include <assert.h>
26
27 #ifndef DISABLE_REGEX
28 #include <sys/types.h>
29 #include <regex.h>
30 #endif /* !DISABLE_REGEX */
31
32 #include "gpg.h"
33 #include "status.h"
34 #include "iobuf.h"
35 #include "keydb.h"
36 #include "util.h"
37 #include "options.h"
38 #include "packet.h"
39 #include "main.h"
40 #include "i18n.h"
41 #include "tdbio.h"
42 #include "trustdb.h"
43
44
45 /*
46  * A structure to store key identification as well as some stuff needed
47  * for validation 
48  */
49 struct key_item {
50   struct key_item *next;
51   unsigned int ownertrust,min_ownertrust;
52   byte trust_depth;
53   byte trust_value;
54   char *trust_regexp;
55   u32 kid[2];
56 };
57
58
59 typedef struct key_item **KeyHashTable; /* see new_key_hash_table() */
60
61 /*
62  * Structure to keep track of keys, this is used as an array wherre
63  * the item right after the last one has a keyblock set to NULL. 
64  * Maybe we can drop this thing and replace it by key_item
65  */
66 struct key_array {
67   KBNODE keyblock;
68 };
69
70
71 /* control information for the trust DB */
72 static struct {
73     int init;
74     int level;
75     char *dbname;
76 } trustdb_args;
77
78 /* some globals */
79 static struct key_item *user_utk_list; /* temp. used to store --trusted-keys */
80 static struct key_item *utk_list;      /* all ultimately trusted keys */
81
82 static int pending_check_trustdb;
83
84 static int validate_keys (int interactive);
85
86 \f
87 /**********************************************
88  ************* some helpers *******************
89  **********************************************/
90
91 static struct key_item *
92 new_key_item (void)
93 {
94   struct key_item *k;
95   
96   k = xmalloc_clear (sizeof *k);
97   return k;
98 }
99
100 static void
101 release_key_items (struct key_item *k)
102 {
103   struct key_item *k2;
104
105   for (; k; k = k2)
106     {
107       k2 = k->next;
108       xfree (k->trust_regexp);
109       xfree (k);
110     }
111 }
112
113 /*
114  * For fast keylook up we need a hash table.  Each byte of a KeyIDs
115  * should be distributed equally over the 256 possible values (except
116  * for v3 keyIDs but we consider them as not important here). So we
117  * can just use 10 bits to index a table of 1024 key items. 
118  * Possible optimization: Don not use key_items but other hash_table when the
119  * duplicates lists gets too large. 
120  */
121 static KeyHashTable 
122 new_key_hash_table (void)
123 {
124   struct key_item **tbl;
125
126   tbl = xmalloc_clear (1024 * sizeof *tbl);
127   return tbl;
128 }
129
130 static void
131 release_key_hash_table (KeyHashTable tbl)
132 {
133   int i;
134
135   if (!tbl)
136     return;
137   for (i=0; i < 1024; i++)
138     release_key_items (tbl[i]);
139   xfree (tbl);
140 }
141
142 /* 
143  * Returns: True if the keyID is in the given hash table
144  */
145 static int
146 test_key_hash_table (KeyHashTable tbl, u32 *kid)
147 {
148   struct key_item *k;
149
150   for (k = tbl[(kid[1] & 0x03ff)]; k; k = k->next)
151     if (k->kid[0] == kid[0] && k->kid[1] == kid[1])
152       return 1;
153   return 0;
154 }
155
156 /*
157  * Add a new key to the hash table.  The key is identified by its key ID.
158  */
159 static void
160 add_key_hash_table (KeyHashTable tbl, u32 *kid)
161 {
162   struct key_item *k, *kk;
163
164   for (k = tbl[(kid[1] & 0x03ff)]; k; k = k->next)
165     if (k->kid[0] == kid[0] && k->kid[1] == kid[1])
166       return; /* already in table */
167   
168   kk = new_key_item ();
169   kk->kid[0] = kid[0];
170   kk->kid[1] = kid[1];
171   kk->next = tbl[(kid[1] & 0x03ff)];
172   tbl[(kid[1] & 0x03ff)] = kk;
173 }
174
175 /*
176  * Release a key_array
177  */
178 static void
179 release_key_array ( struct key_array *keys )
180 {
181     struct key_array *k;
182
183     if (keys) {
184         for (k=keys; k->keyblock; k++)
185             release_kbnode (k->keyblock);
186         xfree (keys);
187     }
188 }
189
190 \f
191 /*********************************************
192  **********  Initialization  *****************
193  *********************************************/
194
195
196
197 /*
198  * Used to register extra ultimately trusted keys - this has to be done
199  * before initializing the validation module.
200  * FIXME: Should be replaced by a function to add those keys to the trustdb.
201  */
202 void
203 register_trusted_keyid(u32 *keyid)
204 {
205   struct key_item *k;
206
207   k = new_key_item ();
208   k->kid[0] = keyid[0];
209   k->kid[1] = keyid[1];
210   k->next = user_utk_list;
211   user_utk_list = k;
212 }
213
214 void
215 register_trusted_key( const char *string )
216 {
217   KEYDB_SEARCH_DESC desc;
218
219   if (classify_user_id (string, &desc) != KEYDB_SEARCH_MODE_LONG_KID )
220     {
221       log_error(_("`%s' is not a valid long keyID\n"), string );
222       return;
223     }
224
225   register_trusted_keyid(desc.u.kid);
226 }
227
228 /*
229  * Helper to add a key to the global list of ultimately trusted keys.
230  * Retruns: true = inserted, false = already in in list.
231  */
232 static int
233 add_utk (u32 *kid)
234 {
235   struct key_item *k;
236
237   for (k = utk_list; k; k = k->next) 
238     {
239       if (k->kid[0] == kid[0] && k->kid[1] == kid[1])
240         {
241           return 0;
242         }
243     }
244
245   k = new_key_item ();
246   k->kid[0] = kid[0];
247   k->kid[1] = kid[1];
248   k->ownertrust = TRUST_ULTIMATE;
249   k->next = utk_list;
250   utk_list = k;
251   if( opt.verbose > 1 )
252     log_info(_("key %s: accepted as trusted key\n"), keystr(kid));
253   return 1;
254 }
255
256
257 /****************
258  * Verify that all our secret keys are usable and put them into the utk_list.
259  */
260 static void
261 verify_own_keys(void)
262 {
263   TRUSTREC rec;
264   ulong recnum;
265   int rc;
266   struct key_item *k;
267
268   if (utk_list)
269     return;
270
271   /* scan the trustdb to find all ultimately trusted keys */
272   for (recnum=1; !tdbio_read_record (recnum, &rec, 0); recnum++ ) 
273     {
274       if ( rec.rectype == RECTYPE_TRUST 
275            && (rec.r.trust.ownertrust & TRUST_MASK) == TRUST_ULTIMATE)
276         {
277             byte *fpr = rec.r.trust.fingerprint;
278             int fprlen;
279             u32 kid[2];
280             
281             /* Problem: We do only use fingerprints in the trustdb but
282              * we need the keyID here to indetify the key; we can only
283              * use that ugly hack to distinguish between 16 and 20
284              * butes fpr - it does not work always so we better change
285              * the whole validation code to only work with
286              * fingerprints */
287             fprlen = (!fpr[16] && !fpr[17] && !fpr[18] && !fpr[19])? 16:20;
288             keyid_from_fingerprint (fpr, fprlen, kid);
289             if (!add_utk (kid))
290               log_info(_("key %s occurs more than once in the trustdb\n"),
291                        keystr(kid));
292         }
293     }
294
295   /* Put any --trusted-key keys into the trustdb */
296   for (k = user_utk_list; k; k = k->next) 
297     {
298       if ( add_utk (k->kid) ) 
299         { /* not yet in trustDB as ultimately trusted */
300           PKT_public_key pk;
301
302           memset (&pk, 0, sizeof pk);
303           rc = get_pubkey (&pk, k->kid);
304           if (rc)
305             log_info(_("key %s: no public key for trusted key - skipped\n"),
306                      keystr(k->kid));
307           else
308             {
309               update_ownertrust (&pk,
310                                  ((get_ownertrust (&pk) & ~TRUST_MASK)
311                                   | TRUST_ULTIMATE ));
312               release_public_key_parts (&pk);
313             }
314
315           log_info (_("key %s marked as ultimately trusted\n"),keystr(k->kid));
316         }
317     }
318
319   /* release the helper table table */
320   release_key_items (user_utk_list);
321   user_utk_list = NULL;
322   return;
323 }
324
325 \f
326 /*********************************************
327  *********** TrustDB stuff *******************
328  *********************************************/
329
330 /*
331  * Read a record but die if it does not exist
332  */
333 static void
334 read_record (ulong recno, TRUSTREC *rec, int rectype )
335 {
336   int rc = tdbio_read_record (recno, rec, rectype);
337   if (rc)
338     {
339       log_error(_("trust record %lu, req type %d: read failed: %s\n"),
340                 recno, rec->rectype, g10_errstr(rc) );
341       tdbio_invalid();
342     }
343   if (rectype != rec->rectype)
344     {
345       log_error(_("trust record %lu is not of requested type %d\n"),
346                 rec->recnum, rectype);
347       tdbio_invalid();
348     }
349 }
350
351 /*
352  * Write a record and die on error
353  */
354 static void
355 write_record (TRUSTREC *rec)
356 {
357   int rc = tdbio_write_record (rec);
358   if (rc)
359     {
360       log_error(_("trust record %lu, type %d: write failed: %s\n"),
361                             rec->recnum, rec->rectype, g10_errstr(rc) );
362       tdbio_invalid();
363     }
364 }
365
366 /*
367  * sync the TrustDb and die on error
368  */
369 static void
370 do_sync(void)
371 {
372     int rc = tdbio_sync ();
373     if(rc)
374       {
375         log_error (_("trustdb: sync failed: %s\n"), g10_errstr(rc) );
376         g10_exit(2);
377       }
378 }
379
380 static const char *
381 trust_model_string(void)
382 {
383   switch(opt.trust_model)
384     {
385     case TM_CLASSIC:  return "classic";
386     case TM_PGP:      return "PGP";
387     case TM_EXTERNAL: return "external";
388     case TM_ALWAYS:   return "always";
389     case TM_DIRECT:   return "direct";
390     default:          return "unknown";
391     }
392 }
393
394 /****************
395  * Perform some checks over the trustdb
396  *  level 0: only open the db
397  *        1: used for initial program startup
398  */
399 int
400 setup_trustdb( int level, const char *dbname )
401 {
402     /* just store the args */
403     if( trustdb_args.init )
404         return 0;
405     trustdb_args.level = level;
406     trustdb_args.dbname = dbname? xstrdup(dbname): NULL;
407     return 0;
408 }
409
410 void
411 how_to_fix_the_trustdb ()
412 {
413   const char *name = trustdb_args.dbname;
414
415   if (!name)
416     name = "trustdb.gpg";
417
418   log_info (_("You may try to re-create the trustdb using the commands:\n"));
419   log_info ("  cd %s\n", default_homedir ());
420   log_info ("  gpg2 --export-ownertrust > otrust.tmp\n");
421 #ifdef HAVE_W32_SYSTEM
422   log_info ("  del %s\n", name);
423 #else
424   log_info ("  rm %s\n", name);
425 #endif
426   log_info ("  gpg2 --import-ownertrust < otrust.tmp\n");
427   log_info (_("If that does not work, please consult the manual\n"));
428 }
429
430
431 void
432 init_trustdb()
433 {
434   int level = trustdb_args.level;
435   const char* dbname = trustdb_args.dbname;
436
437   if( trustdb_args.init )
438     return;
439
440   trustdb_args.init = 1;
441
442   if(level==0 || level==1)
443     {
444       int rc = tdbio_set_dbname( dbname, !!level );
445       if( rc )
446         log_fatal("can't init trustdb: %s\n", g10_errstr(rc) );
447     }
448   else
449     BUG();
450
451   if(opt.trust_model==TM_AUTO)
452     {
453       /* Try and set the trust model off of whatever the trustdb says
454          it is. */
455       opt.trust_model=tdbio_read_model();
456
457       /* Sanity check this ;) */
458       if(opt.trust_model!=TM_CLASSIC
459          && opt.trust_model!=TM_PGP
460          && opt.trust_model!=TM_EXTERNAL)
461         {
462           log_info(_("unable to use unknown trust model (%d) - "
463                      "assuming %s trust model\n"),opt.trust_model,"PGP");
464           opt.trust_model=TM_PGP;
465         }
466
467       if(opt.verbose)
468         log_info(_("using %s trust model\n"),trust_model_string());
469     }
470
471   if(opt.trust_model==TM_PGP || opt.trust_model==TM_CLASSIC)
472     {
473       /* Verify the list of ultimately trusted keys and move the
474          --trusted-keys list there as well. */
475       if(level==1)
476         verify_own_keys();
477
478       if(!tdbio_db_matches_options())
479         pending_check_trustdb=1;
480     }
481 }
482
483
484 /***********************************************
485  *************  Print helpers   ****************
486  ***********************************************/
487
488 /****************
489  * This function returns a letter for a trustvalue  Trust flags
490  * are ignore.
491  */
492 static int
493 trust_letter (unsigned int value)
494 {
495   switch( (value & TRUST_MASK) ) 
496     {
497     case TRUST_UNKNOWN:   return '-';
498     case TRUST_EXPIRED:   return 'e';
499     case TRUST_UNDEFINED: return 'q';
500     case TRUST_NEVER:     return 'n';
501     case TRUST_MARGINAL:  return 'm';
502     case TRUST_FULLY:     return 'f';
503     case TRUST_ULTIMATE:  return 'u';
504     default:              return '?';
505     }
506 }
507
508 /* NOTE TO TRANSLATOR: these strings are similar to those in
509    trust_value_to_string(), but are a fixed length.  This is needed to
510    make attractive information listings where columns line up
511    properly.  The value "10" should be the length of the strings you
512    choose to translate to.  This is the length in printable columns.
513    It gets passed to atoi() so everything after the number is
514    essentially a comment and need not be translated.  Either key and
515    uid are both NULL, or neither are NULL. */
516 const char *
517 uid_trust_string_fixed(PKT_public_key *key,PKT_user_id *uid)
518 {
519   if(!key && !uid)
520     return _("10 translator see trustdb.c:uid_trust_string_fixed");
521   else if(uid->is_revoked || (key && key->is_revoked))
522     return                         _("[ revoked]");
523   else if(uid->is_expired)
524     return                         _("[ expired]");
525   else if(key)
526     switch(get_validity(key,uid)&TRUST_MASK)
527       {
528       case TRUST_UNKNOWN:   return _("[ unknown]");
529       case TRUST_EXPIRED:   return _("[ expired]");
530       case TRUST_UNDEFINED: return _("[  undef ]");
531       case TRUST_MARGINAL:  return _("[marginal]");
532       case TRUST_FULLY:     return _("[  full  ]");
533       case TRUST_ULTIMATE:  return _("[ultimate]");
534       }
535
536   return "err";
537 }
538
539 /* The strings here are similar to those in
540    pkclist.c:do_edit_ownertrust() */
541 const char *
542 trust_value_to_string (unsigned int value)
543 {
544   switch( (value & TRUST_MASK) ) 
545     {
546     case TRUST_UNKNOWN:   return _("unknown");
547     case TRUST_EXPIRED:   return _("expired");
548     case TRUST_UNDEFINED: return _("undefined");
549     case TRUST_NEVER:     return _("never");
550     case TRUST_MARGINAL:  return _("marginal");
551     case TRUST_FULLY:     return _("full");
552     case TRUST_ULTIMATE:  return _("ultimate");
553     default:              return "err";
554     }
555 }
556
557 int
558 string_to_trust_value (const char *str)
559 {
560   if(ascii_strcasecmp(str,"undefined")==0)
561     return TRUST_UNDEFINED;
562   else if(ascii_strcasecmp(str,"never")==0)
563     return TRUST_NEVER;
564   else if(ascii_strcasecmp(str,"marginal")==0)
565     return TRUST_MARGINAL;
566   else if(ascii_strcasecmp(str,"full")==0)
567     return TRUST_FULLY;
568   else if(ascii_strcasecmp(str,"ultimate")==0)
569     return TRUST_ULTIMATE;
570   else
571     return -1;
572 }
573
574 /****************
575  * Recreate the WoT but do not ask for new ownertrusts.  Special
576  * feature: In batch mode and without a forced yes, this is only done
577  * when a check is due.  This can be used to run the check from a crontab
578  */
579 void
580 check_trustdb ()
581 {
582   init_trustdb();
583   if(opt.trust_model==TM_PGP || opt.trust_model==TM_CLASSIC)
584     {
585       if (opt.batch && !opt.answer_yes)
586         {
587           ulong scheduled;
588
589           scheduled = tdbio_read_nextcheck ();
590           if (!scheduled)
591             {
592               log_info (_("no need for a trustdb check\n"));
593               return;
594             }
595
596           if (scheduled > make_timestamp ())
597             {
598               log_info (_("next trustdb check due at %s\n"),
599                         strtimestamp (scheduled));
600               return;
601             }
602         }
603
604       validate_keys (0);
605     }
606   else
607     log_info (_("no need for a trustdb check with `%s' trust model\n"),
608               trust_model_string());
609 }
610
611
612 /*
613  * Recreate the WoT. 
614  */
615 void
616 update_trustdb()
617 {
618   init_trustdb();
619   if(opt.trust_model==TM_PGP || opt.trust_model==TM_CLASSIC)
620     validate_keys (1);
621   else
622     log_info (_("no need for a trustdb update with `%s' trust model\n"),
623               trust_model_string());
624 }
625
626 void
627 revalidation_mark (void)
628 {
629   init_trustdb();
630   /* we simply set the time for the next check to 1 (far back in 1970)
631    * so that a --update-trustdb will be scheduled */
632   if (tdbio_write_nextcheck (1))
633       do_sync ();
634   pending_check_trustdb = 1;
635 }
636
637 int
638 trustdb_pending_check(void)
639 {
640   return pending_check_trustdb;
641 }
642
643 /* If the trustdb is dirty, and we're interactive, update it.
644    Otherwise, check it unless no-auto-check-trustdb is set. */
645 void
646 trustdb_check_or_update(void)
647 {
648   if(trustdb_pending_check())
649     {
650       if(opt.interactive)
651         update_trustdb();
652       else if(!opt.no_auto_check_trustdb)
653         check_trustdb();
654     }
655 }
656
657 void
658 read_trust_options(byte *trust_model,ulong *created,ulong *nextcheck,
659                    byte *marginals,byte *completes,byte *cert_depth)
660 {
661   TRUSTREC opts;
662
663   init_trustdb();
664
665   read_record(0,&opts,RECTYPE_VER);
666
667   if(trust_model)
668     *trust_model=opts.r.ver.trust_model;
669   if(created)
670     *created=opts.r.ver.created;
671   if(nextcheck)
672     *nextcheck=opts.r.ver.nextcheck;
673   if(marginals)
674     *marginals=opts.r.ver.marginals;
675   if(completes)
676     *completes=opts.r.ver.completes;
677   if(cert_depth)
678     *cert_depth=opts.r.ver.cert_depth;
679 }
680
681 /***********************************************
682  ***********  Ownertrust et al. ****************
683  ***********************************************/
684
685 static int 
686 read_trust_record (PKT_public_key *pk, TRUSTREC *rec)
687 {
688   int rc;
689   
690   init_trustdb();
691   rc = tdbio_search_trust_bypk (pk, rec);
692   if (rc == -1)
693     return -1; /* no record yet */
694   if (rc) 
695     {
696       log_error ("trustdb: searching trust record failed: %s\n",
697                  g10_errstr (rc));
698       return rc; 
699     }
700       
701   if (rec->rectype != RECTYPE_TRUST)
702     {
703       log_error ("trustdb: record %lu is not a trust record\n",
704                  rec->recnum);
705       return G10ERR_TRUSTDB; 
706     }      
707   
708   return 0;
709 }
710
711 /****************
712  * Return the assigned ownertrust value for the given public key.
713  * The key should be the primary key.
714  */
715 unsigned int 
716 get_ownertrust ( PKT_public_key *pk)
717 {
718   TRUSTREC rec;
719   int rc;
720   
721   rc = read_trust_record (pk, &rec);
722   if (rc == -1)
723     return TRUST_UNKNOWN; /* no record yet */
724   if (rc) 
725     {
726       tdbio_invalid ();
727       return rc; /* actually never reached */
728     }
729
730   return rec.r.trust.ownertrust;
731 }
732
733 unsigned int 
734 get_min_ownertrust (PKT_public_key *pk)
735 {
736   TRUSTREC rec;
737   int rc;
738   
739   rc = read_trust_record (pk, &rec);
740   if (rc == -1)
741     return TRUST_UNKNOWN; /* no record yet */
742   if (rc) 
743     {
744       tdbio_invalid ();
745       return rc; /* actually never reached */
746     }
747
748   return rec.r.trust.min_ownertrust;
749 }
750
751 /*
752  * Same as get_ownertrust but this takes the minimum ownertrust value
753  * into into account, and will bump up the value as needed.
754  */
755 static int
756 get_ownertrust_with_min (PKT_public_key *pk)
757 {
758   unsigned int otrust,otrust_min;
759
760   otrust = (get_ownertrust (pk) & TRUST_MASK);
761   otrust_min = get_min_ownertrust (pk);
762   if(otrust<otrust_min)
763     {
764       /* If the trust that the user has set is less than the trust
765          that was calculated from a trust signature chain, use the
766          higher of the two.  We do this here and not in
767          get_ownertrust since the underlying ownertrust should not
768          really be set - just the appearance of the ownertrust. */
769
770       otrust=otrust_min;
771     }
772
773   return otrust;
774 }
775
776 /*
777  * Same as get_ownertrust but return a trust letter instead of an
778  * value.  This takes the minimum ownertrust value into account.
779  */
780 int
781 get_ownertrust_info (PKT_public_key *pk)
782 {
783   return trust_letter(get_ownertrust_with_min(pk));
784 }
785
786 /*
787  * Same as get_ownertrust but return a trust string instead of an
788  * value.  This takes the minimum ownertrust value into account.
789  */
790 const char *
791 get_ownertrust_string (PKT_public_key *pk)
792 {
793   return trust_value_to_string(get_ownertrust_with_min(pk));
794 }
795
796 /*
797  * Set the trust value of the given public key to the new value.
798  * The key should be a primary one.
799  */
800 void
801 update_ownertrust (PKT_public_key *pk, unsigned int new_trust )
802 {
803   TRUSTREC rec;
804   int rc;
805   
806   rc = read_trust_record (pk, &rec);
807   if (!rc)
808     {
809       if (DBG_TRUST)
810         log_debug ("update ownertrust from %u to %u\n",
811                    (unsigned int)rec.r.trust.ownertrust, new_trust );
812       if (rec.r.trust.ownertrust != new_trust)
813         {
814           rec.r.trust.ownertrust = new_trust;
815           write_record( &rec );
816           revalidation_mark ();
817           do_sync ();
818         }
819     }
820   else if (rc == -1)
821     { /* no record yet - create a new one */
822       size_t dummy;
823
824       if (DBG_TRUST)
825         log_debug ("insert ownertrust %u\n", new_trust );
826
827       memset (&rec, 0, sizeof rec);
828       rec.recnum = tdbio_new_recnum ();
829       rec.rectype = RECTYPE_TRUST;
830       fingerprint_from_pk (pk, rec.r.trust.fingerprint, &dummy);
831       rec.r.trust.ownertrust = new_trust;
832       write_record (&rec);
833       revalidation_mark ();
834       do_sync ();
835       rc = 0;
836     }
837   else 
838     {
839       tdbio_invalid ();
840     }
841 }
842
843 static void
844 update_min_ownertrust (u32 *kid, unsigned int new_trust )
845 {
846   PKT_public_key *pk;
847   TRUSTREC rec;
848   int rc;
849
850   pk = xmalloc_clear (sizeof *pk);
851   rc = get_pubkey (pk, kid);
852   if (rc)
853     {
854       log_error(_("public key %s not found: %s\n"),keystr(kid),g10_errstr(rc));
855       return;
856     }
857
858   rc = read_trust_record (pk, &rec);
859   if (!rc)
860     {
861       if (DBG_TRUST)
862         log_debug ("key %08lX%08lX: update min_ownertrust from %u to %u\n",
863                    (ulong)kid[0],(ulong)kid[1],
864                    (unsigned int)rec.r.trust.min_ownertrust,
865                    new_trust );
866       if (rec.r.trust.min_ownertrust != new_trust)
867         {
868           rec.r.trust.min_ownertrust = new_trust;
869           write_record( &rec );
870           revalidation_mark ();
871           do_sync ();
872         }
873     }
874   else if (rc == -1)
875     { /* no record yet - create a new one */
876       size_t dummy;
877
878       if (DBG_TRUST)
879         log_debug ("insert min_ownertrust %u\n", new_trust );
880
881       memset (&rec, 0, sizeof rec);
882       rec.recnum = tdbio_new_recnum ();
883       rec.rectype = RECTYPE_TRUST;
884       fingerprint_from_pk (pk, rec.r.trust.fingerprint, &dummy);
885       rec.r.trust.min_ownertrust = new_trust;
886       write_record (&rec);
887       revalidation_mark ();
888       do_sync ();
889       rc = 0;
890     }
891   else 
892     {
893       tdbio_invalid ();
894     }
895 }
896
897 /* Clear the ownertrust and min_ownertrust values.  Return true if a
898    change actually happened. */
899 int
900 clear_ownertrusts (PKT_public_key *pk)
901 {
902   TRUSTREC rec;
903   int rc;
904   
905   rc = read_trust_record (pk, &rec);
906   if (!rc)
907     {
908       if (DBG_TRUST)
909         {
910           log_debug ("clearing ownertrust (old value %u)\n",
911                      (unsigned int)rec.r.trust.ownertrust);
912           log_debug ("clearing min_ownertrust (old value %u)\n",
913                      (unsigned int)rec.r.trust.min_ownertrust);
914         }
915       if (rec.r.trust.ownertrust || rec.r.trust.min_ownertrust)
916         {
917           rec.r.trust.ownertrust = 0;
918           rec.r.trust.min_ownertrust = 0;
919           write_record( &rec );
920           revalidation_mark ();
921           do_sync ();
922           return 1;
923         }
924     }
925   else if (rc != -1)
926     {
927       tdbio_invalid ();
928     }
929   return 0;
930 }
931
932 /* 
933  * Note: Caller has to do a sync 
934  */
935 static void
936 update_validity (PKT_public_key *pk, PKT_user_id *uid,
937                  int depth, int validity)
938 {
939   TRUSTREC trec, vrec;
940   int rc;
941   ulong recno;
942
943   namehash_from_uid(uid);
944
945   rc = read_trust_record (pk, &trec);
946   if (rc && rc != -1)
947     {
948       tdbio_invalid ();
949       return;
950     }
951   if (rc == -1) /* no record yet - create a new one */
952     { 
953       size_t dummy;
954
955       rc = 0;
956       memset (&trec, 0, sizeof trec);
957       trec.recnum = tdbio_new_recnum ();
958       trec.rectype = RECTYPE_TRUST;
959       fingerprint_from_pk (pk, trec.r.trust.fingerprint, &dummy);
960       trec.r.trust.ownertrust = 0;
961       }
962
963   /* locate an existing one */
964   recno = trec.r.trust.validlist;
965   while (recno)
966     {
967       read_record (recno, &vrec, RECTYPE_VALID);
968       if ( !memcmp (vrec.r.valid.namehash, uid->namehash, 20) )
969         break;
970       recno = vrec.r.valid.next;
971     }
972
973   if (!recno) /* insert a new validity record */
974     {
975       memset (&vrec, 0, sizeof vrec);
976       vrec.recnum = tdbio_new_recnum ();
977       vrec.rectype = RECTYPE_VALID;
978       memcpy (vrec.r.valid.namehash, uid->namehash, 20);
979       vrec.r.valid.next = trec.r.trust.validlist;
980       trec.r.trust.validlist = vrec.recnum;
981     }
982   vrec.r.valid.validity = validity;
983   vrec.r.valid.full_count = uid->help_full_count;
984   vrec.r.valid.marginal_count = uid->help_marginal_count;
985   write_record (&vrec);
986   trec.r.trust.depth = depth;
987   write_record (&trec);
988 }
989
990
991 /***********************************************
992  *********  Query trustdb values  **************
993  ***********************************************/
994
995 /* Return true if key is disabled */
996 int
997 cache_disabled_value(PKT_public_key *pk)
998 {
999   int rc;
1000   TRUSTREC trec;
1001   int disabled=0;
1002
1003   if(pk->is_disabled)
1004     return (pk->is_disabled==2);
1005
1006   init_trustdb();
1007
1008   rc = read_trust_record (pk, &trec);
1009   if (rc && rc != -1)
1010     {
1011       tdbio_invalid ();
1012       goto leave;
1013     }
1014   if (rc == -1) /* no record found, so assume not disabled */
1015     goto leave;
1016  
1017   if(trec.r.trust.ownertrust & TRUST_FLAG_DISABLED)
1018     disabled=1;
1019  
1020   /* Cache it for later so we don't need to look at the trustdb every
1021      time */
1022   if(disabled)
1023     pk->is_disabled=2;
1024   else
1025     pk->is_disabled=1;
1026
1027  leave:
1028    return disabled;
1029 }
1030
1031 void
1032 check_trustdb_stale(void)
1033 {
1034   static int did_nextcheck=0;
1035
1036   init_trustdb ();
1037   if (!did_nextcheck
1038       && (opt.trust_model==TM_PGP || opt.trust_model==TM_CLASSIC))
1039     {
1040       ulong scheduled;
1041
1042       did_nextcheck = 1;
1043       scheduled = tdbio_read_nextcheck ();
1044       if (scheduled && scheduled <= make_timestamp ())
1045         {
1046           if (opt.no_auto_check_trustdb) 
1047             {
1048               pending_check_trustdb = 1;
1049               log_info (_("please do a --check-trustdb\n"));
1050             }
1051           else
1052             {
1053               log_info (_("checking the trustdb\n"));
1054               validate_keys (0);
1055             }
1056         }
1057     }
1058 }
1059
1060 /*
1061  * Return the validity information for PK.  If the namehash is not
1062  * NULL, the validity of the corresponsing user ID is returned,
1063  * otherwise, a reasonable value for the entire key is returned. 
1064  */
1065 unsigned int
1066 get_validity (PKT_public_key *pk, PKT_user_id *uid)
1067 {
1068   TRUSTREC trec, vrec;
1069   int rc;
1070   ulong recno;
1071   unsigned int validity;
1072   u32 kid[2];
1073   PKT_public_key *main_pk;
1074
1075   if(uid)
1076     namehash_from_uid(uid);
1077
1078   init_trustdb ();
1079   check_trustdb_stale();
1080
1081   keyid_from_pk (pk, kid);
1082   if (pk->main_keyid[0] != kid[0] || pk->main_keyid[1] != kid[1])
1083     { /* this is a subkey - get the mainkey */
1084       main_pk = xmalloc_clear (sizeof *main_pk);
1085       rc = get_pubkey (main_pk, pk->main_keyid);
1086       if (rc)
1087         {
1088           char *tempkeystr=xstrdup(keystr(pk->main_keyid));
1089           log_error ("error getting main key %s of subkey %s: %s\n",
1090                      tempkeystr, keystr(kid), g10_errstr(rc));
1091           xfree(tempkeystr);
1092           validity = TRUST_UNKNOWN; 
1093           goto leave;
1094         }
1095     }
1096   else
1097     main_pk = pk;
1098
1099   if(opt.trust_model==TM_DIRECT)
1100     {
1101       /* Note that this happens BEFORE any user ID stuff is checked.
1102          The direct trust model applies to keys as a whole. */
1103       validity=get_ownertrust(main_pk);
1104       goto leave;
1105     }
1106
1107   rc = read_trust_record (main_pk, &trec);
1108   if (rc && rc != -1)
1109     {
1110       tdbio_invalid ();
1111       return 0;
1112     }
1113   if (rc == -1) /* no record found */
1114     {
1115       validity = TRUST_UNKNOWN; 
1116       goto leave;
1117     }
1118
1119   /* loop over all user IDs */
1120   recno = trec.r.trust.validlist;
1121   validity = 0;
1122   while (recno)
1123     {
1124       read_record (recno, &vrec, RECTYPE_VALID);
1125
1126       if(uid)
1127         {
1128           /* If a user ID is given we return the validity for that
1129              user ID ONLY.  If the namehash is not found, then there
1130              is no validity at all (i.e. the user ID wasn't
1131              signed). */
1132           if(memcmp(vrec.r.valid.namehash,uid->namehash,20)==0)
1133             {
1134               validity=(vrec.r.valid.validity & TRUST_MASK);
1135               break;
1136             }
1137         }
1138       else
1139         {
1140           /* If no namehash is given, we take the maximum validity
1141              over all user IDs */
1142           if ( validity < (vrec.r.valid.validity & TRUST_MASK) )
1143             validity = (vrec.r.valid.validity & TRUST_MASK);
1144         }
1145
1146       recno = vrec.r.valid.next;
1147     }
1148   
1149   if ( (trec.r.trust.ownertrust & TRUST_FLAG_DISABLED) )
1150     {
1151       validity |= TRUST_FLAG_DISABLED;
1152       pk->is_disabled=2;
1153     }
1154   else
1155     pk->is_disabled=1;
1156
1157  leave:
1158   /* set some flags direct from the key */
1159   if (main_pk->is_revoked)
1160     validity |= TRUST_FLAG_REVOKED;
1161   if (main_pk != pk && pk->is_revoked)
1162     validity |= TRUST_FLAG_SUB_REVOKED;
1163   /* Note: expiration is a trust value and not a flag - don't know why
1164    * I initially designed it that way */
1165   if (main_pk->has_expired || pk->has_expired)
1166     validity = (validity & ~TRUST_MASK) | TRUST_EXPIRED;
1167   
1168   if (pending_check_trustdb)
1169     validity |= TRUST_FLAG_PENDING_CHECK;
1170
1171   if (main_pk != pk)
1172     free_public_key (main_pk);
1173   return validity;
1174 }
1175
1176 int
1177 get_validity_info (PKT_public_key *pk, PKT_user_id *uid)
1178 {
1179     int trustlevel;
1180
1181     trustlevel = get_validity (pk, uid);
1182     if( trustlevel & TRUST_FLAG_REVOKED )
1183         return 'r';
1184     return trust_letter ( trustlevel );
1185 }
1186
1187 const char *
1188 get_validity_string (PKT_public_key *pk, PKT_user_id *uid)
1189 {
1190   int trustlevel;
1191
1192   trustlevel = get_validity (pk, uid);
1193   if( trustlevel & TRUST_FLAG_REVOKED )
1194     return _("revoked");
1195   return trust_value_to_string(trustlevel);
1196 }
1197
1198 static void
1199 get_validity_counts (PKT_public_key *pk, PKT_user_id *uid)
1200 {
1201   TRUSTREC trec, vrec;
1202   ulong recno;
1203
1204   if(pk==NULL || uid==NULL)
1205     BUG();
1206
1207   namehash_from_uid(uid);
1208
1209   uid->help_marginal_count=uid->help_full_count=0;
1210
1211   init_trustdb ();
1212
1213   if(read_trust_record (pk, &trec)!=0)
1214     return;
1215
1216   /* loop over all user IDs */
1217   recno = trec.r.trust.validlist;
1218   while (recno)
1219     {
1220       read_record (recno, &vrec, RECTYPE_VALID);
1221
1222       if(memcmp(vrec.r.valid.namehash,uid->namehash,20)==0)
1223         {
1224           uid->help_marginal_count=vrec.r.valid.marginal_count;
1225           uid->help_full_count=vrec.r.valid.full_count;
1226           /*  printf("Fetched marginal %d, full %d\n",uid->help_marginal_count,uid->help_full_count); */
1227           break;
1228         }
1229
1230       recno = vrec.r.valid.next;
1231     }
1232 }
1233
1234 void
1235 list_trust_path( const char *username )
1236 {
1237   (void)username;
1238 }
1239
1240 /****************
1241  * Enumerate all keys, which are needed to build all trust paths for
1242  * the given key.  This function does not return the key itself or
1243  * the ultimate key (the last point in cerificate chain).  Only
1244  * certificate chains which ends up at an ultimately trusted key
1245  * are listed.  If ownertrust or validity is not NULL, the corresponding
1246  * value for the returned LID is also returned in these variable(s).
1247  *
1248  *  1) create a void pointer and initialize it to NULL
1249  *  2) pass this void pointer by reference to this function.
1250  *     Set lid to the key you want to enumerate and pass it by reference.
1251  *  3) call this function as long as it does not return -1
1252  *     to indicate EOF. LID does contain the next key used to build the web
1253  *  4) Always call this function a last time with LID set to NULL,
1254  *     so that it can free its context.
1255  *
1256  * Returns: -1 on EOF or the level of the returned LID
1257  */
1258 int
1259 enum_cert_paths( void **context, ulong *lid,
1260                  unsigned *ownertrust, unsigned *validity )
1261 {
1262   (void)context;
1263   (void)lid;
1264   (void)ownertrust;
1265   (void)validity;
1266   return -1;
1267 }
1268
1269
1270 /****************
1271  * Print the current path
1272  */
1273 void
1274 enum_cert_paths_print (void **context, FILE *fp,
1275                        int refresh, ulong selected_lid)
1276 {
1277   (void)context;
1278   (void)fp;
1279   (void)refresh;
1280   (void)selected_lid;
1281 }
1282
1283
1284 \f
1285 /****************************************
1286  *********** NEW NEW NEW ****************
1287  ****************************************/
1288
1289 static int
1290 ask_ownertrust (u32 *kid,int minimum)
1291 {
1292   PKT_public_key *pk;
1293   int rc;
1294   int ot;
1295
1296   pk = xmalloc_clear (sizeof *pk);
1297   rc = get_pubkey (pk, kid);
1298   if (rc)
1299     {
1300       log_error (_("public key %s not found: %s\n"),
1301                  keystr(kid), g10_errstr(rc) );
1302       return TRUST_UNKNOWN;
1303     }
1304  
1305   if(opt.force_ownertrust)
1306     {
1307       log_info("force trust for key %s to %s\n",
1308                keystr(kid),trust_value_to_string(opt.force_ownertrust));
1309       update_ownertrust(pk,opt.force_ownertrust);
1310       ot=opt.force_ownertrust;
1311     }
1312   else
1313     {
1314       ot=edit_ownertrust(pk,0);
1315       if(ot>0)
1316         ot = get_ownertrust (pk);
1317       else if(ot==0)
1318         ot = minimum?minimum:TRUST_UNDEFINED;
1319       else
1320         ot = -1; /* quit */
1321     }
1322
1323   free_public_key( pk );
1324
1325   return ot;
1326 }
1327
1328
1329 static void
1330 mark_keyblock_seen (KeyHashTable tbl, KBNODE node)
1331 {
1332   for ( ;node; node = node->next )
1333     if (node->pkt->pkttype == PKT_PUBLIC_KEY
1334         || node->pkt->pkttype == PKT_PUBLIC_SUBKEY)
1335       {
1336         u32 aki[2];
1337
1338         keyid_from_pk (node->pkt->pkt.public_key, aki);
1339         add_key_hash_table (tbl, aki);
1340       }
1341 }
1342
1343
1344 static void
1345 dump_key_array (int depth, struct key_array *keys)
1346 {
1347   struct key_array *kar;
1348
1349   for (kar=keys; kar->keyblock; kar++)
1350     {
1351       KBNODE node = kar->keyblock;
1352       u32 kid[2];
1353
1354       keyid_from_pk(node->pkt->pkt.public_key, kid);
1355       printf ("%d:%08lX%08lX:K::%c::::\n",
1356               depth, (ulong)kid[0], (ulong)kid[1], '?');
1357
1358       for (; node; node = node->next)
1359         {
1360           if (node->pkt->pkttype == PKT_USER_ID)
1361             {
1362               int len = node->pkt->pkt.user_id->len;
1363
1364               if (len > 30)
1365                 len = 30;
1366               printf ("%d:%08lX%08lX:U:::%c:::",
1367                       depth, (ulong)kid[0], (ulong)kid[1],
1368                       (node->flag & 4)? 'f':
1369                       (node->flag & 2)? 'm':
1370                       (node->flag & 1)? 'q':'-');
1371               print_string (stdout,  node->pkt->pkt.user_id->name, len, ':');
1372               putchar (':');
1373               putchar ('\n');
1374             }
1375         }
1376     }
1377 }  
1378
1379
1380 static void
1381 store_validation_status (int depth, KBNODE keyblock, KeyHashTable stored)
1382 {
1383   KBNODE node;
1384   int status;
1385   int any = 0;
1386
1387   for (node=keyblock; node; node = node->next)
1388     {
1389       if (node->pkt->pkttype == PKT_USER_ID)
1390         {
1391           PKT_user_id *uid = node->pkt->pkt.user_id;
1392           if (node->flag & 4)
1393             status = TRUST_FULLY;
1394           else if (node->flag & 2)
1395             status = TRUST_MARGINAL;
1396           else if (node->flag & 1)
1397             status = TRUST_UNDEFINED;
1398           else
1399             status = 0;
1400           
1401           if (status)
1402             {
1403               update_validity (keyblock->pkt->pkt.public_key,
1404                                uid, depth, status);
1405
1406               mark_keyblock_seen(stored,keyblock);
1407
1408               any = 1;
1409             }
1410         }
1411     }
1412
1413   if (any)
1414     do_sync ();
1415 }  
1416
1417 /*
1418  * check whether the signature sig is in the klist k
1419  */
1420 static struct key_item *
1421 is_in_klist (struct key_item *k, PKT_signature *sig)
1422 {
1423   for (; k; k = k->next)
1424     {
1425       if (k->kid[0] == sig->keyid[0] && k->kid[1] == sig->keyid[1])
1426         return k;
1427     }
1428   return NULL;
1429 }
1430
1431 /*
1432  * Mark the signature of the given UID which are used to certify it.
1433  * To do this, we first revmove all signatures which are not valid and
1434  * from the remain ones we look for the latest one.  If this is not a
1435  * certification revocation signature we mark the signature by setting
1436  * node flag bit 8.  Revocations are marked with flag 11, and sigs
1437  * from unavailable keys are marked with flag 12.  Note that flag bits
1438  * 9 and 10 are used for internal purposes.
1439  */
1440 static void
1441 mark_usable_uid_certs (KBNODE keyblock, KBNODE uidnode,
1442                        u32 *main_kid, struct key_item *klist,
1443                        u32 curtime, u32 *next_expire)
1444 {
1445   KBNODE node;
1446   PKT_signature *sig;
1447   
1448   /* first check all signatures */
1449   for (node=uidnode->next; node; node = node->next)
1450     {
1451       int rc;
1452
1453       node->flag &= ~(1<<8 | 1<<9 | 1<<10 | 1<<11 | 1<<12);
1454       if (node->pkt->pkttype == PKT_USER_ID
1455           || node->pkt->pkttype == PKT_PUBLIC_SUBKEY)
1456         break; /* ready */
1457       if (node->pkt->pkttype != PKT_SIGNATURE)
1458         continue;
1459       sig = node->pkt->pkt.signature;
1460       if (main_kid
1461           && sig->keyid[0] == main_kid[0] && sig->keyid[1] == main_kid[1])
1462         continue; /* ignore self-signatures if we pass in a main_kid */
1463       if (!IS_UID_SIG(sig) && !IS_UID_REV(sig))
1464         continue; /* we only look at these signature classes */
1465       if(sig->sig_class>=0x11 && sig->sig_class<=0x13 &&
1466          sig->sig_class-0x10<opt.min_cert_level)
1467         continue; /* treat anything under our min_cert_level as an
1468                      invalid signature */
1469       if (klist && !is_in_klist (klist, sig))
1470         continue;  /* no need to check it then */
1471       if ((rc=check_key_signature (keyblock, node, NULL)))
1472         {
1473           /* we ignore anything that won't verify, but tag the
1474              no_pubkey case */
1475           if(rc==G10ERR_NO_PUBKEY)
1476             node->flag |= 1<<12;
1477           continue;
1478         }
1479       node->flag |= 1<<9;
1480     }      
1481   /* reset the remaining flags */
1482   for (; node; node = node->next)
1483       node->flag &= ~(1<<8 | 1<<9 | 1<<10 | 1<<11 | 1<<12);
1484
1485   /* kbnode flag usage: bit 9 is here set for signatures to consider,
1486    * bit 10 will be set by the loop to keep track of keyIDs already
1487    * processed, bit 8 will be set for the usable signatures, and bit
1488    * 11 will be set for usable revocations. */
1489
1490   /* for each cert figure out the latest valid one */
1491   for (node=uidnode->next; node; node = node->next)
1492     {
1493       KBNODE n, signode;
1494       u32 kid[2];
1495       u32 sigdate;
1496
1497       if (node->pkt->pkttype == PKT_PUBLIC_SUBKEY)
1498         break;
1499       if ( !(node->flag & (1<<9)) )
1500         continue; /* not a node to look at */
1501       if ( (node->flag & (1<<10)) )
1502         continue; /* signature with a keyID already processed */
1503       node->flag |= (1<<10); /* mark this node as processed */
1504       sig = node->pkt->pkt.signature;
1505       signode = node;
1506       sigdate = sig->timestamp;
1507       kid[0] = sig->keyid[0]; kid[1] = sig->keyid[1];
1508
1509       /* Now find the latest and greatest signature */
1510       for (n=uidnode->next; n; n = n->next)
1511         {
1512           if (n->pkt->pkttype == PKT_PUBLIC_SUBKEY)
1513             break;
1514           if ( !(n->flag & (1<<9)) )
1515             continue;
1516           if ( (n->flag & (1<<10)) )
1517             continue; /* shortcut already processed signatures */
1518           sig = n->pkt->pkt.signature;
1519           if (kid[0] != sig->keyid[0] || kid[1] != sig->keyid[1])
1520             continue;
1521           n->flag |= (1<<10); /* mark this node as processed */
1522
1523           /* If signode is nonrevocable and unexpired and n isn't,
1524              then take signode (skip).  It doesn't matter which is
1525              older: if signode was older then we don't want to take n
1526              as signode is nonrevocable.  If n was older then we're
1527              automatically fine. */
1528           
1529           if(((IS_UID_SIG(signode->pkt->pkt.signature) &&
1530                !signode->pkt->pkt.signature->flags.revocable &&
1531                (signode->pkt->pkt.signature->expiredate==0 ||
1532                 signode->pkt->pkt.signature->expiredate>curtime))) &&
1533              (!(IS_UID_SIG(n->pkt->pkt.signature) &&
1534                 !n->pkt->pkt.signature->flags.revocable &&
1535                 (n->pkt->pkt.signature->expiredate==0 ||
1536                  n->pkt->pkt.signature->expiredate>curtime))))
1537             continue;
1538
1539           /* If n is nonrevocable and unexpired and signode isn't,
1540              then take n.  Again, it doesn't matter which is older: if
1541              n was older then we don't want to take signode as n is
1542              nonrevocable.  If signode was older then we're
1543              automatically fine. */
1544           
1545           if((!(IS_UID_SIG(signode->pkt->pkt.signature) &&
1546                 !signode->pkt->pkt.signature->flags.revocable &&
1547                 (signode->pkt->pkt.signature->expiredate==0 ||
1548                  signode->pkt->pkt.signature->expiredate>curtime))) &&
1549              ((IS_UID_SIG(n->pkt->pkt.signature) &&
1550                !n->pkt->pkt.signature->flags.revocable &&
1551                (n->pkt->pkt.signature->expiredate==0 ||
1552                 n->pkt->pkt.signature->expiredate>curtime))))
1553             {
1554               signode = n;
1555               sigdate = sig->timestamp;
1556               continue;
1557             }
1558
1559           /* At this point, if it's newer, it goes in as the only
1560              remaining possibilities are signode and n are both either
1561              revocable or expired or both nonrevocable and unexpired.
1562              If the timestamps are equal take the later ordered
1563              packet, presuming that the key packets are hopefully in
1564              their original order. */
1565
1566           if (sig->timestamp >= sigdate)
1567             {
1568               signode = n;
1569               sigdate = sig->timestamp;
1570             }
1571         }
1572
1573       sig = signode->pkt->pkt.signature;
1574       if (IS_UID_SIG (sig))
1575         { /* this seems to be a usable one which is not revoked. 
1576            * Just need to check whether there is an expiration time,
1577            * We do the expired certification after finding a suitable
1578            * certification, the assumption is that a signator does not
1579            * want that after the expiration of his certificate the
1580            * system falls back to an older certification which has a
1581            * different expiration time */
1582           const byte *p;
1583           u32 expire;
1584                     
1585           p = parse_sig_subpkt (sig->hashed, SIGSUBPKT_SIG_EXPIRE, NULL );
1586           expire = p? sig->timestamp + buffer_to_u32(p) : 0;
1587
1588           if (expire==0 || expire > curtime )
1589             {
1590               signode->flag |= (1<<8); /* yeah, found a good cert */
1591               if (next_expire && expire && expire < *next_expire)
1592                 *next_expire = expire;
1593             }
1594         }
1595       else
1596         signode->flag |= (1<<11);
1597     }
1598 }
1599
1600 static int
1601 clean_sigs_from_uid(KBNODE keyblock,KBNODE uidnode,int noisy,int self_only)
1602 {
1603   int deleted=0;
1604   KBNODE node;
1605   u32 keyid[2];
1606
1607   assert(keyblock->pkt->pkttype==PKT_PUBLIC_KEY);
1608
1609   keyid_from_pk(keyblock->pkt->pkt.public_key,keyid);
1610
1611   /* Passing in a 0 for current time here means that we'll never weed
1612      out an expired sig.  This is correct behavior since we want to
1613      keep the most recent expired sig in a series. */
1614   mark_usable_uid_certs(keyblock,uidnode,NULL,NULL,0,NULL);
1615
1616   /* What we want to do here is remove signatures that are not
1617      considered as part of the trust calculations.  Thus, all invalid
1618      signatures are out, as are any signatures that aren't the last of
1619      a series of uid sigs or revocations It breaks down like this:
1620      coming out of mark_usable_uid_certs, if a sig is unflagged, it is
1621      not even a candidate.  If a sig has flag 9 or 10, that means it
1622      was selected as a candidate and vetted.  If a sig has flag 8 it
1623      is a usable signature.  If a sig has flag 11 it is a usable
1624      revocation.  If a sig has flag 12 it was issued by an unavailable
1625      key.  "Usable" here means the most recent valid
1626      signature/revocation in a series from a particular signer.
1627
1628      Delete everything that isn't a usable uid sig (which might be
1629      expired), a usable revocation, or a sig from an unavailable
1630      key. */
1631
1632   for(node=uidnode->next;
1633       node && node->pkt->pkttype==PKT_SIGNATURE;
1634       node=node->next)
1635     {
1636       int keep=self_only?(node->pkt->pkt.signature->keyid[0]==keyid[0]
1637                           && node->pkt->pkt.signature->keyid[1]==keyid[1]):1;
1638
1639       /* Keep usable uid sigs ... */
1640       if((node->flag & (1<<8)) && keep)
1641         continue;
1642
1643       /* ... and usable revocations... */
1644       if((node->flag & (1<<11)) && keep)
1645         continue;
1646
1647       /* ... and sigs from unavailable keys. */
1648       /* disabled for now since more people seem to want sigs from
1649          unavailable keys removed altogether.  */
1650       /*
1651         if(node->flag & (1<<12))
1652         continue;
1653       */
1654
1655       /* Everything else we delete */
1656
1657       /* At this point, if 12 is set, the signing key was unavailable.
1658          If 9 or 10 is set, it's superceded.  Otherwise, it's
1659          invalid. */
1660
1661       if(noisy)
1662         log_info("removing signature from key %s on user ID \"%s\": %s\n",
1663                  keystr(node->pkt->pkt.signature->keyid),
1664                  uidnode->pkt->pkt.user_id->name,
1665                  node->flag&(1<<12)?"key unavailable":
1666                  node->flag&(1<<9)?"signature superceded":"invalid signature");
1667
1668       delete_kbnode(node);
1669       deleted++;
1670     }
1671     
1672   return deleted;
1673 }
1674
1675 /* This is substantially easier than clean_sigs_from_uid since we just
1676    have to establish if the uid has a valid self-sig, is not revoked,
1677    and is not expired.  Note that this does not take into account
1678    whether the uid has a trust path to it - just whether the keyholder
1679    themselves has certified the uid.  Returns true if the uid was
1680    compacted.  To "compact" a user ID, we simply remove ALL signatures
1681    except the self-sig that caused the user ID to be remove-worthy.
1682    We don't actually remove the user ID packet itself since it might
1683    be ressurected in a later merge.  Note that this function requires
1684    that the caller has already done a merge_keys_and_selfsig().
1685
1686    TODO: change the import code to allow importing a uid with only a
1687    revocation if the uid already exists on the keyring. */
1688
1689 static int
1690 clean_uid_from_key(KBNODE keyblock,KBNODE uidnode,int noisy)
1691 {
1692   KBNODE node;
1693   PKT_user_id *uid=uidnode->pkt->pkt.user_id;
1694   int deleted=0;
1695
1696   assert(keyblock->pkt->pkttype==PKT_PUBLIC_KEY);
1697   assert(uidnode->pkt->pkttype==PKT_USER_ID);
1698
1699   /* Skip valid user IDs, compacted user IDs, and non-self-signed user
1700      IDs if --allow-non-selfsigned-uid is set. */
1701   if(uid->created || uid->flags.compacted
1702      || (!uid->is_expired && !uid->is_revoked
1703          && opt.allow_non_selfsigned_uid))
1704     return 0;
1705
1706   for(node=uidnode->next;
1707       node && node->pkt->pkttype==PKT_SIGNATURE;
1708       node=node->next)
1709     if(!node->pkt->pkt.signature->flags.chosen_selfsig)
1710       {
1711         delete_kbnode(node);
1712         deleted=1;
1713         uidnode->pkt->pkt.user_id->flags.compacted=1;
1714       }
1715
1716   if(noisy)
1717     {
1718       const char *reason;
1719       char *user=utf8_to_native(uid->name,uid->len,0);
1720
1721       if(uid->is_revoked)
1722         reason=_("revoked");
1723       else if(uid->is_expired)
1724         reason=_("expired");
1725       else
1726         reason=_("invalid");
1727
1728       log_info("compacting user ID \"%s\" on key %s: %s\n",
1729                user,keystr_from_pk(keyblock->pkt->pkt.public_key),
1730                reason);
1731
1732       xfree(user);
1733     }
1734
1735   return deleted;
1736 }
1737
1738 /* Needs to be called after a merge_keys_and_selfsig() */
1739 void
1740 clean_one_uid(KBNODE keyblock,KBNODE uidnode,int noisy,int self_only,
1741               int *uids_cleaned,int *sigs_cleaned)
1742 {
1743   int dummy;
1744
1745   assert(keyblock->pkt->pkttype==PKT_PUBLIC_KEY);
1746   assert(uidnode->pkt->pkttype==PKT_USER_ID);
1747
1748   if(!uids_cleaned)
1749     uids_cleaned=&dummy;
1750
1751   if(!sigs_cleaned)
1752     sigs_cleaned=&dummy;
1753
1754   /* Do clean_uid_from_key first since if it fires off, we don't
1755      have to bother with the other */
1756   *uids_cleaned+=clean_uid_from_key(keyblock,uidnode,noisy);
1757   if(!uidnode->pkt->pkt.user_id->flags.compacted)
1758     *sigs_cleaned+=clean_sigs_from_uid(keyblock,uidnode,noisy,self_only);
1759 }
1760
1761 void
1762 clean_key(KBNODE keyblock,int noisy,int self_only,
1763           int *uids_cleaned,int *sigs_cleaned)
1764 {
1765   KBNODE uidnode;
1766
1767   merge_keys_and_selfsig(keyblock);
1768
1769   for(uidnode=keyblock->next;
1770       uidnode && uidnode->pkt->pkttype!=PKT_PUBLIC_SUBKEY;
1771       uidnode=uidnode->next)
1772     if(uidnode->pkt->pkttype==PKT_USER_ID)
1773       clean_one_uid(keyblock,uidnode,noisy,self_only,
1774                     uids_cleaned,sigs_cleaned);
1775 }
1776
1777 /* Returns a sanitized copy of the regexp (which might be "", but not
1778    NULL). */
1779 #ifndef DISABLE_REGEX
1780 static char *
1781 sanitize_regexp(const char *old)
1782 {
1783   size_t start=0,len=strlen(old),idx=0;
1784   int escaped=0,standard_bracket=0;
1785   char *new=xmalloc((len*2)+1); /* enough to \-escape everything if we
1786                                    have to */
1787
1788   /* There are basically two commonly-used regexps here.  GPG and most
1789      versions of PGP use "<[^>]+[@.]example\.com>$" and PGP (9)
1790      command line uses "example.com" (i.e. whatever the user specfies,
1791      and we can't expect users know to use "\." instead of ".").  So
1792      here are the rules: we're allowed to start with "<[^>]+[@.]" and
1793      end with ">$" or start and end with nothing.  In between, the
1794      only legal regex character is ".", and everything else gets
1795      escaped.  Part of the gotcha here is that some regex packages
1796      allow more than RFC-4880 requires.  For example, 4880 has no "{}"
1797      operator, but GNU regex does.  Commenting removes these operators
1798      from consideration.  A possible future enhancement is to use
1799      commenting to effectively back off a given regex to the Henry
1800      Spencer syntax in 4880. -dshaw */
1801
1802   /* Are we bracketed between "<[^>]+[@.]" and ">$" ? */
1803   if(len>=12 && strncmp(old,"<[^>]+[@.]",10)==0
1804      && old[len-2]=='>' && old[len-1]=='$')
1805     {
1806       strcpy(new,"<[^>]+[@.]");
1807       idx=strlen(new);
1808       standard_bracket=1;
1809       start+=10;
1810       len-=2;
1811     }
1812
1813   /* Walk the remaining characters and ensure that everything that is
1814      left is not an operational regex character. */
1815   for(;start<len;start++)
1816     {
1817       if(!escaped && old[start]=='\\')
1818         escaped=1;
1819       else if(!escaped && old[start]!='.')
1820         new[idx++]='\\';
1821       else
1822         escaped=0;
1823
1824       new[idx++]=old[start];
1825     }
1826
1827   new[idx]='\0';
1828
1829   /* Note that the (sub)string we look at might end with a bare "\".
1830      If it does, leave it that way.  If the regexp actually ended with
1831      ">$", then it was escaping the ">" and is fine.  If the regexp
1832      actually ended with the bare "\", then it's an illegal regexp and
1833      regcomp should kick it out. */
1834
1835   if(standard_bracket)
1836     strcat(new,">$");
1837
1838   return new;
1839 }
1840 #endif /*!DISABLE_REGEX*/
1841
1842 /* Used by validate_one_keyblock to confirm a regexp within a trust
1843    signature.  Returns 1 for match, and 0 for no match or regex
1844    error. */
1845 static int
1846 check_regexp(const char *expr,const char *string)
1847 {
1848 #ifdef DISABLE_REGEX
1849   /* When DISABLE_REGEX is defined, assume all regexps do not
1850      match. */
1851   return 0;
1852 #else
1853   int ret;
1854   char *regexp;
1855
1856   regexp=sanitize_regexp(expr);
1857
1858 #ifdef __riscos__
1859   ret=riscos_check_regexp(expr, string, DBG_TRUST);
1860 #else
1861   {
1862     regex_t pat;
1863
1864     ret=regcomp(&pat,regexp,REG_ICASE|REG_NOSUB|REG_EXTENDED);
1865     if(ret==0)
1866       {
1867         ret=regexec(&pat,string,0,NULL,0);
1868         regfree(&pat);
1869         ret=(ret==0);
1870       }
1871   }
1872 #endif
1873
1874   if(DBG_TRUST)
1875     log_debug("regexp `%s' (`%s') on `%s': %s\n",
1876               regexp,expr,string,ret==0?"YES":"NO");
1877
1878   xfree(regexp);
1879
1880   return ret;
1881 #endif
1882 }
1883
1884 /*
1885  * Return true if the key is signed by one of the keys in the given
1886  * key ID list.  User IDs with a valid signature are marked by node
1887  * flags as follows:
1888  *  flag bit 0: There is at least one signature
1889  *           1: There is marginal confidence that this is a legitimate uid
1890  *           2: There is full confidence that this is a legitimate uid.
1891  *           8: Used for internal purposes.
1892  *           9: Ditto (in mark_usable_uid_certs())
1893  *          10: Ditto (ditto)
1894  * This function assumes that all kbnode flags are cleared on entry.
1895  */
1896 static int
1897 validate_one_keyblock (KBNODE kb, struct key_item *klist,
1898                        u32 curtime, u32 *next_expire)
1899 {
1900   struct key_item *kr;
1901   KBNODE node, uidnode=NULL;
1902   PKT_user_id *uid=NULL;
1903   PKT_public_key *pk = kb->pkt->pkt.public_key;
1904   u32 main_kid[2];
1905   int issigned=0, any_signed = 0;
1906
1907   keyid_from_pk(pk, main_kid);
1908   for (node=kb; node; node = node->next)
1909     {
1910       /* A bit of discussion here: is it better for the web of trust
1911          to be built among only self-signed uids?  On the one hand, a
1912          self-signed uid is a statement that the key owner definitely
1913          intended that uid to be there, but on the other hand, a
1914          signed (but not self-signed) uid does carry trust, of a sort,
1915          even if it is a statement being made by people other than the
1916          key owner "through" the uids on the key owner's key.  I'm
1917          going with the latter.  However, if the user ID was
1918          explicitly revoked, or passively allowed to expire, that
1919          should stop validity through the user ID until it is
1920          resigned.  -dshaw */
1921
1922       if (node->pkt->pkttype == PKT_USER_ID
1923           && !node->pkt->pkt.user_id->is_revoked
1924           && !node->pkt->pkt.user_id->is_expired)
1925         {
1926           if (uidnode && issigned)
1927             {
1928               if (uid->help_full_count >= opt.completes_needed
1929                   || uid->help_marginal_count >= opt.marginals_needed )
1930                 uidnode->flag |= 4; 
1931               else if (uid->help_full_count || uid->help_marginal_count)
1932                 uidnode->flag |= 2;
1933               uidnode->flag |= 1;
1934               any_signed = 1;
1935             }
1936           uidnode = node;
1937           uid=uidnode->pkt->pkt.user_id;
1938
1939           /* If the selfsig is going to expire... */
1940           if(uid->expiredate && uid->expiredate<*next_expire)
1941             *next_expire = uid->expiredate;
1942
1943           issigned = 0;
1944           get_validity_counts(pk,uid);
1945           mark_usable_uid_certs (kb, uidnode, main_kid, klist, 
1946                                  curtime, next_expire);
1947         }
1948       else if (node->pkt->pkttype == PKT_SIGNATURE
1949                && (node->flag & (1<<8)) && uid)
1950         {
1951           /* Note that we are only seeing unrevoked sigs here */
1952           PKT_signature *sig = node->pkt->pkt.signature;
1953           
1954           kr = is_in_klist (klist, sig);
1955           /* If the trust_regexp does not match, it's as if the sig
1956              did not exist.  This is safe for non-trust sigs as well
1957              since we don't accept a regexp on the sig unless it's a
1958              trust sig. */
1959           if (kr && (!kr->trust_regexp 
1960                      || opt.trust_model != TM_PGP 
1961                      || (uidnode 
1962                          && check_regexp(kr->trust_regexp,
1963                                          uidnode->pkt->pkt.user_id->name))))
1964             {
1965               /* Are we part of a trust sig chain?  We always favor
1966                  the latest trust sig, rather than the greater or
1967                  lesser trust sig or value.  I could make a decent
1968                  argument for any of these cases, but this seems to be
1969                  what PGP does, and I'd like to be compatible. -dms */
1970               if (opt.trust_model == TM_PGP
1971                   && sig->trust_depth
1972                   && pk->trust_timestamp <= sig->timestamp)
1973                 {
1974                   unsigned char depth;
1975
1976                   /* If the depth on the signature is less than the
1977                      chain currently has, then use the signature depth
1978                      so we don't increase the depth beyond what the
1979                      signer wanted.  If the depth on the signature is
1980                      more than the chain currently has, then use the
1981                      chain depth so we use as much of the signature
1982                      depth as the chain will permit.  An ultimately
1983                      trusted signature can restart the depth to
1984                      whatever level it likes. */
1985
1986                   if (sig->trust_depth < kr->trust_depth
1987                       || kr->ownertrust == TRUST_ULTIMATE)
1988                     depth = sig->trust_depth;
1989                   else
1990                     depth = kr->trust_depth;
1991
1992                   if (depth)
1993                     {
1994                       if(DBG_TRUST)
1995                         log_debug ("trust sig on %s, sig depth is %d,"
1996                                    " kr depth is %d\n",
1997                                    uidnode->pkt->pkt.user_id->name,
1998                                    sig->trust_depth,
1999                                    kr->trust_depth);
2000
2001                       /* If we got here, we know that:
2002
2003                          this is a trust sig.
2004
2005                          it's a newer trust sig than any previous trust
2006                          sig on this key (not uid).
2007
2008                          it is legal in that it was either generated by an
2009                          ultimate key, or a key that was part of a trust
2010                          chain, and the depth does not violate the
2011                          original trust sig.
2012
2013                          if there is a regexp attached, it matched
2014                          successfully.
2015                       */
2016
2017                       if (DBG_TRUST)
2018                         log_debug ("replacing trust value %d with %d and "
2019                                    "depth %d with %d\n",
2020                                    pk->trust_value,sig->trust_value,
2021                                    pk->trust_depth,depth);
2022
2023                       pk->trust_value = sig->trust_value;
2024                       pk->trust_depth = depth-1;
2025                       
2026                       /* If the trust sig contains a regexp, record it
2027                          on the pk for the next round. */
2028                       if (sig->trust_regexp)
2029                         pk->trust_regexp = sig->trust_regexp;
2030                     }
2031                 }
2032
2033               if (kr->ownertrust == TRUST_ULTIMATE)
2034                 uid->help_full_count = opt.completes_needed;
2035               else if (kr->ownertrust == TRUST_FULLY)
2036                 uid->help_full_count++;
2037               else if (kr->ownertrust == TRUST_MARGINAL)
2038                 uid->help_marginal_count++;
2039               issigned = 1;
2040             }
2041         }
2042     }
2043
2044   if (uidnode && issigned)
2045     {
2046       if (uid->help_full_count >= opt.completes_needed
2047           || uid->help_marginal_count >= opt.marginals_needed )
2048         uidnode->flag |= 4; 
2049       else if (uid->help_full_count || uid->help_marginal_count)
2050         uidnode->flag |= 2;
2051       uidnode->flag |= 1;
2052       any_signed = 1;
2053     }
2054
2055   return any_signed;
2056 }
2057
2058
2059 static int
2060 search_skipfnc (void *opaque, u32 *kid, PKT_user_id *dummy)
2061 {
2062   (void)dummy;
2063   return test_key_hash_table ((KeyHashTable)opaque, kid);
2064 }
2065
2066
2067 /*
2068  * Scan all keys and return a key_array of all suitable keys from
2069  * kllist.  The caller has to pass keydb handle so that we don't use
2070  * to create our own.  Returns either a key_array or NULL in case of
2071  * an error.  No results found are indicated by an empty array.
2072  * Caller hast to release the returned array.  
2073  */
2074 static struct key_array *
2075 validate_key_list (KEYDB_HANDLE hd, KeyHashTable full_trust,
2076                    struct key_item *klist, u32 curtime, u32 *next_expire)
2077 {
2078   KBNODE keyblock = NULL;
2079   struct key_array *keys = NULL;
2080   size_t nkeys, maxkeys;
2081   int rc;
2082   KEYDB_SEARCH_DESC desc;
2083   
2084   maxkeys = 1000;
2085   keys = xmalloc ((maxkeys+1) * sizeof *keys);
2086   nkeys = 0;
2087   
2088   rc = keydb_search_reset (hd);
2089   if (rc)
2090     {
2091       log_error ("keydb_search_reset failed: %s\n", g10_errstr(rc));
2092       xfree (keys);
2093       return NULL;
2094     }
2095
2096   memset (&desc, 0, sizeof desc);
2097   desc.mode = KEYDB_SEARCH_MODE_FIRST;
2098   desc.skipfnc = search_skipfnc;
2099   desc.skipfncvalue = full_trust;
2100   rc = keydb_search (hd, &desc, 1);
2101   if (rc == -1)
2102     {
2103       keys[nkeys].keyblock = NULL;
2104       return keys;
2105     }
2106   if (rc)
2107     {
2108       log_error ("keydb_search_first failed: %s\n", g10_errstr(rc));
2109       xfree (keys);
2110       return NULL;
2111     }
2112   
2113   desc.mode = KEYDB_SEARCH_MODE_NEXT; /* change mode */
2114   do
2115     {
2116       PKT_public_key *pk;
2117         
2118       rc = keydb_get_keyblock (hd, &keyblock);
2119       if (rc) 
2120         {
2121           log_error ("keydb_get_keyblock failed: %s\n", g10_errstr(rc));
2122           xfree (keys);
2123           return NULL;
2124         }
2125       
2126       if ( keyblock->pkt->pkttype != PKT_PUBLIC_KEY) 
2127         {
2128           log_debug ("ooops: invalid pkttype %d encountered\n",
2129                      keyblock->pkt->pkttype);
2130           dump_kbnode (keyblock);
2131           release_kbnode(keyblock);
2132           continue;
2133         }
2134
2135       /* prepare the keyblock for further processing */
2136       merge_keys_and_selfsig (keyblock); 
2137       clear_kbnode_flags (keyblock);
2138       pk = keyblock->pkt->pkt.public_key;
2139       if (pk->has_expired || pk->is_revoked)
2140         {
2141           /* it does not make sense to look further at those keys */
2142           mark_keyblock_seen (full_trust, keyblock);
2143         }
2144       else if (validate_one_keyblock (keyblock, klist, curtime, next_expire))
2145         {
2146           KBNODE node;
2147
2148           if (pk->expiredate && pk->expiredate >= curtime
2149               && pk->expiredate < *next_expire)
2150             *next_expire = pk->expiredate;
2151
2152           if (nkeys == maxkeys) {
2153             maxkeys += 1000;
2154             keys = xrealloc (keys, (maxkeys+1) * sizeof *keys);
2155           }
2156           keys[nkeys++].keyblock = keyblock;
2157
2158           /* Optimization - if all uids are fully trusted, then we
2159              never need to consider this key as a candidate again. */
2160
2161           for (node=keyblock; node; node = node->next)
2162             if (node->pkt->pkttype == PKT_USER_ID && !(node->flag & 4))
2163               break;
2164
2165           if(node==NULL)
2166             mark_keyblock_seen (full_trust, keyblock);
2167
2168           keyblock = NULL;
2169         }
2170
2171       release_kbnode (keyblock);
2172       keyblock = NULL;
2173     } 
2174   while ( !(rc = keydb_search (hd, &desc, 1)) );
2175   if (rc && rc != -1) 
2176     {
2177       log_error ("keydb_search_next failed: %s\n", g10_errstr(rc));
2178       xfree (keys);
2179       return NULL;
2180     }
2181
2182   keys[nkeys].keyblock = NULL;
2183   return keys;
2184
2185
2186 /* Caller must sync */
2187 static void
2188 reset_trust_records(void)
2189 {
2190   TRUSTREC rec;
2191   ulong recnum;
2192   int count = 0, nreset = 0;
2193
2194   for (recnum=1; !tdbio_read_record (recnum, &rec, 0); recnum++ ) 
2195     {
2196       if(rec.rectype==RECTYPE_TRUST)
2197         {
2198           count++;
2199           if(rec.r.trust.min_ownertrust)
2200             {
2201               rec.r.trust.min_ownertrust=0;
2202               write_record(&rec);
2203             }
2204
2205         }
2206       else if(rec.rectype==RECTYPE_VALID
2207               && ((rec.r.valid.validity&TRUST_MASK)
2208                   || rec.r.valid.marginal_count
2209                   || rec.r.valid.full_count))
2210         {
2211           rec.r.valid.validity &= ~TRUST_MASK;
2212           rec.r.valid.marginal_count=rec.r.valid.full_count=0;
2213           nreset++;
2214           write_record(&rec);
2215         }
2216
2217     }
2218
2219   if (opt.verbose)
2220     log_info (_("%d keys processed (%d validity counts cleared)\n"),
2221               count, nreset);
2222 }
2223
2224 /*
2225  * Run the key validation procedure.
2226  *
2227  * This works this way:
2228  * Step 1: Find all ultimately trusted keys (UTK).
2229  *         mark them all as seen and put them into klist.
2230  * Step 2: loop max_cert_times
2231  * Step 3:   if OWNERTRUST of any key in klist is undefined
2232  *             ask user to assign ownertrust
2233  * Step 4:   Loop over all keys in the keyDB which are not marked seen 
2234  * Step 5:     if key is revoked or expired
2235  *                mark key as seen
2236  *                continue loop at Step 4
2237  * Step 6:     For each user ID of that key signed by a key in klist
2238  *                Calculate validity by counting trusted signatures.
2239  *                Set validity of user ID
2240  * Step 7:     If any signed user ID was found
2241  *                mark key as seen
2242  *             End Loop
2243  * Step 8:   Build a new klist from all fully trusted keys from step 6
2244  *           End Loop
2245  *         Ready  
2246  *
2247  */
2248 static int
2249 validate_keys (int interactive)
2250 {
2251   int rc = 0;
2252   int quit=0;
2253   struct key_item *klist = NULL;
2254   struct key_item *k;
2255   struct key_array *keys = NULL;
2256   struct key_array *kar;
2257   KEYDB_HANDLE kdb = NULL;
2258   KBNODE node;
2259   int depth;
2260   int ot_unknown, ot_undefined, ot_never, ot_marginal, ot_full, ot_ultimate;
2261   KeyHashTable stored,used,full_trust;
2262   u32 start_time, next_expire;
2263
2264   /* Make sure we have all sigs cached.  TODO: This is going to
2265      require some architectual re-thinking, as it is agonizingly slow.
2266      Perhaps combine this with reset_trust_records(), or only check
2267      the caches on keys that are actually involved in the web of
2268      trust. */
2269   keydb_rebuild_caches(0);
2270
2271   start_time = make_timestamp ();
2272   next_expire = 0xffffffff; /* set next expire to the year 2106 */
2273   stored = new_key_hash_table ();
2274   used = new_key_hash_table ();
2275   full_trust = new_key_hash_table ();
2276
2277   kdb = keydb_new (0);
2278   reset_trust_records();
2279
2280   /* Fixme: Instead of always building a UTK list, we could just build it
2281    * here when needed */
2282   if (!utk_list)
2283     {
2284       if (!opt.quiet)
2285         log_info (_("no ultimately trusted keys found\n"));
2286       goto leave;
2287     }
2288
2289   /* mark all UTKs as used and fully_trusted and set validity to
2290      ultimate */
2291   for (k=utk_list; k; k = k->next)
2292     {
2293       KBNODE keyblock;
2294       PKT_public_key *pk;
2295
2296       keyblock = get_pubkeyblock (k->kid);
2297       if (!keyblock)
2298         {
2299           log_error (_("public key of ultimately"
2300                        " trusted key %s not found\n"), keystr(k->kid));
2301           continue;
2302         }
2303       mark_keyblock_seen (used, keyblock);
2304       mark_keyblock_seen (stored, keyblock);
2305       mark_keyblock_seen (full_trust, keyblock);
2306       pk = keyblock->pkt->pkt.public_key;
2307       for (node=keyblock; node; node = node->next)
2308         {
2309           if (node->pkt->pkttype == PKT_USER_ID)
2310             update_validity (pk, node->pkt->pkt.user_id, 0, TRUST_ULTIMATE);
2311         }
2312       if ( pk->expiredate && pk->expiredate >= start_time
2313            && pk->expiredate < next_expire)
2314         next_expire = pk->expiredate;
2315       
2316       release_kbnode (keyblock);
2317       do_sync ();
2318     }
2319
2320   klist = utk_list;
2321
2322   log_info(_("%d marginal(s) needed, %d complete(s) needed, %s trust model\n"),
2323            opt.marginals_needed,opt.completes_needed,trust_model_string());
2324
2325   for (depth=0; depth < opt.max_cert_depth; depth++)
2326     {
2327       int valids=0,key_count;
2328       /* See whether we should assign ownertrust values to the keys in
2329          klist.  */
2330       ot_unknown = ot_undefined = ot_never = 0;
2331       ot_marginal = ot_full = ot_ultimate = 0;
2332       for (k=klist; k; k = k->next)
2333         {
2334           int min=0;
2335
2336           /* 120 and 60 are as per RFC2440 */
2337           if(k->trust_value>=120)
2338             min=TRUST_FULLY;
2339           else if(k->trust_value>=60)
2340             min=TRUST_MARGINAL;
2341
2342           if(min!=k->min_ownertrust)
2343             update_min_ownertrust(k->kid,min);
2344
2345           if (interactive && k->ownertrust == TRUST_UNKNOWN)
2346             {
2347               k->ownertrust = ask_ownertrust (k->kid,min);
2348
2349               if (k->ownertrust == -1)
2350                 {
2351                   quit=1;
2352                   goto leave;
2353                 }
2354             }
2355
2356           /* This can happen during transition from an old trustdb
2357              before trust sigs.  It can also happen if a user uses two
2358              different versions of GnuPG or changes the --trust-model
2359              setting. */
2360           if(k->ownertrust<min)
2361             {
2362               if(DBG_TRUST)
2363                 log_debug("key %08lX%08lX:"
2364                           " overriding ownertrust `%s' with `%s'\n",
2365                           (ulong)k->kid[0],(ulong)k->kid[1],
2366                           trust_value_to_string(k->ownertrust),
2367                           trust_value_to_string(min));
2368
2369               k->ownertrust=min;
2370             }
2371
2372           if (k->ownertrust == TRUST_UNKNOWN)
2373             ot_unknown++;
2374           else if (k->ownertrust == TRUST_UNDEFINED)
2375             ot_undefined++;
2376           else if (k->ownertrust == TRUST_NEVER)
2377             ot_never++;
2378           else if (k->ownertrust == TRUST_MARGINAL)
2379             ot_marginal++;
2380           else if (k->ownertrust == TRUST_FULLY)
2381             ot_full++;
2382           else if (k->ownertrust == TRUST_ULTIMATE)
2383             ot_ultimate++;
2384
2385           valids++;
2386         }
2387
2388       /* Find all keys which are signed by a key in kdlist */
2389       keys = validate_key_list (kdb, full_trust, klist,
2390                                 start_time, &next_expire);
2391       if (!keys) 
2392         {
2393           log_error ("validate_key_list failed\n");
2394           rc = G10ERR_GENERAL;
2395           goto leave;
2396         }
2397
2398       for (key_count=0, kar=keys; kar->keyblock; kar++, key_count++)
2399         ;
2400
2401       /* Store the calculated valididation status somewhere */
2402       if (opt.verbose > 1)
2403         dump_key_array (depth, keys);
2404
2405       for (kar=keys; kar->keyblock; kar++)
2406           store_validation_status (depth, kar->keyblock, stored);
2407
2408       log_info (_("depth: %d  valid: %3d  signed: %3d"
2409                   "  trust: %d-, %dq, %dn, %dm, %df, %du\n"), 
2410                 depth, valids, key_count, ot_unknown, ot_undefined,
2411                 ot_never, ot_marginal, ot_full, ot_ultimate ); 
2412
2413       /* Build a new kdlist from all fully valid keys in KEYS */
2414       if (klist != utk_list)
2415         release_key_items (klist);
2416       klist = NULL;
2417       for (kar=keys; kar->keyblock; kar++)
2418         {
2419           for (node=kar->keyblock; node; node = node->next)
2420             {
2421               if (node->pkt->pkttype == PKT_USER_ID && (node->flag & 4))
2422                 {
2423                   u32 kid[2];
2424
2425                   /* have we used this key already? */
2426                   keyid_from_pk (kar->keyblock->pkt->pkt.public_key, kid);
2427                   if(test_key_hash_table(used,kid)==0)
2428                     {
2429                       /* Normally we add both the primary and subkey
2430                          ids to the hash via mark_keyblock_seen, but
2431                          since we aren't using this hash as a skipfnc,
2432                          that doesn't matter here. */
2433                       add_key_hash_table (used,kid);
2434                       k = new_key_item ();
2435                       k->kid[0]=kid[0];
2436                       k->kid[1]=kid[1];
2437                       k->ownertrust =
2438                         (get_ownertrust (kar->keyblock->pkt->pkt.public_key)
2439                          & TRUST_MASK);
2440                       k->min_ownertrust =
2441                         get_min_ownertrust(kar->keyblock->pkt->pkt.public_key);
2442                       k->trust_depth=
2443                         kar->keyblock->pkt->pkt.public_key->trust_depth;
2444                       k->trust_value=
2445                         kar->keyblock->pkt->pkt.public_key->trust_value;
2446                       if(kar->keyblock->pkt->pkt.public_key->trust_regexp)
2447                         k->trust_regexp=
2448                           xstrdup(kar->keyblock->pkt->
2449                                    pkt.public_key->trust_regexp);
2450                       k->next = klist;
2451                       klist = k;
2452                       break;
2453                     }
2454                 }
2455             }
2456         }
2457       release_key_array (keys);
2458       keys = NULL;
2459       if (!klist)
2460         break; /* no need to dive in deeper */
2461     }
2462
2463  leave:
2464   keydb_release (kdb);
2465   release_key_array (keys);
2466   release_key_items (klist);
2467   release_key_hash_table (full_trust);
2468   release_key_hash_table (used);
2469   release_key_hash_table (stored);
2470   if (!rc && !quit) /* mark trustDB as checked */
2471     {
2472       if (next_expire == 0xffffffff || next_expire < start_time )
2473         tdbio_write_nextcheck (0); 
2474       else
2475         {
2476           tdbio_write_nextcheck (next_expire); 
2477           log_info (_("next trustdb check due at %s\n"),
2478                     strtimestamp (next_expire));
2479         }
2480
2481       if(tdbio_update_version_record()!=0)
2482         {
2483           log_error(_("unable to update trustdb version record: "
2484                       "write failed: %s\n"), g10_errstr(rc));
2485           tdbio_invalid();
2486         }
2487
2488       do_sync ();
2489       pending_check_trustdb = 0;
2490     }
2491
2492   return rc;
2493 }