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