* trustdb.h, trustdb.c (uid_trust_string_fixed): New. Return a fixed-size
[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
497    columns. */
498 const char *
499 uid_trust_string_fixed(PKT_public_key *key,PKT_user_id *uid)
500 {
501   if(!key && !uid)
502     return _("10");
503   else if(uid->is_revoked)
504     return                         _("[ revoked]");
505   else if(uid->is_expired)
506     return                         _("[ expired]");
507   else if(key)
508     switch(get_validity(key,uid)&TRUST_MASK)
509       {
510       case TRUST_UNKNOWN:   return _("[ unknown]");
511       case TRUST_UNDEFINED: return _("[  undef ]");
512       case TRUST_MARGINAL:  return _("[marginal]");
513       case TRUST_FULLY:     return _("[  full  ]");
514       case TRUST_ULTIMATE:  return _("[ultimate]");
515       }
516
517   return "err";
518 }
519
520 /* The strings here are similar to those in
521    pkclist.c:do_edit_ownertrust() */
522 const char *
523 trust_value_to_string (unsigned int value)
524 {
525   switch( (value & TRUST_MASK) ) 
526     {
527     case TRUST_UNKNOWN:   return _("unknown");
528     case TRUST_EXPIRED:   return _("expired");
529     case TRUST_UNDEFINED: return _("undefined");
530     case TRUST_NEVER:     return _("never");
531     case TRUST_MARGINAL:  return _("marginal");
532     case TRUST_FULLY:     return _("full");
533     case TRUST_ULTIMATE:  return _("ultimate");
534     default:              return "err";
535     }
536 }
537
538 int
539 string_to_trust_value (const char *str)
540 {
541   if(ascii_strcasecmp(str,"undefined")==0)
542     return TRUST_UNDEFINED;
543   else if(ascii_strcasecmp(str,"never")==0)
544     return TRUST_NEVER;
545   else if(ascii_strcasecmp(str,"marginal")==0)
546     return TRUST_MARGINAL;
547   else if(ascii_strcasecmp(str,"full")==0)
548     return TRUST_FULLY;
549   else if(ascii_strcasecmp(str,"ultimate")==0)
550     return TRUST_ULTIMATE;
551   else
552     return -1;
553 }
554
555 /****************
556  * Recreate the WoT but do not ask for new ownertrusts.  Special
557  * feature: In batch mode and without a forced yes, this is only done
558  * when a check is due.  This can be used to run the check from a crontab
559  */
560 void
561 check_trustdb ()
562 {
563   init_trustdb();
564   if(opt.trust_model==TM_PGP || opt.trust_model==TM_CLASSIC)
565     {
566       if (opt.batch && !opt.answer_yes)
567         {
568           ulong scheduled;
569
570           scheduled = tdbio_read_nextcheck ();
571           if (!scheduled)
572             {
573               log_info (_("no need for a trustdb check\n"));
574               return;
575             }
576
577           if (scheduled > make_timestamp ())
578             {
579               log_info (_("next trustdb check due at %s\n"),
580                         strtimestamp (scheduled));
581               return;
582             }
583         }
584
585       validate_keys (0);
586     }
587   else
588     log_info (_("no need for a trustdb check with `%s' trust model\n"),
589               trust_model_string());
590 }
591
592
593 /*
594  * Recreate the WoT. 
595  */
596 void
597 update_trustdb()
598 {
599   init_trustdb();
600   if(opt.trust_model==TM_PGP || opt.trust_model==TM_CLASSIC)
601     validate_keys (1);
602   else
603     log_info (_("no need for a trustdb update with `%s' trust model\n"),
604               trust_model_string());
605 }
606
607 void
608 revalidation_mark (void)
609 {
610   init_trustdb();
611   /* we simply set the time for the next check to 1 (far back in 1970)
612    * so that a --update-trustdb will be scheduled */
613   if (tdbio_write_nextcheck (1))
614       do_sync ();
615   pending_check_trustdb = 1;
616 }
617
618 int
619 trustdb_pending_check(void)
620 {
621   return pending_check_trustdb;
622 }
623
624 void
625 read_trust_options(byte *trust_model,ulong *created,ulong *nextcheck,
626                    byte *marginals,byte *completes,byte *cert_depth)
627 {
628   TRUSTREC opts;
629
630   init_trustdb();
631
632   read_record(0,&opts,RECTYPE_VER);
633
634   if(trust_model)
635     *trust_model=opts.r.ver.trust_model;
636   if(created)
637     *created=opts.r.ver.created;
638   if(nextcheck)
639     *nextcheck=opts.r.ver.nextcheck;
640   if(marginals)
641     *marginals=opts.r.ver.marginals;
642   if(completes)
643     *completes=opts.r.ver.completes;
644   if(cert_depth)
645     *cert_depth=opts.r.ver.cert_depth;
646 }
647
648 /***********************************************
649  ***********  Ownertrust et al. ****************
650  ***********************************************/
651
652 static int 
653 read_trust_record (PKT_public_key *pk, TRUSTREC *rec)
654 {
655   int rc;
656   
657   init_trustdb();
658   rc = tdbio_search_trust_bypk (pk, rec);
659   if (rc == -1)
660     return -1; /* no record yet */
661   if (rc) 
662     {
663       log_error ("trustdb: searching trust record failed: %s\n",
664                  g10_errstr (rc));
665       return rc; 
666     }
667       
668   if (rec->rectype != RECTYPE_TRUST)
669     {
670       log_error ("trustdb: record %lu is not a trust record\n",
671                  rec->recnum);
672       return G10ERR_TRUSTDB; 
673     }      
674   
675   return 0;
676 }
677
678 /****************
679  * Return the assigned ownertrust value for the given public key.
680  * The key should be the primary key.
681  */
682 unsigned int 
683 get_ownertrust ( PKT_public_key *pk)
684 {
685   TRUSTREC rec;
686   int rc;
687   
688   rc = read_trust_record (pk, &rec);
689   if (rc == -1)
690     return TRUST_UNKNOWN; /* no record yet */
691   if (rc) 
692     {
693       tdbio_invalid ();
694       return rc; /* actually never reached */
695     }
696
697   return rec.r.trust.ownertrust;
698 }
699
700 unsigned int 
701 get_min_ownertrust (PKT_public_key *pk)
702 {
703   TRUSTREC rec;
704   int rc;
705   
706   rc = read_trust_record (pk, &rec);
707   if (rc == -1)
708     return TRUST_UNKNOWN; /* no record yet */
709   if (rc) 
710     {
711       tdbio_invalid ();
712       return rc; /* actually never reached */
713     }
714
715   return rec.r.trust.min_ownertrust;
716 }
717
718 /*
719  * Same as get_ownertrust but this takes the minimum ownertrust value
720  * into into account, and will bump up the value as needed.
721  */
722 static int
723 get_ownertrust_with_min (PKT_public_key *pk)
724 {
725   unsigned int otrust,otrust_min;
726
727   otrust = (get_ownertrust (pk) & TRUST_MASK);
728   otrust_min = get_min_ownertrust (pk);
729   if(otrust<otrust_min)
730     {
731       /* If the trust that the user has set is less than the trust
732          that was calculated from a trust signature chain, use the
733          higher of the two.  We do this here and not in
734          get_ownertrust since the underlying ownertrust should not
735          really be set - just the appearance of the ownertrust. */
736
737       otrust=otrust_min;
738     }
739
740   return otrust;
741 }
742
743 /*
744  * Same as get_ownertrust but return a trust letter instead of an
745  * value.  This takes the minimum ownertrust value into account.
746  */
747 int
748 get_ownertrust_info (PKT_public_key *pk)
749 {
750   return trust_letter(get_ownertrust_with_min(pk));
751 }
752
753 /*
754  * Same as get_ownertrust but return a trust string instead of an
755  * value.  This takes the minimum ownertrust value into account.
756  */
757 const char *
758 get_ownertrust_string (PKT_public_key *pk)
759 {
760   return trust_value_to_string(get_ownertrust_with_min(pk));
761 }
762
763 /*
764  * Set the trust value of the given public key to the new value.
765  * The key should be a primary one.
766  */
767 void
768 update_ownertrust (PKT_public_key *pk, unsigned int new_trust )
769 {
770   TRUSTREC rec;
771   int rc;
772   
773   rc = read_trust_record (pk, &rec);
774   if (!rc)
775     {
776       if (DBG_TRUST)
777         log_debug ("update ownertrust from %u to %u\n",
778                    (unsigned int)rec.r.trust.ownertrust, new_trust );
779       if (rec.r.trust.ownertrust != new_trust)
780         {
781           rec.r.trust.ownertrust = new_trust;
782           write_record( &rec );
783           revalidation_mark ();
784           do_sync ();
785         }
786     }
787   else if (rc == -1)
788     { /* no record yet - create a new one */
789       size_t dummy;
790
791       if (DBG_TRUST)
792         log_debug ("insert ownertrust %u\n", new_trust );
793
794       memset (&rec, 0, sizeof rec);
795       rec.recnum = tdbio_new_recnum ();
796       rec.rectype = RECTYPE_TRUST;
797       fingerprint_from_pk (pk, rec.r.trust.fingerprint, &dummy);
798       rec.r.trust.ownertrust = new_trust;
799       write_record (&rec);
800       revalidation_mark ();
801       do_sync ();
802       rc = 0;
803     }
804   else 
805     {
806       tdbio_invalid ();
807     }
808 }
809
810 static void
811 update_min_ownertrust (u32 *kid, unsigned int new_trust )
812 {
813   PKT_public_key *pk;
814   TRUSTREC rec;
815   int rc;
816
817   pk = m_alloc_clear (sizeof *pk);
818   rc = get_pubkey (pk, kid);
819   if (rc)
820     {
821       log_error(_("public key %s not found: %s\n"),keystr(kid),g10_errstr(rc));
822       return;
823     }
824
825   rc = read_trust_record (pk, &rec);
826   if (!rc)
827     {
828       if (DBG_TRUST)
829         log_debug ("key %08lX%08lX: update min_ownertrust from %u to %u\n",
830                    (ulong)kid[0],(ulong)kid[1],
831                    (unsigned int)rec.r.trust.min_ownertrust,
832                    new_trust );
833       if (rec.r.trust.min_ownertrust != new_trust)
834         {
835           rec.r.trust.min_ownertrust = new_trust;
836           write_record( &rec );
837           revalidation_mark ();
838           do_sync ();
839         }
840     }
841   else if (rc == -1)
842     { /* no record yet - create a new one */
843       size_t dummy;
844
845       if (DBG_TRUST)
846         log_debug ("insert min_ownertrust %u\n", new_trust );
847
848       memset (&rec, 0, sizeof rec);
849       rec.recnum = tdbio_new_recnum ();
850       rec.rectype = RECTYPE_TRUST;
851       fingerprint_from_pk (pk, rec.r.trust.fingerprint, &dummy);
852       rec.r.trust.min_ownertrust = new_trust;
853       write_record (&rec);
854       revalidation_mark ();
855       do_sync ();
856       rc = 0;
857     }
858   else 
859     {
860       tdbio_invalid ();
861     }
862 }
863
864 /* Clear the ownertrust and min_ownertrust values.  Return true if a
865    change actually happened. */
866 int
867 clear_ownertrusts (PKT_public_key *pk)
868 {
869   TRUSTREC rec;
870   int rc;
871   
872   rc = read_trust_record (pk, &rec);
873   if (!rc)
874     {
875       if (DBG_TRUST)
876         {
877           log_debug ("clearing ownertrust (old value %u)\n",
878                      (unsigned int)rec.r.trust.ownertrust);
879           log_debug ("clearing min_ownertrust (old value %u)\n",
880                      (unsigned int)rec.r.trust.min_ownertrust);
881         }
882       if (rec.r.trust.ownertrust || rec.r.trust.min_ownertrust)
883         {
884           rec.r.trust.ownertrust = 0;
885           rec.r.trust.min_ownertrust = 0;
886           write_record( &rec );
887           revalidation_mark ();
888           do_sync ();
889           return 1;
890         }
891     }
892   else if (rc != -1)
893     {
894       tdbio_invalid ();
895     }
896   return 0;
897 }
898
899 /* 
900  * Note: Caller has to do a sync 
901  */
902 static void
903 update_validity (PKT_public_key *pk, PKT_user_id *uid,
904                  int depth, int validity)
905 {
906   TRUSTREC trec, vrec;
907   int rc;
908   ulong recno;
909
910   namehash_from_uid(uid);
911
912   rc = read_trust_record (pk, &trec);
913   if (rc && rc != -1)
914     {
915       tdbio_invalid ();
916       return;
917     }
918   if (rc == -1) /* no record yet - create a new one */
919     { 
920       size_t dummy;
921
922       rc = 0;
923       memset (&trec, 0, sizeof trec);
924       trec.recnum = tdbio_new_recnum ();
925       trec.rectype = RECTYPE_TRUST;
926       fingerprint_from_pk (pk, trec.r.trust.fingerprint, &dummy);
927       trec.r.trust.ownertrust = 0;
928       }
929
930   /* locate an existing one */
931   recno = trec.r.trust.validlist;
932   while (recno)
933     {
934       read_record (recno, &vrec, RECTYPE_VALID);
935       if ( !memcmp (vrec.r.valid.namehash, uid->namehash, 20) )
936         break;
937       recno = vrec.r.valid.next;
938     }
939
940   if (!recno) /* insert a new validity record */
941     {
942       memset (&vrec, 0, sizeof vrec);
943       vrec.recnum = tdbio_new_recnum ();
944       vrec.rectype = RECTYPE_VALID;
945       memcpy (vrec.r.valid.namehash, uid->namehash, 20);
946       vrec.r.valid.next = trec.r.trust.validlist;
947       trec.r.trust.validlist = vrec.recnum;
948     }
949   vrec.r.valid.validity = validity;
950   vrec.r.valid.full_count = uid->help_full_count;
951   vrec.r.valid.marginal_count = uid->help_marginal_count;
952   write_record (&vrec);
953   trec.r.trust.depth = depth;
954   write_record (&trec);
955 }
956
957
958 /***********************************************
959  *********  Query trustdb values  **************
960  ***********************************************/
961
962 /* Return true if key is disabled */
963 int
964 cache_disabled_value(PKT_public_key *pk)
965 {
966   int rc;
967   TRUSTREC trec;
968   int disabled=0;
969
970   if(pk->is_disabled)
971     return (pk->is_disabled==2);
972
973   init_trustdb();
974
975   rc = read_trust_record (pk, &trec);
976   if (rc && rc != -1)
977     {
978       tdbio_invalid ();
979       goto leave;
980     }
981   if (rc == -1) /* no record found, so assume not disabled */
982     goto leave;
983  
984   if(trec.r.trust.ownertrust & TRUST_FLAG_DISABLED)
985     disabled=1;
986  
987   /* Cache it for later so we don't need to look at the trustdb every
988      time */
989   if(disabled)
990     pk->is_disabled=2;
991   else
992     pk->is_disabled=1;
993
994  leave:
995    return disabled;
996 }
997
998 void
999 check_trustdb_stale(void)
1000 {
1001   static int did_nextcheck=0;
1002
1003   init_trustdb ();
1004   if (!did_nextcheck
1005       && (opt.trust_model==TM_PGP || opt.trust_model==TM_CLASSIC))
1006     {
1007       ulong scheduled;
1008
1009       did_nextcheck = 1;
1010       scheduled = tdbio_read_nextcheck ();
1011       if (scheduled && scheduled <= make_timestamp ())
1012         {
1013           if (opt.no_auto_check_trustdb) 
1014             {
1015               pending_check_trustdb = 1;
1016               log_info (_("please do a --check-trustdb\n"));
1017             }
1018           else
1019             {
1020               log_info (_("checking the trustdb\n"));
1021               validate_keys (0);
1022             }
1023         }
1024     }
1025 }
1026
1027 /*
1028  * Return the validity information for PK.  If the namehash is not
1029  * NULL, the validity of the corresponsing user ID is returned,
1030  * otherwise, a reasonable value for the entire key is returned. 
1031  */
1032 unsigned int
1033 get_validity (PKT_public_key *pk, PKT_user_id *uid)
1034 {
1035   TRUSTREC trec, vrec;
1036   int rc;
1037   ulong recno;
1038   unsigned int validity;
1039   u32 kid[2];
1040   PKT_public_key *main_pk;
1041
1042   if(uid)
1043     namehash_from_uid(uid);
1044
1045   init_trustdb ();
1046   check_trustdb_stale();
1047
1048   keyid_from_pk (pk, kid);
1049   if (pk->main_keyid[0] != kid[0] || pk->main_keyid[1] != kid[1])
1050     { /* this is a subkey - get the mainkey */
1051       main_pk = m_alloc_clear (sizeof *main_pk);
1052       rc = get_pubkey (main_pk, pk->main_keyid);
1053       if (rc)
1054         {
1055           char *tempkeystr=m_strdup(keystr(pk->main_keyid));
1056           log_error ("error getting main key %s of subkey %s: %s\n",
1057                      tempkeystr, keystr(kid), g10_errstr(rc));
1058           m_free(tempkeystr);
1059           validity = TRUST_UNKNOWN; 
1060           goto leave;
1061         }
1062     }
1063   else
1064     main_pk = pk;
1065
1066   if(opt.trust_model==TM_DIRECT)
1067     {
1068       /* Note that this happens BEFORE any user ID stuff is checked.
1069          The direct trust model applies to keys as a whole. */
1070       validity=get_ownertrust(main_pk);
1071       goto leave;
1072     }
1073
1074   rc = read_trust_record (main_pk, &trec);
1075   if (rc && rc != -1)
1076     {
1077       tdbio_invalid ();
1078       return 0;
1079     }
1080   if (rc == -1) /* no record found */
1081     {
1082       validity = TRUST_UNKNOWN; 
1083       goto leave;
1084     }
1085
1086   /* loop over all user IDs */
1087   recno = trec.r.trust.validlist;
1088   validity = 0;
1089   while (recno)
1090     {
1091       read_record (recno, &vrec, RECTYPE_VALID);
1092
1093       if(uid)
1094         {
1095           /* If a user ID is given we return the validity for that
1096              user ID ONLY.  If the namehash is not found, then there
1097              is no validity at all (i.e. the user ID wasn't
1098              signed). */
1099           if(memcmp(vrec.r.valid.namehash,uid->namehash,20)==0)
1100             {
1101               validity=(vrec.r.valid.validity & TRUST_MASK);
1102               break;
1103             }
1104         }
1105       else
1106         {
1107           /* If no namehash is given, we take the maximum validity
1108              over all user IDs */
1109           if ( validity < (vrec.r.valid.validity & TRUST_MASK) )
1110             validity = (vrec.r.valid.validity & TRUST_MASK);
1111         }
1112
1113       recno = vrec.r.valid.next;
1114     }
1115   
1116   if ( (trec.r.trust.ownertrust & TRUST_FLAG_DISABLED) )
1117     {
1118       validity |= TRUST_FLAG_DISABLED;
1119       pk->is_disabled=2;
1120     }
1121   else
1122     pk->is_disabled=1;
1123
1124  leave:
1125   /* set some flags direct from the key */
1126   if (main_pk->is_revoked)
1127     validity |= TRUST_FLAG_REVOKED;
1128   if (main_pk != pk && pk->is_revoked)
1129     validity |= TRUST_FLAG_SUB_REVOKED;
1130   /* Note: expiration is a trust value and not a flag - don't know why
1131    * I initially designed it that way */
1132   if (main_pk->has_expired || pk->has_expired)
1133     validity = (validity & ~TRUST_MASK) | TRUST_EXPIRED;
1134   
1135   if (pending_check_trustdb)
1136     validity |= TRUST_FLAG_PENDING_CHECK;
1137
1138   if (main_pk != pk)
1139     free_public_key (main_pk);
1140   return validity;
1141 }
1142
1143 int
1144 get_validity_info (PKT_public_key *pk, PKT_user_id *uid)
1145 {
1146     int trustlevel;
1147
1148     trustlevel = get_validity (pk, uid);
1149     if( trustlevel & TRUST_FLAG_REVOKED )
1150         return 'r';
1151     return trust_letter ( trustlevel );
1152 }
1153
1154 const char *
1155 get_validity_string (PKT_public_key *pk, PKT_user_id *uid)
1156 {
1157   int trustlevel;
1158
1159   trustlevel = get_validity (pk, uid);
1160   if( trustlevel & TRUST_FLAG_REVOKED )
1161     return _("revoked");
1162   return trust_value_to_string(trustlevel);
1163 }
1164
1165 static void
1166 get_validity_counts (PKT_public_key *pk, PKT_user_id *uid)
1167 {
1168   TRUSTREC trec, vrec;
1169   ulong recno;
1170
1171   if(pk==NULL || uid==NULL)
1172     BUG();
1173
1174   namehash_from_uid(uid);
1175
1176   uid->help_marginal_count=uid->help_full_count=0;
1177
1178   init_trustdb ();
1179
1180   if(read_trust_record (pk, &trec)!=0)
1181     return;
1182
1183   /* loop over all user IDs */
1184   recno = trec.r.trust.validlist;
1185   while (recno)
1186     {
1187       read_record (recno, &vrec, RECTYPE_VALID);
1188
1189       if(memcmp(vrec.r.valid.namehash,uid->namehash,20)==0)
1190         {
1191           uid->help_marginal_count=vrec.r.valid.marginal_count;
1192           uid->help_full_count=vrec.r.valid.full_count;
1193           /*  printf("Fetched marginal %d, full %d\n",uid->help_marginal_count,uid->help_full_count); */
1194           break;
1195         }
1196
1197       recno = vrec.r.valid.next;
1198     }
1199 }
1200
1201 void
1202 list_trust_path( const char *username )
1203 {
1204 }
1205
1206 /****************
1207  * Enumerate all keys, which are needed to build all trust paths for
1208  * the given key.  This function does not return the key itself or
1209  * the ultimate key (the last point in cerificate chain).  Only
1210  * certificate chains which ends up at an ultimately trusted key
1211  * are listed.  If ownertrust or validity is not NULL, the corresponding
1212  * value for the returned LID is also returned in these variable(s).
1213  *
1214  *  1) create a void pointer and initialize it to NULL
1215  *  2) pass this void pointer by reference to this function.
1216  *     Set lid to the key you want to enumerate and pass it by reference.
1217  *  3) call this function as long as it does not return -1
1218  *     to indicate EOF. LID does contain the next key used to build the web
1219  *  4) Always call this function a last time with LID set to NULL,
1220  *     so that it can free its context.
1221  *
1222  * Returns: -1 on EOF or the level of the returned LID
1223  */
1224 int
1225 enum_cert_paths( void **context, ulong *lid,
1226                  unsigned *ownertrust, unsigned *validity )
1227 {
1228     return -1;
1229 }
1230
1231
1232 /****************
1233  * Print the current path
1234  */
1235 void
1236 enum_cert_paths_print( void **context, FILE *fp,
1237                                        int refresh, ulong selected_lid )
1238 {
1239     return;
1240 }
1241
1242
1243 \f
1244 /****************************************
1245  *********** NEW NEW NEW ****************
1246  ****************************************/
1247
1248 static int
1249 ask_ownertrust (u32 *kid,int minimum)
1250 {
1251   PKT_public_key *pk;
1252   int rc;
1253   int ot;
1254
1255   pk = m_alloc_clear (sizeof *pk);
1256   rc = get_pubkey (pk, kid);
1257   if (rc)
1258     {
1259       log_error (_("public key %s not found: %s\n"),
1260                  keystr(kid), g10_errstr(rc) );
1261       return TRUST_UNKNOWN;
1262     }
1263  
1264   if(opt.force_ownertrust)
1265     {
1266       log_info("force trust for key %s to %s\n",
1267                keystr(kid),trust_value_to_string(opt.force_ownertrust));
1268       update_ownertrust(pk,opt.force_ownertrust);
1269       ot=opt.force_ownertrust;
1270     }
1271   else
1272     {
1273       ot=edit_ownertrust(pk,0);
1274       if(ot>0)
1275         ot = get_ownertrust (pk);
1276       else if(ot==0)
1277         ot = minimum?minimum:TRUST_UNDEFINED;
1278       else
1279         ot = -1; /* quit */
1280     }
1281
1282   free_public_key( pk );
1283
1284   return ot;
1285 }
1286
1287
1288 static void
1289 mark_keyblock_seen (KeyHashTable tbl, KBNODE node)
1290 {
1291   for ( ;node; node = node->next )
1292     if (node->pkt->pkttype == PKT_PUBLIC_KEY
1293         || node->pkt->pkttype == PKT_PUBLIC_SUBKEY)
1294       {
1295         u32 aki[2];
1296
1297         keyid_from_pk (node->pkt->pkt.public_key, aki);
1298         add_key_hash_table (tbl, aki);
1299       }
1300 }
1301
1302
1303 static void
1304 dump_key_array (int depth, struct key_array *keys)
1305 {
1306   struct key_array *kar;
1307
1308   for (kar=keys; kar->keyblock; kar++)
1309     {
1310       KBNODE node = kar->keyblock;
1311       u32 kid[2];
1312
1313       keyid_from_pk(node->pkt->pkt.public_key, kid);
1314       printf ("%d:%08lX%08lX:K::%c::::\n",
1315               depth, (ulong)kid[0], (ulong)kid[1], '?');
1316
1317       for (; node; node = node->next)
1318         {
1319           if (node->pkt->pkttype == PKT_USER_ID)
1320             {
1321               int len = node->pkt->pkt.user_id->len;
1322
1323               if (len > 30)
1324                 len = 30;
1325               printf ("%d:%08lX%08lX:U:::%c:::",
1326                       depth, (ulong)kid[0], (ulong)kid[1],
1327                       (node->flag & 4)? 'f':
1328                       (node->flag & 2)? 'm':
1329                       (node->flag & 1)? 'q':'-');
1330               print_string (stdout,  node->pkt->pkt.user_id->name, len, ':');
1331               putchar (':');
1332               putchar ('\n');
1333             }
1334         }
1335     }
1336 }  
1337
1338
1339 static void
1340 store_validation_status (int depth, KBNODE keyblock, KeyHashTable stored)
1341 {
1342   KBNODE node;
1343   int status;
1344   int any = 0;
1345
1346   for (node=keyblock; node; node = node->next)
1347     {
1348       if (node->pkt->pkttype == PKT_USER_ID)
1349         {
1350           PKT_user_id *uid = node->pkt->pkt.user_id;
1351           if (node->flag & 4)
1352             status = TRUST_FULLY;
1353           else if (node->flag & 2)
1354             status = TRUST_MARGINAL;
1355           else if (node->flag & 1)
1356             status = TRUST_UNDEFINED;
1357           else
1358             status = 0;
1359           
1360           if (status)
1361             {
1362               update_validity (keyblock->pkt->pkt.public_key,
1363                                uid, depth, status);
1364
1365               mark_keyblock_seen(stored,keyblock);
1366
1367               any = 1;
1368             }
1369         }
1370     }
1371
1372   if (any)
1373     do_sync ();
1374 }  
1375
1376 /*
1377  * check whether the signature sig is in the klist k
1378  */
1379 static struct key_item *
1380 is_in_klist (struct key_item *k, PKT_signature *sig)
1381 {
1382   for (; k; k = k->next)
1383     {
1384       if (k->kid[0] == sig->keyid[0] && k->kid[1] == sig->keyid[1])
1385         return k;
1386     }
1387   return NULL;
1388 }
1389
1390 /*
1391  * Mark the signature of the given UID which are used to certify it.
1392  * To do this, we first revmove all signatures which are not valid and
1393  * from the remain ones we look for the latest one.  If this is not a
1394  * certification revocation signature we mark the signature by setting
1395  * node flag bit 8.  Note that flag bits 9 and 10 are used for internal
1396  * purposes.  
1397  */
1398 static void
1399 mark_usable_uid_certs (KBNODE keyblock, KBNODE uidnode,
1400                        u32 *main_kid, struct key_item *klist,
1401                        u32 curtime, u32 *next_expire)
1402 {
1403   KBNODE node;
1404   PKT_signature *sig;
1405   
1406   /* first check all signatures */
1407   for (node=uidnode->next; node; node = node->next)
1408     {
1409       node->flag &= ~(1<<8 | 1<<9 | 1<<10);
1410       if (node->pkt->pkttype == PKT_USER_ID
1411           || node->pkt->pkttype == PKT_PUBLIC_SUBKEY)
1412         break; /* ready */
1413       if (node->pkt->pkttype != PKT_SIGNATURE)
1414         continue;
1415       
1416       sig = node->pkt->pkt.signature;
1417       if (sig->keyid[0] == main_kid[0] && sig->keyid[1] == main_kid[1])
1418         continue; /* ignore self-signatures */
1419       if (!IS_UID_SIG(sig) && !IS_UID_REV(sig))
1420         continue; /* we only look at these signature classes */
1421       if(sig->sig_class>=0x11 && sig->sig_class<=0x13 &&
1422          sig->sig_class-0x10<opt.min_cert_level)
1423         continue;
1424       if (!is_in_klist (klist, sig))
1425         continue;  /* no need to check it then */
1426       if (check_key_signature (keyblock, node, NULL))
1427         continue; /* ignore invalid signatures */
1428       node->flag |= 1<<9;
1429     }      
1430   /* reset the remaining flags */
1431   for (; node; node = node->next)
1432       node->flag &= ~(1<<8 | 1<<9 | 1 << 10);
1433
1434   /* kbnode flag usage: bit 9 is here set for signatures to consider,
1435    * bit 10 will be set by the loop to keep track of keyIDs already
1436    * processed, bit 8 will be set for the usable signatures */
1437
1438   /* for each cert figure out the latest valid one */
1439   for (node=uidnode->next; node; node = node->next)
1440     {
1441       KBNODE n, signode;
1442       u32 kid[2];
1443       u32 sigdate;
1444       
1445       if (node->pkt->pkttype == PKT_PUBLIC_SUBKEY)
1446         break;
1447       if ( !(node->flag & (1<<9)) )
1448         continue; /* not a node to look at */
1449       if ( (node->flag & (1<<10)) )
1450         continue; /* signature with a keyID already processed */
1451       node->flag |= (1<<10); /* mark this node as processed */
1452       sig = node->pkt->pkt.signature;
1453       signode = node;
1454       sigdate = sig->timestamp;
1455       kid[0] = sig->keyid[0]; kid[1] = sig->keyid[1];
1456       for (n=uidnode->next; n; n = n->next)
1457         {
1458           if (n->pkt->pkttype == PKT_PUBLIC_SUBKEY)
1459             break;
1460           if ( !(n->flag & (1<<9)) )
1461             continue;
1462           if ( (n->flag & (1<<10)) )
1463             continue; /* shortcut already processed signatures */
1464           sig = n->pkt->pkt.signature;
1465           if (kid[0] != sig->keyid[0] || kid[1] != sig->keyid[1])
1466             continue;
1467           n->flag |= (1<<10); /* mark this node as processed */
1468
1469           /* If signode is nonrevocable and unexpired and n isn't,
1470              then take signode (skip).  It doesn't matter which is
1471              older: if signode was older then we don't want to take n
1472              as signode is nonrevocable.  If n was older then we're
1473              automatically fine. */
1474           
1475           if(((IS_UID_SIG(signode->pkt->pkt.signature) &&
1476                !signode->pkt->pkt.signature->flags.revocable &&
1477                (signode->pkt->pkt.signature->expiredate==0 ||
1478                 signode->pkt->pkt.signature->expiredate>curtime))) &&
1479              (!(IS_UID_SIG(n->pkt->pkt.signature) &&
1480                 !n->pkt->pkt.signature->flags.revocable &&
1481                 (n->pkt->pkt.signature->expiredate==0 ||
1482                  n->pkt->pkt.signature->expiredate>curtime))))
1483             continue;
1484
1485           /* If n is nonrevocable and unexpired and signode isn't,
1486              then take n.  Again, it doesn't matter which is older: if
1487              n was older then we don't want to take signode as n is
1488              nonrevocable.  If signode was older then we're
1489              automatically fine. */
1490           
1491           if((!(IS_UID_SIG(signode->pkt->pkt.signature) &&
1492                 !signode->pkt->pkt.signature->flags.revocable &&
1493                 (signode->pkt->pkt.signature->expiredate==0 ||
1494                  signode->pkt->pkt.signature->expiredate>curtime))) &&
1495              ((IS_UID_SIG(n->pkt->pkt.signature) &&
1496                !n->pkt->pkt.signature->flags.revocable &&
1497                (n->pkt->pkt.signature->expiredate==0 ||
1498                 n->pkt->pkt.signature->expiredate>curtime))))
1499             {
1500               signode = n;
1501               sigdate = sig->timestamp;
1502               continue;
1503             }
1504
1505           /* At this point, if it's newer, it goes in as the only
1506              remaining possibilities are signode and n are both either
1507              revocable or expired or both nonrevocable and unexpired.
1508              If the timestamps are equal take the later ordered
1509              packet, presuming that the key packets are hopefully in
1510              their original order. */
1511
1512           if (sig->timestamp >= sigdate)
1513             {
1514               signode = n;
1515               sigdate = sig->timestamp;
1516             }
1517         }
1518       sig = signode->pkt->pkt.signature;
1519       if (IS_UID_SIG (sig))
1520         { /* this seems to be a usable one which is not revoked. 
1521            * Just need to check whether there is an expiration time,
1522            * We do the expired certification after finding a suitable
1523            * certification, the assumption is that a signator does not
1524            * want that after the expiration of his certificate the
1525            * system falls back to an older certification which has a
1526            * different expiration time */
1527           const byte *p;
1528           u32 expire;
1529                     
1530           p = parse_sig_subpkt (sig->hashed, SIGSUBPKT_SIG_EXPIRE, NULL );
1531           expire = p? sig->timestamp + buffer_to_u32(p) : 0;
1532
1533           if (expire==0 || expire > curtime )
1534             {
1535               signode->flag |= (1<<8); /* yeah, found a good cert */
1536               if (expire && expire < *next_expire)
1537                 *next_expire = expire;
1538             }
1539         }
1540     }
1541 }
1542
1543 /* Used by validate_one_keyblock to confirm a regexp within a trust
1544    signature.  Returns 1 for match, and 0 for no match or regex
1545    error. */
1546 static int
1547 check_regexp(const char *expr,const char *string)
1548 {
1549 #ifdef DISABLE_REGEX
1550   /* When DISABLE_REGEX is defined, assume all regexps do not
1551      match. */
1552   return 0;
1553 #elif defined(__riscos__)
1554   return riscos_check_regexp(expr, string, DBG_TRUST);
1555 #else
1556   int ret;
1557   regex_t pat;
1558
1559   if(regcomp(&pat,expr,REG_ICASE|REG_NOSUB|REG_EXTENDED)!=0)
1560     return 0;
1561
1562   ret=regexec(&pat,string,0,NULL,0);
1563
1564   regfree(&pat);
1565
1566   if(DBG_TRUST)
1567     log_debug("regexp `%s' on `%s': %s\n",expr,string,ret==0?"YES":"NO");
1568
1569   return (ret==0);
1570 #endif
1571 }
1572
1573 /*
1574  * Return true if the key is signed by one of the keys in the given
1575  * key ID list.  User IDs with a valid signature are marked by node
1576  * flags as follows:
1577  *  flag bit 0: There is at least one signature
1578  *           1: There is marginal confidence that this is a legitimate uid
1579  *           2: There is full confidence that this is a legitimate uid.
1580  *           8: Used for internal purposes.
1581  *           9: Ditto (in mark_usable_uid_certs())
1582  *          10: Ditto (ditto)
1583  * This function assumes that all kbnode flags are cleared on entry.
1584  */
1585 static int
1586 validate_one_keyblock (KBNODE kb, struct key_item *klist,
1587                        u32 curtime, u32 *next_expire)
1588 {
1589   struct key_item *kr;
1590   KBNODE node, uidnode=NULL;
1591   PKT_user_id *uid=NULL;
1592   PKT_public_key *pk = kb->pkt->pkt.public_key;
1593   u32 main_kid[2];
1594   int issigned=0, any_signed = 0;
1595
1596   keyid_from_pk(pk, main_kid);
1597   for (node=kb; node; node = node->next)
1598     {
1599       /* A bit of discussion here: is it better for the web of trust
1600          to be built among only self-signed uids?  On the one hand, a
1601          self-signed uid is a statement that the key owner definitely
1602          intended that uid to be there, but on the other hand, a
1603          signed (but not self-signed) uid does carry trust, of a sort,
1604          even if it is a statement being made by people other than the
1605          key owner "through" the uids on the key owner's key.  I'm
1606          going with the latter.  However, if the user ID was
1607          explicitly revoked, or passively allowed to expire, that
1608          should stop validity through the user ID until it is
1609          resigned.  -dshaw */
1610
1611       if (node->pkt->pkttype == PKT_USER_ID
1612           && !node->pkt->pkt.user_id->is_revoked
1613           && !node->pkt->pkt.user_id->is_expired)
1614         {
1615           if (uidnode && issigned)
1616             {
1617               if (uid->help_full_count >= opt.completes_needed
1618                   || uid->help_marginal_count >= opt.marginals_needed )
1619                 uidnode->flag |= 4; 
1620               else if (uid->help_full_count || uid->help_marginal_count)
1621                 uidnode->flag |= 2;
1622               uidnode->flag |= 1;
1623               any_signed = 1;
1624             }
1625           uidnode = node;
1626           uid=uidnode->pkt->pkt.user_id;
1627
1628           /* If the selfsig is going to expire... */
1629           if(uid->expiredate && uid->expiredate<*next_expire)
1630             *next_expire = uid->expiredate;
1631
1632           issigned = 0;
1633           get_validity_counts(pk,uid);
1634           mark_usable_uid_certs (kb, uidnode, main_kid, klist, 
1635                                  curtime, next_expire);
1636         }
1637       else if (node->pkt->pkttype == PKT_SIGNATURE
1638                && (node->flag & (1<<8)) && uid)
1639         {
1640           /* Note that we are only seeing unrevoked sigs here */
1641           PKT_signature *sig = node->pkt->pkt.signature;
1642           
1643           kr = is_in_klist (klist, sig);
1644           /* If the trust_regexp does not match, it's as if the sig
1645              did not exist.  This is safe for non-trust sigs as well
1646              since we don't accept a regexp on the sig unless it's a
1647              trust sig. */
1648           if (kr && (kr->trust_regexp==NULL || opt.trust_model!=TM_PGP ||
1649                      (uidnode && check_regexp(kr->trust_regexp,
1650                                             uidnode->pkt->pkt.user_id->name))))
1651             {
1652               if(DBG_TRUST && opt.trust_model==TM_PGP && sig->trust_depth)
1653                 log_debug("trust sig on %s, sig depth is %d, kr depth is %d\n",
1654                           uidnode->pkt->pkt.user_id->name,sig->trust_depth,
1655                           kr->trust_depth);
1656
1657               /* Are we part of a trust sig chain?  We always favor
1658                  the latest trust sig, rather than the greater or
1659                  lesser trust sig or value.  I could make a decent
1660                  argument for any of these cases, but this seems to be
1661                  what PGP does, and I'd like to be compatible. -dms */
1662               if(opt.trust_model==TM_PGP && sig->trust_depth
1663                  && pk->trust_timestamp<=sig->timestamp
1664                  && (sig->trust_depth<=kr->trust_depth
1665                      || kr->ownertrust==TRUST_ULTIMATE))
1666                 {
1667                   /* If we got here, we know that:
1668
1669                      this is a trust sig.
1670
1671                      it's a newer trust sig than any previous trust
1672                      sig on this key (not uid).
1673
1674                      it is legal in that it was either generated by an
1675                      ultimate key, or a key that was part of a trust
1676                      chain, and the depth does not violate the
1677                      original trust sig.
1678
1679                      if there is a regexp attached, it matched
1680                      successfully.
1681                   */
1682
1683                   if(DBG_TRUST)
1684                     log_debug("replacing trust value %d with %d and "
1685                               "depth %d with %d\n",
1686                               pk->trust_value,sig->trust_value,
1687                               pk->trust_depth,sig->trust_depth);
1688
1689                   pk->trust_value=sig->trust_value;
1690                   pk->trust_depth=sig->trust_depth-1;
1691
1692                   /* If the trust sig contains a regexp, record it
1693                      on the pk for the next round. */
1694                   if(sig->trust_regexp)
1695                     pk->trust_regexp=sig->trust_regexp;
1696                 }
1697
1698               if (kr->ownertrust == TRUST_ULTIMATE)
1699                 uid->help_full_count = opt.completes_needed;
1700               else if (kr->ownertrust == TRUST_FULLY)
1701                 uid->help_full_count++;
1702               else if (kr->ownertrust == TRUST_MARGINAL)
1703                 uid->help_marginal_count++;
1704               issigned = 1;
1705             }
1706         }
1707     }
1708
1709   if (uidnode && issigned)
1710     {
1711       if (uid->help_full_count >= opt.completes_needed
1712           || uid->help_marginal_count >= opt.marginals_needed )
1713         uidnode->flag |= 4; 
1714       else if (uid->help_full_count || uid->help_marginal_count)
1715         uidnode->flag |= 2;
1716       uidnode->flag |= 1;
1717       any_signed = 1;
1718     }
1719
1720   return any_signed;
1721 }
1722
1723
1724 static int
1725 search_skipfnc (void *opaque, u32 *kid, PKT_user_id *dummy)
1726 {
1727   return test_key_hash_table ((KeyHashTable)opaque, kid);
1728 }
1729
1730
1731 /*
1732  * Scan all keys and return a key_array of all suitable keys from
1733  * kllist.  The caller has to pass keydb handle so that we don't use
1734  * to create our own.  Returns either a key_array or NULL in case of
1735  * an error.  No results found are indicated by an empty array.
1736  * Caller hast to release the returned array.  
1737  */
1738 static struct key_array *
1739 validate_key_list (KEYDB_HANDLE hd, KeyHashTable full_trust,
1740                    struct key_item *klist, u32 curtime, u32 *next_expire)
1741 {
1742   KBNODE keyblock = NULL;
1743   struct key_array *keys = NULL;
1744   size_t nkeys, maxkeys;
1745   int rc;
1746   KEYDB_SEARCH_DESC desc;
1747   
1748   maxkeys = 1000;
1749   keys = m_alloc ((maxkeys+1) * sizeof *keys);
1750   nkeys = 0;
1751   
1752   rc = keydb_search_reset (hd);
1753   if (rc)
1754     {
1755       log_error ("keydb_search_reset failed: %s\n", g10_errstr(rc));
1756       m_free (keys);
1757       return NULL;
1758     }
1759
1760   memset (&desc, 0, sizeof desc);
1761   desc.mode = KEYDB_SEARCH_MODE_FIRST;
1762   desc.skipfnc = search_skipfnc;
1763   desc.skipfncvalue = full_trust;
1764   rc = keydb_search (hd, &desc, 1);
1765   if (rc == -1)
1766     {
1767       keys[nkeys].keyblock = NULL;
1768       return keys;
1769     }
1770   if (rc)
1771     {
1772       log_error ("keydb_search_first failed: %s\n", g10_errstr(rc));
1773       m_free (keys);
1774       return NULL;
1775     }
1776   
1777   desc.mode = KEYDB_SEARCH_MODE_NEXT; /* change mode */
1778   do
1779     {
1780       PKT_public_key *pk;
1781         
1782       rc = keydb_get_keyblock (hd, &keyblock);
1783       if (rc) 
1784         {
1785           log_error ("keydb_get_keyblock failed: %s\n", g10_errstr(rc));
1786           m_free (keys);
1787           return NULL;
1788         }
1789       
1790       if ( keyblock->pkt->pkttype != PKT_PUBLIC_KEY) 
1791         {
1792           log_debug ("ooops: invalid pkttype %d encountered\n",
1793                      keyblock->pkt->pkttype);
1794           dump_kbnode (keyblock);
1795           release_kbnode(keyblock);
1796           continue;
1797         }
1798
1799       /* prepare the keyblock for further processing */
1800       merge_keys_and_selfsig (keyblock); 
1801       clear_kbnode_flags (keyblock);
1802       pk = keyblock->pkt->pkt.public_key;
1803       if (pk->has_expired || pk->is_revoked)
1804         {
1805           /* it does not make sense to look further at those keys */
1806           mark_keyblock_seen (full_trust, keyblock);
1807         }
1808       else if (validate_one_keyblock (keyblock, klist, curtime, next_expire))
1809         {
1810           KBNODE node;
1811
1812           if (pk->expiredate && pk->expiredate >= curtime
1813               && pk->expiredate < *next_expire)
1814             *next_expire = pk->expiredate;
1815
1816           if (nkeys == maxkeys) {
1817             maxkeys += 1000;
1818             keys = m_realloc (keys, (maxkeys+1) * sizeof *keys);
1819           }
1820           keys[nkeys++].keyblock = keyblock;
1821
1822           /* Optimization - if all uids are fully trusted, then we
1823              never need to consider this key as a candidate again. */
1824
1825           for (node=keyblock; node; node = node->next)
1826             if (node->pkt->pkttype == PKT_USER_ID && !(node->flag & 4))
1827               break;
1828
1829           if(node==NULL)
1830             mark_keyblock_seen (full_trust, keyblock);
1831
1832           keyblock = NULL;
1833         }
1834
1835       release_kbnode (keyblock);
1836       keyblock = NULL;
1837     } 
1838   while ( !(rc = keydb_search (hd, &desc, 1)) );
1839   if (rc && rc != -1) 
1840     {
1841       log_error ("keydb_search_next failed: %s\n", g10_errstr(rc));
1842       m_free (keys);
1843       return NULL;
1844     }
1845
1846   keys[nkeys].keyblock = NULL;
1847   return keys;
1848
1849
1850 /* Caller must sync */
1851 static void
1852 reset_trust_records(void)
1853 {
1854   TRUSTREC rec;
1855   ulong recnum;
1856   int count = 0, nreset = 0;
1857
1858   for (recnum=1; !tdbio_read_record (recnum, &rec, 0); recnum++ ) 
1859     {
1860       if(rec.rectype==RECTYPE_TRUST)
1861         {
1862           count++;
1863           if(rec.r.trust.min_ownertrust)
1864             {
1865               rec.r.trust.min_ownertrust=0;
1866               write_record(&rec);
1867             }
1868
1869         }
1870       else if(rec.rectype==RECTYPE_VALID
1871               && ((rec.r.valid.validity&TRUST_MASK)
1872                   || rec.r.valid.marginal_count
1873                   || rec.r.valid.full_count))
1874         {
1875           rec.r.valid.validity &= ~TRUST_MASK;
1876           rec.r.valid.marginal_count=rec.r.valid.full_count=0;
1877           nreset++;
1878           write_record(&rec);
1879         }
1880
1881     }
1882
1883   if (opt.verbose)
1884     log_info (_("%d keys processed (%d validity counts cleared)\n"),
1885               count, nreset);
1886 }
1887
1888 /*
1889  * Run the key validation procedure.
1890  *
1891  * This works this way:
1892  * Step 1: Find all ultimately trusted keys (UTK).
1893  *         mark them all as seen and put them into klist.
1894  * Step 2: loop max_cert_times
1895  * Step 3:   if OWNERTRUST of any key in klist is undefined
1896  *             ask user to assign ownertrust
1897  * Step 4:   Loop over all keys in the keyDB which are not marked seen 
1898  * Step 5:     if key is revoked or expired
1899  *                mark key as seen
1900  *                continue loop at Step 4
1901  * Step 6:     For each user ID of that key signed by a key in klist
1902  *                Calculate validity by counting trusted signatures.
1903  *                Set validity of user ID
1904  * Step 7:     If any signed user ID was found
1905  *                mark key as seen
1906  *             End Loop
1907  * Step 8:   Build a new klist from all fully trusted keys from step 6
1908  *           End Loop
1909  *         Ready  
1910  *
1911  */
1912 static int
1913 validate_keys (int interactive)
1914 {
1915   int rc = 0;
1916   int quit=0;
1917   struct key_item *klist = NULL;
1918   struct key_item *k;
1919   struct key_array *keys = NULL;
1920   struct key_array *kar;
1921   KEYDB_HANDLE kdb = NULL;
1922   KBNODE node;
1923   int depth;
1924   int ot_unknown, ot_undefined, ot_never, ot_marginal, ot_full, ot_ultimate;
1925   KeyHashTable stored,used,full_trust;
1926   u32 start_time, next_expire;
1927
1928   /* Make sure we have all sigs cached.  TODO: This is going to
1929      require some architectual re-thinking, as it is agonizingly slow.
1930      Perhaps combine this with reset_trust_records(), or only check
1931      the caches on keys that are actually involved in the web of
1932      trust. */
1933   keydb_rebuild_caches(0);
1934
1935   start_time = make_timestamp ();
1936   next_expire = 0xffffffff; /* set next expire to the year 2106 */
1937   stored = new_key_hash_table ();
1938   used = new_key_hash_table ();
1939   full_trust = new_key_hash_table ();
1940
1941   kdb = keydb_new (0);
1942   reset_trust_records();
1943
1944   /* Fixme: Instead of always building a UTK list, we could just build it
1945    * here when needed */
1946   if (!utk_list)
1947     {
1948       log_info (_("no ultimately trusted keys found\n"));
1949       goto leave;
1950     }
1951
1952   /* mark all UTKs as used and fully_trusted and set validity to
1953      ultimate */
1954   for (k=utk_list; k; k = k->next)
1955     {
1956       KBNODE keyblock;
1957       PKT_public_key *pk;
1958
1959       keyblock = get_pubkeyblock (k->kid);
1960       if (!keyblock)
1961         {
1962           log_error (_("public key of ultimately"
1963                        " trusted key %s not found\n"), keystr(k->kid));
1964           continue;
1965         }
1966       mark_keyblock_seen (used, keyblock);
1967       mark_keyblock_seen (stored, keyblock);
1968       mark_keyblock_seen (full_trust, keyblock);
1969       pk = keyblock->pkt->pkt.public_key;
1970       for (node=keyblock; node; node = node->next)
1971         {
1972           if (node->pkt->pkttype == PKT_USER_ID)
1973             update_validity (pk, node->pkt->pkt.user_id, 0, TRUST_ULTIMATE);
1974         }
1975       if ( pk->expiredate && pk->expiredate >= start_time
1976            && pk->expiredate < next_expire)
1977         next_expire = pk->expiredate;
1978       
1979       release_kbnode (keyblock);
1980       do_sync ();
1981     }
1982
1983   klist = utk_list;
1984
1985   log_info(_("%d marginal(s) needed, %d complete(s) needed, %s trust model\n"),
1986            opt.marginals_needed,opt.completes_needed,trust_model_string());
1987
1988   for (depth=0; depth < opt.max_cert_depth; depth++)
1989     {
1990       int valids=0,key_count;
1991       /* See whether we should assign ownertrust values to the keys in
1992          klist.  */
1993       ot_unknown = ot_undefined = ot_never = 0;
1994       ot_marginal = ot_full = ot_ultimate = 0;
1995       for (k=klist; k; k = k->next)
1996         {
1997           int min=0;
1998
1999           /* 120 and 60 are as per RFC2440 */
2000           if(k->trust_value>=120)
2001             min=TRUST_FULLY;
2002           else if(k->trust_value>=60)
2003             min=TRUST_MARGINAL;
2004
2005           if(min!=k->min_ownertrust)
2006             update_min_ownertrust(k->kid,min);
2007
2008           if (interactive && k->ownertrust == TRUST_UNKNOWN)
2009             {
2010               k->ownertrust = ask_ownertrust (k->kid,min);
2011
2012               if (k->ownertrust == -1)
2013                 {
2014                   quit=1;
2015                   goto leave;
2016                 }
2017             }
2018
2019           /* This can happen during transition from an old trustdb
2020              before trust sigs.  It can also happen if a user uses two
2021              different versions of GnuPG or changes the --trust-model
2022              setting. */
2023           if(k->ownertrust<min)
2024             {
2025               if(DBG_TRUST)
2026                 log_debug("key %08lX%08lX:"
2027                           " overriding ownertrust `%s' with `%s'\n",
2028                           (ulong)k->kid[0],(ulong)k->kid[1],
2029                           trust_value_to_string(k->ownertrust),
2030                           trust_value_to_string(min));
2031
2032               k->ownertrust=min;
2033             }
2034
2035           if (k->ownertrust == TRUST_UNKNOWN)
2036             ot_unknown++;
2037           else if (k->ownertrust == TRUST_UNDEFINED)
2038             ot_undefined++;
2039           else if (k->ownertrust == TRUST_NEVER)
2040             ot_never++;
2041           else if (k->ownertrust == TRUST_MARGINAL)
2042             ot_marginal++;
2043           else if (k->ownertrust == TRUST_FULLY)
2044             ot_full++;
2045           else if (k->ownertrust == TRUST_ULTIMATE)
2046             ot_ultimate++;
2047
2048           valids++;
2049         }
2050
2051       /* Find all keys which are signed by a key in kdlist */
2052       keys = validate_key_list (kdb, full_trust, klist,
2053                                 start_time, &next_expire);
2054       if (!keys) 
2055         {
2056           log_error ("validate_key_list failed\n");
2057           rc = G10ERR_GENERAL;
2058           goto leave;
2059         }
2060
2061       for (key_count=0, kar=keys; kar->keyblock; kar++, key_count++)
2062         ;
2063
2064       /* Store the calculated valididation status somewhere */
2065       if (opt.verbose > 1)
2066         dump_key_array (depth, keys);
2067
2068       for (kar=keys; kar->keyblock; kar++)
2069           store_validation_status (depth, kar->keyblock, stored);
2070
2071       log_info (_("depth: %d  valid: %3d  signed: %3d"
2072                   "  trust: %d-, %dq, %dn, %dm, %df, %du\n"), 
2073                 depth, valids, key_count, ot_unknown, ot_undefined,
2074                 ot_never, ot_marginal, ot_full, ot_ultimate ); 
2075
2076       /* Build a new kdlist from all fully valid keys in KEYS */
2077       if (klist != utk_list)
2078         release_key_items (klist);
2079       klist = NULL;
2080       for (kar=keys; kar->keyblock; kar++)
2081         {
2082           for (node=kar->keyblock; node; node = node->next)
2083             {
2084               if (node->pkt->pkttype == PKT_USER_ID && (node->flag & 4))
2085                 {
2086                   u32 kid[2];
2087
2088                   /* have we used this key already? */
2089                   keyid_from_pk (kar->keyblock->pkt->pkt.public_key, kid);
2090                   if(test_key_hash_table(used,kid)==0)
2091                     {
2092                       /* Normally we add both the primary and subkey
2093                          ids to the hash via mark_keyblock_seen, but
2094                          since we aren't using this hash as a skipfnc,
2095                          that doesn't matter here. */
2096                       add_key_hash_table (used,kid);
2097                       k = new_key_item ();
2098                       k->kid[0]=kid[0];
2099                       k->kid[1]=kid[1];
2100                       k->ownertrust =
2101                         (get_ownertrust (kar->keyblock->pkt->pkt.public_key)
2102                          & TRUST_MASK);
2103                       k->min_ownertrust =
2104                         get_min_ownertrust(kar->keyblock->pkt->pkt.public_key);
2105                       k->trust_depth=
2106                         kar->keyblock->pkt->pkt.public_key->trust_depth;
2107                       k->trust_value=
2108                         kar->keyblock->pkt->pkt.public_key->trust_value;
2109                       if(kar->keyblock->pkt->pkt.public_key->trust_regexp)
2110                         k->trust_regexp=
2111                           m_strdup(kar->keyblock->pkt->
2112                                    pkt.public_key->trust_regexp);
2113                       k->next = klist;
2114                       klist = k;
2115                       break;
2116                     }
2117                 }
2118             }
2119         }
2120       release_key_array (keys);
2121       keys = NULL;
2122       if (!klist)
2123         break; /* no need to dive in deeper */
2124     }
2125
2126  leave:
2127   keydb_release (kdb);
2128   release_key_array (keys);
2129   release_key_items (klist);
2130   release_key_hash_table (full_trust);
2131   release_key_hash_table (used);
2132   release_key_hash_table (stored);
2133   if (!rc && !quit) /* mark trustDB as checked */
2134     {
2135       if (next_expire == 0xffffffff || next_expire < start_time )
2136         tdbio_write_nextcheck (0); 
2137       else
2138         {
2139           tdbio_write_nextcheck (next_expire); 
2140           log_info (_("next trustdb check due at %s\n"),
2141                     strtimestamp (next_expire));
2142         }
2143
2144       if(tdbio_update_version_record()!=0)
2145         {
2146           log_error(_("unable to update trustdb version record: "
2147                       "write failed: %s\n"), g10_errstr(rc));
2148           tdbio_invalid();
2149         }
2150
2151       do_sync ();
2152       pending_check_trustdb = 0;
2153     }
2154
2155   return rc;
2156 }