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