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