gpg: Move all DNS access to Dirmngr.
[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, gpg_strerror (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, gpg_strerror (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"), gpg_strerror (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", gpg_strerror (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                  gpg_strerror (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 GPG_ERR_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),gpg_strerror (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               if (!opt.quiet)
942                 log_info (_("please do a --check-trustdb\n"));
943             }
944           else
945             {
946               if (!opt.quiet)
947                 log_info (_("checking the trustdb\n"));
948               validate_keys (0);
949             }
950         }
951     }
952 }
953
954 /*
955  * Return the validity information for PK.  This is the core of
956  * get_validity.
957  */
958 unsigned int
959 tdb_get_validity_core (PKT_public_key *pk, PKT_user_id *uid,
960                        PKT_public_key *main_pk)
961 {
962   TRUSTREC trec, vrec;
963   int rc;
964   ulong recno;
965   unsigned int validity;
966
967   init_trustdb ();
968
969   /* If we have no trustdb (which also means it has not been created)
970      and the trust-model is always, we don't know the validity -
971      return immediately.  If we won't do that the tdbio code would try
972      to open the trustdb and run into a fatal error.  */
973   if (trustdb_args.no_trustdb && opt.trust_model == TM_ALWAYS)
974     return TRUST_UNKNOWN;
975
976   check_trustdb_stale();
977
978   if(opt.trust_model==TM_DIRECT)
979     {
980       /* Note that this happens BEFORE any user ID stuff is checked.
981          The direct trust model applies to keys as a whole. */
982       validity = tdb_get_ownertrust (main_pk);
983       goto leave;
984     }
985
986   rc = read_trust_record (main_pk, &trec);
987   if (rc && rc != -1)
988     {
989       tdbio_invalid ();
990       return 0;
991     }
992   if (rc == -1) /* no record found */
993     {
994       validity = TRUST_UNKNOWN;
995       goto leave;
996     }
997
998   /* loop over all user IDs */
999   recno = trec.r.trust.validlist;
1000   validity = 0;
1001   while (recno)
1002     {
1003       read_record (recno, &vrec, RECTYPE_VALID);
1004
1005       if(uid)
1006         {
1007           /* If a user ID is given we return the validity for that
1008              user ID ONLY.  If the namehash is not found, then there
1009              is no validity at all (i.e. the user ID wasn't
1010              signed). */
1011           if(memcmp(vrec.r.valid.namehash,uid->namehash,20)==0)
1012             {
1013               validity=(vrec.r.valid.validity & TRUST_MASK);
1014               break;
1015             }
1016         }
1017       else
1018         {
1019           /* If no namehash is given, we take the maximum validity
1020              over all user IDs */
1021           if ( validity < (vrec.r.valid.validity & TRUST_MASK) )
1022             validity = (vrec.r.valid.validity & TRUST_MASK);
1023         }
1024
1025       recno = vrec.r.valid.next;
1026     }
1027
1028   if ( (trec.r.trust.ownertrust & TRUST_FLAG_DISABLED) )
1029     {
1030       validity |= TRUST_FLAG_DISABLED;
1031       pk->flags.disabled = 1;
1032     }
1033   else
1034     pk->flags.disabled = 0;
1035   pk->flags.disabled_valid = 1;
1036
1037  leave:
1038   if (pending_check_trustdb)
1039     validity |= TRUST_FLAG_PENDING_CHECK;
1040
1041   return validity;
1042 }
1043
1044
1045 static void
1046 get_validity_counts (PKT_public_key *pk, PKT_user_id *uid)
1047 {
1048   TRUSTREC trec, vrec;
1049   ulong recno;
1050
1051   if(pk==NULL || uid==NULL)
1052     BUG();
1053
1054   namehash_from_uid(uid);
1055
1056   uid->help_marginal_count=uid->help_full_count=0;
1057
1058   init_trustdb ();
1059
1060   if(read_trust_record (pk, &trec)!=0)
1061     return;
1062
1063   /* loop over all user IDs */
1064   recno = trec.r.trust.validlist;
1065   while (recno)
1066     {
1067       read_record (recno, &vrec, RECTYPE_VALID);
1068
1069       if(memcmp(vrec.r.valid.namehash,uid->namehash,20)==0)
1070         {
1071           uid->help_marginal_count=vrec.r.valid.marginal_count;
1072           uid->help_full_count=vrec.r.valid.full_count;
1073           /*  es_printf("Fetched marginal %d, full %d\n",uid->help_marginal_count,uid->help_full_count); */
1074           break;
1075         }
1076
1077       recno = vrec.r.valid.next;
1078     }
1079 }
1080
1081 void
1082 list_trust_path( const char *username )
1083 {
1084   (void)username;
1085 }
1086
1087 /****************
1088  * Enumerate all keys, which are needed to build all trust paths for
1089  * the given key.  This function does not return the key itself or
1090  * the ultimate key (the last point in cerificate chain).  Only
1091  * certificate chains which ends up at an ultimately trusted key
1092  * are listed.  If ownertrust or validity is not NULL, the corresponding
1093  * value for the returned LID is also returned in these variable(s).
1094  *
1095  *  1) create a void pointer and initialize it to NULL
1096  *  2) pass this void pointer by reference to this function.
1097  *     Set lid to the key you want to enumerate and pass it by reference.
1098  *  3) call this function as long as it does not return -1
1099  *     to indicate EOF. LID does contain the next key used to build the web
1100  *  4) Always call this function a last time with LID set to NULL,
1101  *     so that it can free its context.
1102  *
1103  * Returns: -1 on EOF or the level of the returned LID
1104  */
1105 int
1106 enum_cert_paths( void **context, ulong *lid,
1107                  unsigned *ownertrust, unsigned *validity )
1108 {
1109   (void)context;
1110   (void)lid;
1111   (void)ownertrust;
1112   (void)validity;
1113   return -1;
1114 }
1115
1116
1117 /****************
1118  * Print the current path
1119  */
1120 void
1121 enum_cert_paths_print (void **context, FILE *fp,
1122                        int refresh, ulong selected_lid)
1123 {
1124   (void)context;
1125   (void)fp;
1126   (void)refresh;
1127   (void)selected_lid;
1128 }
1129
1130
1131 \f
1132 /****************************************
1133  *********** NEW NEW NEW ****************
1134  ****************************************/
1135
1136 static int
1137 ask_ownertrust (u32 *kid,int minimum)
1138 {
1139   PKT_public_key *pk;
1140   int rc;
1141   int ot;
1142
1143   pk = xmalloc_clear (sizeof *pk);
1144   rc = get_pubkey (pk, kid);
1145   if (rc)
1146     {
1147       log_error (_("public key %s not found: %s\n"),
1148                  keystr(kid), gpg_strerror (rc) );
1149       return TRUST_UNKNOWN;
1150     }
1151
1152   if(opt.force_ownertrust)
1153     {
1154       log_info("force trust for key %s to %s\n",
1155                keystr(kid),trust_value_to_string(opt.force_ownertrust));
1156       tdb_update_ownertrust (pk, opt.force_ownertrust);
1157       ot=opt.force_ownertrust;
1158     }
1159   else
1160     {
1161       ot=edit_ownertrust(pk,0);
1162       if(ot>0)
1163         ot = tdb_get_ownertrust (pk);
1164       else if(ot==0)
1165         ot = minimum?minimum:TRUST_UNDEFINED;
1166       else
1167         ot = -1; /* quit */
1168     }
1169
1170   free_public_key( pk );
1171
1172   return ot;
1173 }
1174
1175
1176 static void
1177 mark_keyblock_seen (KeyHashTable tbl, KBNODE node)
1178 {
1179   for ( ;node; node = node->next )
1180     if (node->pkt->pkttype == PKT_PUBLIC_KEY
1181         || node->pkt->pkttype == PKT_PUBLIC_SUBKEY)
1182       {
1183         u32 aki[2];
1184
1185         keyid_from_pk (node->pkt->pkt.public_key, aki);
1186         add_key_hash_table (tbl, aki);
1187       }
1188 }
1189
1190
1191 static void
1192 dump_key_array (int depth, struct key_array *keys)
1193 {
1194   struct key_array *kar;
1195
1196   for (kar=keys; kar->keyblock; kar++)
1197     {
1198       KBNODE node = kar->keyblock;
1199       u32 kid[2];
1200
1201       keyid_from_pk(node->pkt->pkt.public_key, kid);
1202       es_printf ("%d:%08lX%08lX:K::%c::::\n",
1203                  depth, (ulong)kid[0], (ulong)kid[1], '?');
1204
1205       for (; node; node = node->next)
1206         {
1207           if (node->pkt->pkttype == PKT_USER_ID)
1208             {
1209               int len = node->pkt->pkt.user_id->len;
1210
1211               if (len > 30)
1212                 len = 30;
1213               es_printf ("%d:%08lX%08lX:U:::%c:::",
1214                          depth, (ulong)kid[0], (ulong)kid[1],
1215                          (node->flag & 4)? 'f':
1216                          (node->flag & 2)? 'm':
1217                          (node->flag & 1)? 'q':'-');
1218               es_write_sanitized (es_stdout, node->pkt->pkt.user_id->name,
1219                                   len, ":", NULL);
1220               es_putc (':', es_stdout);
1221               es_putc ('\n', es_stdout);
1222             }
1223         }
1224     }
1225 }
1226
1227
1228 static void
1229 store_validation_status (int depth, KBNODE keyblock, KeyHashTable stored)
1230 {
1231   KBNODE node;
1232   int status;
1233   int any = 0;
1234
1235   for (node=keyblock; node; node = node->next)
1236     {
1237       if (node->pkt->pkttype == PKT_USER_ID)
1238         {
1239           PKT_user_id *uid = node->pkt->pkt.user_id;
1240           if (node->flag & 4)
1241             status = TRUST_FULLY;
1242           else if (node->flag & 2)
1243             status = TRUST_MARGINAL;
1244           else if (node->flag & 1)
1245             status = TRUST_UNDEFINED;
1246           else
1247             status = 0;
1248
1249           if (status)
1250             {
1251               update_validity (keyblock->pkt->pkt.public_key,
1252                                uid, depth, status);
1253
1254               mark_keyblock_seen(stored,keyblock);
1255
1256               any = 1;
1257             }
1258         }
1259     }
1260
1261   if (any)
1262     do_sync ();
1263 }
1264
1265
1266 /* Returns a sanitized copy of the regexp (which might be "", but not
1267    NULL). */
1268 #ifndef DISABLE_REGEX
1269 static char *
1270 sanitize_regexp(const char *old)
1271 {
1272   size_t start=0,len=strlen(old),idx=0;
1273   int escaped=0,standard_bracket=0;
1274   char *new=xmalloc((len*2)+1); /* enough to \-escape everything if we
1275                                    have to */
1276
1277   /* There are basically two commonly-used regexps here.  GPG and most
1278      versions of PGP use "<[^>]+[@.]example\.com>$" and PGP (9)
1279      command line uses "example.com" (i.e. whatever the user specfies,
1280      and we can't expect users know to use "\." instead of ".").  So
1281      here are the rules: we're allowed to start with "<[^>]+[@.]" and
1282      end with ">$" or start and end with nothing.  In between, the
1283      only legal regex character is ".", and everything else gets
1284      escaped.  Part of the gotcha here is that some regex packages
1285      allow more than RFC-4880 requires.  For example, 4880 has no "{}"
1286      operator, but GNU regex does.  Commenting removes these operators
1287      from consideration.  A possible future enhancement is to use
1288      commenting to effectively back off a given regex to the Henry
1289      Spencer syntax in 4880. -dshaw */
1290
1291   /* Are we bracketed between "<[^>]+[@.]" and ">$" ? */
1292   if(len>=12 && strncmp(old,"<[^>]+[@.]",10)==0
1293      && old[len-2]=='>' && old[len-1]=='$')
1294     {
1295       strcpy(new,"<[^>]+[@.]");
1296       idx=strlen(new);
1297       standard_bracket=1;
1298       start+=10;
1299       len-=2;
1300     }
1301
1302   /* Walk the remaining characters and ensure that everything that is
1303      left is not an operational regex character. */
1304   for(;start<len;start++)
1305     {
1306       if(!escaped && old[start]=='\\')
1307         escaped=1;
1308       else if(!escaped && old[start]!='.')
1309         new[idx++]='\\';
1310       else
1311         escaped=0;
1312
1313       new[idx++]=old[start];
1314     }
1315
1316   new[idx]='\0';
1317
1318   /* Note that the (sub)string we look at might end with a bare "\".
1319      If it does, leave it that way.  If the regexp actually ended with
1320      ">$", then it was escaping the ">" and is fine.  If the regexp
1321      actually ended with the bare "\", then it's an illegal regexp and
1322      regcomp should kick it out. */
1323
1324   if(standard_bracket)
1325     strcat(new,">$");
1326
1327   return new;
1328 }
1329 #endif /*!DISABLE_REGEX*/
1330
1331 /* Used by validate_one_keyblock to confirm a regexp within a trust
1332    signature.  Returns 1 for match, and 0 for no match or regex
1333    error. */
1334 static int
1335 check_regexp(const char *expr,const char *string)
1336 {
1337 #ifdef DISABLE_REGEX
1338   (void)expr;
1339   (void)string;
1340   /* When DISABLE_REGEX is defined, assume all regexps do not
1341      match. */
1342   return 0;
1343 #else
1344   int ret;
1345   char *regexp;
1346
1347   regexp=sanitize_regexp(expr);
1348
1349 #ifdef __riscos__
1350   ret=riscos_check_regexp(expr, string, DBG_TRUST);
1351 #else
1352   {
1353     regex_t pat;
1354
1355     ret=regcomp(&pat,regexp,REG_ICASE|REG_NOSUB|REG_EXTENDED);
1356     if(ret==0)
1357       {
1358         ret=regexec(&pat,string,0,NULL,0);
1359         regfree(&pat);
1360         ret=(ret==0);
1361       }
1362   }
1363 #endif
1364
1365   if(DBG_TRUST)
1366     log_debug("regexp '%s' ('%s') on '%s': %s\n",
1367               regexp,expr,string,ret==0?"YES":"NO");
1368
1369   xfree(regexp);
1370
1371   return ret;
1372 #endif
1373 }
1374
1375 /*
1376  * Return true if the key is signed by one of the keys in the given
1377  * key ID list.  User IDs with a valid signature are marked by node
1378  * flags as follows:
1379  *  flag bit 0: There is at least one signature
1380  *           1: There is marginal confidence that this is a legitimate uid
1381  *           2: There is full confidence that this is a legitimate uid.
1382  *           8: Used for internal purposes.
1383  *           9: Ditto (in mark_usable_uid_certs())
1384  *          10: Ditto (ditto)
1385  * This function assumes that all kbnode flags are cleared on entry.
1386  */
1387 static int
1388 validate_one_keyblock (KBNODE kb, struct key_item *klist,
1389                        u32 curtime, u32 *next_expire)
1390 {
1391   struct key_item *kr;
1392   KBNODE node, uidnode=NULL;
1393   PKT_user_id *uid=NULL;
1394   PKT_public_key *pk = kb->pkt->pkt.public_key;
1395   u32 main_kid[2];
1396   int issigned=0, any_signed = 0;
1397
1398   keyid_from_pk(pk, main_kid);
1399   for (node=kb; node; node = node->next)
1400     {
1401       /* A bit of discussion here: is it better for the web of trust
1402          to be built among only self-signed uids?  On the one hand, a
1403          self-signed uid is a statement that the key owner definitely
1404          intended that uid to be there, but on the other hand, a
1405          signed (but not self-signed) uid does carry trust, of a sort,
1406          even if it is a statement being made by people other than the
1407          key owner "through" the uids on the key owner's key.  I'm
1408          going with the latter.  However, if the user ID was
1409          explicitly revoked, or passively allowed to expire, that
1410          should stop validity through the user ID until it is
1411          resigned.  -dshaw */
1412
1413       if (node->pkt->pkttype == PKT_USER_ID
1414           && !node->pkt->pkt.user_id->is_revoked
1415           && !node->pkt->pkt.user_id->is_expired)
1416         {
1417           if (uidnode && issigned)
1418             {
1419               if (uid->help_full_count >= opt.completes_needed
1420                   || uid->help_marginal_count >= opt.marginals_needed )
1421                 uidnode->flag |= 4;
1422               else if (uid->help_full_count || uid->help_marginal_count)
1423                 uidnode->flag |= 2;
1424               uidnode->flag |= 1;
1425               any_signed = 1;
1426             }
1427           uidnode = node;
1428           uid=uidnode->pkt->pkt.user_id;
1429
1430           /* If the selfsig is going to expire... */
1431           if(uid->expiredate && uid->expiredate<*next_expire)
1432             *next_expire = uid->expiredate;
1433
1434           issigned = 0;
1435           get_validity_counts(pk,uid);
1436           mark_usable_uid_certs (kb, uidnode, main_kid, klist,
1437                                  curtime, next_expire);
1438         }
1439       else if (node->pkt->pkttype == PKT_SIGNATURE
1440                && (node->flag & (1<<8)) && uid)
1441         {
1442           /* Note that we are only seeing unrevoked sigs here */
1443           PKT_signature *sig = node->pkt->pkt.signature;
1444
1445           kr = is_in_klist (klist, sig);
1446           /* If the trust_regexp does not match, it's as if the sig
1447              did not exist.  This is safe for non-trust sigs as well
1448              since we don't accept a regexp on the sig unless it's a
1449              trust sig. */
1450           if (kr && (!kr->trust_regexp
1451                      || opt.trust_model != TM_PGP
1452                      || (uidnode
1453                          && check_regexp(kr->trust_regexp,
1454                                          uidnode->pkt->pkt.user_id->name))))
1455             {
1456               /* Are we part of a trust sig chain?  We always favor
1457                  the latest trust sig, rather than the greater or
1458                  lesser trust sig or value.  I could make a decent
1459                  argument for any of these cases, but this seems to be
1460                  what PGP does, and I'd like to be compatible. -dms */
1461               if (opt.trust_model == TM_PGP
1462                   && sig->trust_depth
1463                   && pk->trust_timestamp <= sig->timestamp)
1464                 {
1465                   unsigned char depth;
1466
1467                   /* If the depth on the signature is less than the
1468                      chain currently has, then use the signature depth
1469                      so we don't increase the depth beyond what the
1470                      signer wanted.  If the depth on the signature is
1471                      more than the chain currently has, then use the
1472                      chain depth so we use as much of the signature
1473                      depth as the chain will permit.  An ultimately
1474                      trusted signature can restart the depth to
1475                      whatever level it likes. */
1476
1477                   if (sig->trust_depth < kr->trust_depth
1478                       || kr->ownertrust == TRUST_ULTIMATE)
1479                     depth = sig->trust_depth;
1480                   else
1481                     depth = kr->trust_depth;
1482
1483                   if (depth)
1484                     {
1485                       if(DBG_TRUST)
1486                         log_debug ("trust sig on %s, sig depth is %d,"
1487                                    " kr depth is %d\n",
1488                                    uidnode->pkt->pkt.user_id->name,
1489                                    sig->trust_depth,
1490                                    kr->trust_depth);
1491
1492                       /* If we got here, we know that:
1493
1494                          this is a trust sig.
1495
1496                          it's a newer trust sig than any previous trust
1497                          sig on this key (not uid).
1498
1499                          it is legal in that it was either generated by an
1500                          ultimate key, or a key that was part of a trust
1501                          chain, and the depth does not violate the
1502                          original trust sig.
1503
1504                          if there is a regexp attached, it matched
1505                          successfully.
1506                       */
1507
1508                       if (DBG_TRUST)
1509                         log_debug ("replacing trust value %d with %d and "
1510                                    "depth %d with %d\n",
1511                                    pk->trust_value,sig->trust_value,
1512                                    pk->trust_depth,depth);
1513
1514                       pk->trust_value = sig->trust_value;
1515                       pk->trust_depth = depth-1;
1516
1517                       /* If the trust sig contains a regexp, record it
1518                          on the pk for the next round. */
1519                       if (sig->trust_regexp)
1520                         pk->trust_regexp = sig->trust_regexp;
1521                     }
1522                 }
1523
1524               if (kr->ownertrust == TRUST_ULTIMATE)
1525                 uid->help_full_count = opt.completes_needed;
1526               else if (kr->ownertrust == TRUST_FULLY)
1527                 uid->help_full_count++;
1528               else if (kr->ownertrust == TRUST_MARGINAL)
1529                 uid->help_marginal_count++;
1530               issigned = 1;
1531             }
1532         }
1533     }
1534
1535   if (uidnode && issigned)
1536     {
1537       if (uid->help_full_count >= opt.completes_needed
1538           || uid->help_marginal_count >= opt.marginals_needed )
1539         uidnode->flag |= 4;
1540       else if (uid->help_full_count || uid->help_marginal_count)
1541         uidnode->flag |= 2;
1542       uidnode->flag |= 1;
1543       any_signed = 1;
1544     }
1545
1546   return any_signed;
1547 }
1548
1549
1550 static int
1551 search_skipfnc (void *opaque, u32 *kid, PKT_user_id *dummy)
1552 {
1553   (void)dummy;
1554   return test_key_hash_table ((KeyHashTable)opaque, kid);
1555 }
1556
1557
1558 /*
1559  * Scan all keys and return a key_array of all suitable keys from
1560  * kllist.  The caller has to pass keydb handle so that we don't use
1561  * to create our own.  Returns either a key_array or NULL in case of
1562  * an error.  No results found are indicated by an empty array.
1563  * Caller hast to release the returned array.
1564  */
1565 static struct key_array *
1566 validate_key_list (KEYDB_HANDLE hd, KeyHashTable full_trust,
1567                    struct key_item *klist, u32 curtime, u32 *next_expire)
1568 {
1569   KBNODE keyblock = NULL;
1570   struct key_array *keys = NULL;
1571   size_t nkeys, maxkeys;
1572   int rc;
1573   KEYDB_SEARCH_DESC desc;
1574
1575   maxkeys = 1000;
1576   keys = xmalloc ((maxkeys+1) * sizeof *keys);
1577   nkeys = 0;
1578
1579   rc = keydb_search_reset (hd);
1580   if (rc)
1581     {
1582       log_error ("keydb_search_reset failed: %s\n", gpg_strerror (rc));
1583       xfree (keys);
1584       return NULL;
1585     }
1586
1587   memset (&desc, 0, sizeof desc);
1588   desc.mode = KEYDB_SEARCH_MODE_FIRST;
1589   desc.skipfnc = search_skipfnc;
1590   desc.skipfncvalue = full_trust;
1591   rc = keydb_search (hd, &desc, 1, NULL);
1592   if (gpg_err_code (rc) == GPG_ERR_NOT_FOUND)
1593     {
1594       keys[nkeys].keyblock = NULL;
1595       return keys;
1596     }
1597   if (rc)
1598     {
1599       log_error ("keydb_search_first failed: %s\n", gpg_strerror (rc));
1600       xfree (keys);
1601       return NULL;
1602     }
1603
1604   desc.mode = KEYDB_SEARCH_MODE_NEXT; /* change mode */
1605   do
1606     {
1607       PKT_public_key *pk;
1608
1609       if (gpg_err_code (rc) == GPG_ERR_LEGACY_KEY)
1610         continue;
1611
1612       rc = keydb_get_keyblock (hd, &keyblock);
1613       if (rc)
1614         {
1615           log_error ("keydb_get_keyblock failed: %s\n", gpg_strerror (rc));
1616           xfree (keys);
1617           return NULL;
1618         }
1619
1620       if ( keyblock->pkt->pkttype != PKT_PUBLIC_KEY)
1621         {
1622           log_debug ("ooops: invalid pkttype %d encountered\n",
1623                      keyblock->pkt->pkttype);
1624           dump_kbnode (keyblock);
1625           release_kbnode(keyblock);
1626           continue;
1627         }
1628
1629       /* prepare the keyblock for further processing */
1630       merge_keys_and_selfsig (keyblock);
1631       clear_kbnode_flags (keyblock);
1632       pk = keyblock->pkt->pkt.public_key;
1633       if (pk->has_expired || pk->flags.revoked)
1634         {
1635           /* it does not make sense to look further at those keys */
1636           mark_keyblock_seen (full_trust, keyblock);
1637         }
1638       else if (validate_one_keyblock (keyblock, klist, curtime, next_expire))
1639         {
1640           KBNODE node;
1641
1642           if (pk->expiredate && pk->expiredate >= curtime
1643               && pk->expiredate < *next_expire)
1644             *next_expire = pk->expiredate;
1645
1646           if (nkeys == maxkeys) {
1647             maxkeys += 1000;
1648             keys = xrealloc (keys, (maxkeys+1) * sizeof *keys);
1649           }
1650           keys[nkeys++].keyblock = keyblock;
1651
1652           /* Optimization - if all uids are fully trusted, then we
1653              never need to consider this key as a candidate again. */
1654
1655           for (node=keyblock; node; node = node->next)
1656             if (node->pkt->pkttype == PKT_USER_ID && !(node->flag & 4))
1657               break;
1658
1659           if(node==NULL)
1660             mark_keyblock_seen (full_trust, keyblock);
1661
1662           keyblock = NULL;
1663         }
1664
1665       release_kbnode (keyblock);
1666       keyblock = NULL;
1667     }
1668   while (!(rc = keydb_search (hd, &desc, 1, NULL))
1669          || gpg_err_code (rc) == GPG_ERR_LEGACY_KEY);
1670
1671   if (rc && gpg_err_code (rc) != GPG_ERR_NOT_FOUND)
1672     {
1673       log_error ("keydb_search_next failed: %s\n", gpg_strerror (rc));
1674       xfree (keys);
1675       return NULL;
1676     }
1677
1678   keys[nkeys].keyblock = NULL;
1679   return keys;
1680 }
1681
1682 /* Caller must sync */
1683 static void
1684 reset_trust_records(void)
1685 {
1686   TRUSTREC rec;
1687   ulong recnum;
1688   int count = 0, nreset = 0;
1689
1690   for (recnum=1; !tdbio_read_record (recnum, &rec, 0); recnum++ )
1691     {
1692       if(rec.rectype==RECTYPE_TRUST)
1693         {
1694           count++;
1695           if(rec.r.trust.min_ownertrust)
1696             {
1697               rec.r.trust.min_ownertrust=0;
1698               write_record(&rec);
1699             }
1700
1701         }
1702       else if(rec.rectype==RECTYPE_VALID
1703               && ((rec.r.valid.validity&TRUST_MASK)
1704                   || rec.r.valid.marginal_count
1705                   || rec.r.valid.full_count))
1706         {
1707           rec.r.valid.validity &= ~TRUST_MASK;
1708           rec.r.valid.marginal_count=rec.r.valid.full_count=0;
1709           nreset++;
1710           write_record(&rec);
1711         }
1712
1713     }
1714
1715   if (opt.verbose)
1716     log_info (_("%d keys processed (%d validity counts cleared)\n"),
1717               count, nreset);
1718 }
1719
1720 /*
1721  * Run the key validation procedure.
1722  *
1723  * This works this way:
1724  * Step 1: Find all ultimately trusted keys (UTK).
1725  *         mark them all as seen and put them into klist.
1726  * Step 2: loop max_cert_times
1727  * Step 3:   if OWNERTRUST of any key in klist is undefined
1728  *             ask user to assign ownertrust
1729  * Step 4:   Loop over all keys in the keyDB which are not marked seen
1730  * Step 5:     if key is revoked or expired
1731  *                mark key as seen
1732  *                continue loop at Step 4
1733  * Step 6:     For each user ID of that key signed by a key in klist
1734  *                Calculate validity by counting trusted signatures.
1735  *                Set validity of user ID
1736  * Step 7:     If any signed user ID was found
1737  *                mark key as seen
1738  *             End Loop
1739  * Step 8:   Build a new klist from all fully trusted keys from step 6
1740  *           End Loop
1741  *         Ready
1742  *
1743  */
1744 static int
1745 validate_keys (int interactive)
1746 {
1747   int rc = 0;
1748   int quit=0;
1749   struct key_item *klist = NULL;
1750   struct key_item *k;
1751   struct key_array *keys = NULL;
1752   struct key_array *kar;
1753   KEYDB_HANDLE kdb = NULL;
1754   KBNODE node;
1755   int depth;
1756   int ot_unknown, ot_undefined, ot_never, ot_marginal, ot_full, ot_ultimate;
1757   KeyHashTable stored,used,full_trust;
1758   u32 start_time, next_expire;
1759
1760   /* Make sure we have all sigs cached.  TODO: This is going to
1761      require some architectual re-thinking, as it is agonizingly slow.
1762      Perhaps combine this with reset_trust_records(), or only check
1763      the caches on keys that are actually involved in the web of
1764      trust. */
1765   keydb_rebuild_caches(0);
1766
1767   start_time = make_timestamp ();
1768   next_expire = 0xffffffff; /* set next expire to the year 2106 */
1769   stored = new_key_hash_table ();
1770   used = new_key_hash_table ();
1771   full_trust = new_key_hash_table ();
1772
1773   kdb = keydb_new ();
1774   reset_trust_records();
1775
1776   /* Fixme: Instead of always building a UTK list, we could just build it
1777    * here when needed */
1778   if (!utk_list)
1779     {
1780       if (!opt.quiet)
1781         log_info (_("no ultimately trusted keys found\n"));
1782       goto leave;
1783     }
1784
1785   /* mark all UTKs as used and fully_trusted and set validity to
1786      ultimate */
1787   for (k=utk_list; k; k = k->next)
1788     {
1789       KBNODE keyblock;
1790       PKT_public_key *pk;
1791
1792       keyblock = get_pubkeyblock (k->kid);
1793       if (!keyblock)
1794         {
1795           log_error (_("public key of ultimately"
1796                        " trusted key %s not found\n"), keystr(k->kid));
1797           continue;
1798         }
1799       mark_keyblock_seen (used, keyblock);
1800       mark_keyblock_seen (stored, keyblock);
1801       mark_keyblock_seen (full_trust, keyblock);
1802       pk = keyblock->pkt->pkt.public_key;
1803       for (node=keyblock; node; node = node->next)
1804         {
1805           if (node->pkt->pkttype == PKT_USER_ID)
1806             update_validity (pk, node->pkt->pkt.user_id, 0, TRUST_ULTIMATE);
1807         }
1808       if ( pk->expiredate && pk->expiredate >= start_time
1809            && pk->expiredate < next_expire)
1810         next_expire = pk->expiredate;
1811
1812       release_kbnode (keyblock);
1813       do_sync ();
1814     }
1815
1816   klist = utk_list;
1817
1818   log_info(_("%d marginal(s) needed, %d complete(s) needed, %s trust model\n"),
1819            opt.marginals_needed,opt.completes_needed,trust_model_string());
1820
1821   for (depth=0; depth < opt.max_cert_depth; depth++)
1822     {
1823       int valids=0,key_count;
1824       /* See whether we should assign ownertrust values to the keys in
1825          klist.  */
1826       ot_unknown = ot_undefined = ot_never = 0;
1827       ot_marginal = ot_full = ot_ultimate = 0;
1828       for (k=klist; k; k = k->next)
1829         {
1830           int min=0;
1831
1832           /* 120 and 60 are as per RFC2440 */
1833           if(k->trust_value>=120)
1834             min=TRUST_FULLY;
1835           else if(k->trust_value>=60)
1836             min=TRUST_MARGINAL;
1837
1838           if(min!=k->min_ownertrust)
1839             update_min_ownertrust(k->kid,min);
1840
1841           if (interactive && k->ownertrust == TRUST_UNKNOWN)
1842             {
1843               k->ownertrust = ask_ownertrust (k->kid,min);
1844
1845               if (k->ownertrust == (unsigned int)(-1))
1846                 {
1847                   quit=1;
1848                   goto leave;
1849                 }
1850             }
1851
1852           /* This can happen during transition from an old trustdb
1853              before trust sigs.  It can also happen if a user uses two
1854              different versions of GnuPG or changes the --trust-model
1855              setting. */
1856           if(k->ownertrust<min)
1857             {
1858               if(DBG_TRUST)
1859                 log_debug("key %08lX%08lX:"
1860                           " overriding ownertrust '%s' with '%s'\n",
1861                           (ulong)k->kid[0],(ulong)k->kid[1],
1862                           trust_value_to_string(k->ownertrust),
1863                           trust_value_to_string(min));
1864
1865               k->ownertrust=min;
1866             }
1867
1868           if (k->ownertrust == TRUST_UNKNOWN)
1869             ot_unknown++;
1870           else if (k->ownertrust == TRUST_UNDEFINED)
1871             ot_undefined++;
1872           else if (k->ownertrust == TRUST_NEVER)
1873             ot_never++;
1874           else if (k->ownertrust == TRUST_MARGINAL)
1875             ot_marginal++;
1876           else if (k->ownertrust == TRUST_FULLY)
1877             ot_full++;
1878           else if (k->ownertrust == TRUST_ULTIMATE)
1879             ot_ultimate++;
1880
1881           valids++;
1882         }
1883
1884       /* Find all keys which are signed by a key in kdlist */
1885       keys = validate_key_list (kdb, full_trust, klist,
1886                                 start_time, &next_expire);
1887       if (!keys)
1888         {
1889           log_error ("validate_key_list failed\n");
1890           rc = GPG_ERR_GENERAL;
1891           goto leave;
1892         }
1893
1894       for (key_count=0, kar=keys; kar->keyblock; kar++, key_count++)
1895         ;
1896
1897       /* Store the calculated valididation status somewhere */
1898       if (opt.verbose > 1)
1899         dump_key_array (depth, keys);
1900
1901       for (kar=keys; kar->keyblock; kar++)
1902           store_validation_status (depth, kar->keyblock, stored);
1903
1904       log_info (_("depth: %d  valid: %3d  signed: %3d"
1905                   "  trust: %d-, %dq, %dn, %dm, %df, %du\n"),
1906                 depth, valids, key_count, ot_unknown, ot_undefined,
1907                 ot_never, ot_marginal, ot_full, ot_ultimate );
1908
1909       /* Build a new kdlist from all fully valid keys in KEYS */
1910       if (klist != utk_list)
1911         release_key_items (klist);
1912       klist = NULL;
1913       for (kar=keys; kar->keyblock; kar++)
1914         {
1915           for (node=kar->keyblock; node; node = node->next)
1916             {
1917               if (node->pkt->pkttype == PKT_USER_ID && (node->flag & 4))
1918                 {
1919                   u32 kid[2];
1920
1921                   /* have we used this key already? */
1922                   keyid_from_pk (kar->keyblock->pkt->pkt.public_key, kid);
1923                   if(test_key_hash_table(used,kid)==0)
1924                     {
1925                       /* Normally we add both the primary and subkey
1926                          ids to the hash via mark_keyblock_seen, but
1927                          since we aren't using this hash as a skipfnc,
1928                          that doesn't matter here. */
1929                       add_key_hash_table (used,kid);
1930                       k = new_key_item ();
1931                       k->kid[0]=kid[0];
1932                       k->kid[1]=kid[1];
1933                       k->ownertrust =
1934                         (tdb_get_ownertrust
1935                          (kar->keyblock->pkt->pkt.public_key) & TRUST_MASK);
1936                       k->min_ownertrust = tdb_get_min_ownertrust
1937                         (kar->keyblock->pkt->pkt.public_key);
1938                       k->trust_depth=
1939                         kar->keyblock->pkt->pkt.public_key->trust_depth;
1940                       k->trust_value=
1941                         kar->keyblock->pkt->pkt.public_key->trust_value;
1942                       if(kar->keyblock->pkt->pkt.public_key->trust_regexp)
1943                         k->trust_regexp=
1944                           xstrdup(kar->keyblock->pkt->
1945                                    pkt.public_key->trust_regexp);
1946                       k->next = klist;
1947                       klist = k;
1948                       break;
1949                     }
1950                 }
1951             }
1952         }
1953       release_key_array (keys);
1954       keys = NULL;
1955       if (!klist)
1956         break; /* no need to dive in deeper */
1957     }
1958
1959  leave:
1960   keydb_release (kdb);
1961   release_key_array (keys);
1962   release_key_items (klist);
1963   release_key_hash_table (full_trust);
1964   release_key_hash_table (used);
1965   release_key_hash_table (stored);
1966   if (!rc && !quit) /* mark trustDB as checked */
1967     {
1968       if (next_expire == 0xffffffff || next_expire < start_time )
1969         tdbio_write_nextcheck (0);
1970       else
1971         {
1972           tdbio_write_nextcheck (next_expire);
1973           log_info (_("next trustdb check due at %s\n"),
1974                     strtimestamp (next_expire));
1975         }
1976
1977       if(tdbio_update_version_record()!=0)
1978         {
1979           log_error(_("unable to update trustdb version record: "
1980                       "write failed: %s\n"), gpg_strerror (rc));
1981           tdbio_invalid();
1982         }
1983
1984       do_sync ();
1985       pending_check_trustdb = 0;
1986     }
1987
1988   return rc;
1989 }