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