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