gpg: Emit FAILURE stati now in almost all cases.
[gnupg.git] / g10 / trust.c
1 /* trust.c - High level trust functions
2  * Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007,
3  *               2008, 2012 Free Software Foundation, Inc.
4  * Copyright (C) 2014 Werner Koch
5  *
6  * This file is part of GnuPG.
7  *
8  * GnuPG is free software; you can redistribute it and/or modify
9  * it under the terms of the GNU General Public License as published by
10  * the Free Software Foundation; either version 3 of the License, or
11  * (at your option) any later version.
12  *
13  * GnuPG is distributed in the hope that it will be useful,
14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
16  * GNU General Public License for more details.
17  *
18  * You should have received a copy of the GNU General Public License
19  * along with this program; if not, see <https://www.gnu.org/licenses/>.
20  */
21
22 #include <config.h>
23 #include <stdio.h>
24 #include <stdlib.h>
25 #include <string.h>
26
27 #include "gpg.h"
28 #include "keydb.h"
29 #include "../common/util.h"
30 #include "options.h"
31 #include "packet.h"
32 #include "main.h"
33 #include "../common/i18n.h"
34 #include "trustdb.h"
35 #include "../common/host2net.h"
36
37
38 /* Return true if key is disabled.  Note that this is usually used via
39    the pk_is_disabled macro.  */
40 int
41 cache_disabled_value (ctrl_t ctrl, PKT_public_key *pk)
42 {
43 #ifdef NO_TRUST_MODELS
44   (void)pk;
45   return 0;
46 #else
47   return tdb_cache_disabled_value (ctrl, pk);
48 #endif
49 }
50
51
52 void
53 register_trusted_keyid (u32 *keyid)
54 {
55 #ifdef NO_TRUST_MODELS
56   (void)keyid;
57 #else
58   tdb_register_trusted_keyid (keyid);
59 #endif
60 }
61
62
63 void
64 register_trusted_key (const char *string)
65 {
66 #ifdef NO_TRUST_MODELS
67   (void)string;
68 #else
69
70   /* Some users have conf files with entries like
71    *   trusted-key 0x1234567812345678    # foo
72    * That is obviously wrong.  Before fixing bug#1206 trailing garbage
73    * on a key specification if was ignored.  We detect the above use case
74    * here and  cut off the junk-looking-like-a comment.  */
75   if (strchr (string, '#'))
76     {
77       char *buf;
78
79       buf = xtrystrdup (string);
80       if (buf)
81         {
82           *strchr (buf, '#') = 0;
83           tdb_register_trusted_key (buf);
84           xfree (buf);
85           return;
86         }
87     }
88
89   tdb_register_trusted_key (string);
90 #endif
91 }
92
93
94 \f
95 /*
96  * This function returns a letter for a trust value.  Trust flags
97  * are ignored.
98  */
99 static int
100 trust_letter (unsigned int value)
101 {
102   switch( (value & TRUST_MASK) )
103     {
104     case TRUST_UNKNOWN:   return '-';
105     case TRUST_EXPIRED:   return 'e';
106     case TRUST_UNDEFINED: return 'q';
107     case TRUST_NEVER:     return 'n';
108     case TRUST_MARGINAL:  return 'm';
109     case TRUST_FULLY:     return 'f';
110     case TRUST_ULTIMATE:  return 'u';
111     default:              return '?';
112     }
113 }
114
115
116 /* The strings here are similar to those in
117    pkclist.c:do_edit_ownertrust() */
118 const char *
119 trust_value_to_string (unsigned int value)
120 {
121   switch ((value & TRUST_MASK))
122     {
123     case TRUST_UNKNOWN:   return _("unknown");
124     case TRUST_EXPIRED:   return _("expired");
125     case TRUST_UNDEFINED: return _("undefined");
126     case TRUST_NEVER:     return _("never");
127     case TRUST_MARGINAL:  return _("marginal");
128     case TRUST_FULLY:     return _("full");
129     case TRUST_ULTIMATE:  return _("ultimate");
130     default:              return "err";
131     }
132 }
133
134
135 int
136 string_to_trust_value (const char *str)
137 {
138   if (!ascii_strcasecmp (str, "undefined"))
139     return TRUST_UNDEFINED;
140   else if (!ascii_strcasecmp (str, "never"))
141     return TRUST_NEVER;
142   else if (!ascii_strcasecmp (str, "marginal"))
143     return TRUST_MARGINAL;
144   else if (!ascii_strcasecmp (str, "full"))
145     return TRUST_FULLY;
146   else if (!ascii_strcasecmp(str, "ultimate"))
147     return TRUST_ULTIMATE;
148   else
149     return -1;
150 }
151
152
153 const char *
154 uid_trust_string_fixed (ctrl_t ctrl, PKT_public_key *key, PKT_user_id *uid)
155 {
156   if (!key && !uid)
157     {
158       /* TRANSLATORS: these strings are similar to those in
159          trust_value_to_string(), but are a fixed length.  This is needed to
160          make attractive information listings where columns line up
161          properly.  The value "10" should be the length of the strings you
162          choose to translate to.  This is the length in printable columns.
163          It gets passed to atoi() so everything after the number is
164          essentially a comment and need not be translated.  Either key and
165          uid are both NULL, or neither are NULL. */
166       return _("10 translator see trust.c:uid_trust_string_fixed");
167     }
168   else if(uid->flags.revoked || (key && key->flags.revoked))
169     return                         _("[ revoked]");
170   else if(uid->flags.expired)
171     return                         _("[ expired]");
172   else if(key)
173     {
174       switch (get_validity (ctrl, NULL, key, uid, NULL, 0) & TRUST_MASK)
175         {
176         case TRUST_UNKNOWN:   return _("[ unknown]");
177         case TRUST_EXPIRED:   return _("[ expired]");
178         case TRUST_UNDEFINED: return _("[  undef ]");
179         case TRUST_NEVER:     return _("[  never ]");
180         case TRUST_MARGINAL:  return _("[marginal]");
181         case TRUST_FULLY:     return _("[  full  ]");
182         case TRUST_ULTIMATE:  return _("[ultimate]");
183         }
184     }
185
186   return "err";
187 }
188
189
190 \f
191 /*
192  * Return the assigned ownertrust value for the given public key.
193  * The key should be the primary key.
194  */
195 unsigned int
196 get_ownertrust (ctrl_t ctrl, PKT_public_key *pk)
197 {
198 #ifdef NO_TRUST_MODELS
199   (void)pk;
200   return TRUST_UNKNOWN;
201 #else
202   return tdb_get_ownertrust (ctrl, pk, 0);
203 #endif
204 }
205
206
207 /*
208  * Same as get_ownertrust but this takes the minimum ownertrust value
209  * into account, and will bump up the value as needed.  NO_CREATE
210  * inhibits creation of a trustdb it that does not yet exists.
211  */
212 static int
213 get_ownertrust_with_min (ctrl_t ctrl, PKT_public_key *pk, int no_create)
214 {
215 #ifdef NO_TRUST_MODELS
216   (void)pk;
217   return TRUST_UNKNOWN;
218 #else
219   unsigned int otrust, otrust_min;
220
221   /* Shortcut instead of doing the same twice in the two tdb_get
222    * functions: If the caller asked not to create a trustdb we call
223    * init_trustdb directly and allow it to fail with an error code for
224    * a non-existing trustdb.  */
225   if (no_create && init_trustdb (ctrl, 1))
226     return TRUST_UNKNOWN;
227
228   otrust = (tdb_get_ownertrust (ctrl, pk, no_create) & TRUST_MASK);
229   otrust_min = tdb_get_min_ownertrust (ctrl, pk, no_create);
230   if (otrust < otrust_min)
231     {
232       /* If the trust that the user has set is less than the trust
233          that was calculated from a trust signature chain, use the
234          higher of the two.  We do this here and not in
235          get_ownertrust since the underlying ownertrust should not
236          really be set - just the appearance of the ownertrust. */
237
238       otrust = otrust_min;
239     }
240
241   return otrust;
242 #endif
243 }
244
245
246 /*
247  * Same as get_ownertrust but return a trust letter instead of an
248  * value.  This takes the minimum ownertrust value into account.  If
249  * NO_CREATE is set, no efforts for creating a trustdb will be taken.
250  */
251 int
252 get_ownertrust_info (ctrl_t ctrl, PKT_public_key *pk, int no_create)
253 {
254   return trust_letter (get_ownertrust_with_min (ctrl, pk, no_create));
255 }
256
257
258 /*
259  * Same as get_ownertrust but return a trust string instead of an
260  * value.  This takes the minimum ownertrust value into account.  If
261  * NO_CREATE is set, no efforts for creating a trustdb will be taken.
262  */
263 const char *
264 get_ownertrust_string (ctrl_t ctrl, PKT_public_key *pk, int no_create)
265 {
266   return trust_value_to_string (get_ownertrust_with_min (ctrl, pk, no_create));
267 }
268
269
270 /*
271  * Set the trust value of the given public key to the new value.
272  * The key should be a primary one.
273  */
274 void
275 update_ownertrust (ctrl_t ctrl, PKT_public_key *pk, unsigned int new_trust)
276 {
277 #ifdef NO_TRUST_MODELS
278   (void)pk;
279   (void)new_trust;
280 #else
281   tdb_update_ownertrust (ctrl, pk, new_trust);
282 #endif
283 }
284
285
286 int
287 clear_ownertrusts (ctrl_t ctrl, PKT_public_key *pk)
288 {
289 #ifdef NO_TRUST_MODELS
290   (void)pk;
291   return 0;
292 #else
293   return tdb_clear_ownertrusts (ctrl, pk);
294 #endif
295 }
296
297
298 void
299 revalidation_mark (ctrl_t ctrl)
300 {
301 #ifndef NO_TRUST_MODELS
302   tdb_revalidation_mark (ctrl);
303 #endif
304 }
305
306
307 void
308 check_trustdb_stale (ctrl_t ctrl)
309 {
310 #ifndef NO_TRUST_MODELS
311   tdb_check_trustdb_stale (ctrl);
312 #else
313   (void)ctrl;
314 #endif
315 }
316
317
318 void
319 check_or_update_trustdb (ctrl_t ctrl)
320 {
321 #ifndef NO_TRUST_MODELS
322   tdb_check_or_update (ctrl);
323 #else
324   (void)ctrl;
325 #endif
326 }
327
328
329 /*
330  * Return the validity information for KB/PK (at least one must be
331  * non-NULL).  If the namehash is not NULL, the validity of the
332  * corresponding user ID is returned, otherwise, a reasonable value
333  * for the entire key is returned.
334  */
335 unsigned int
336 get_validity (ctrl_t ctrl, kbnode_t kb, PKT_public_key *pk, PKT_user_id *uid,
337               PKT_signature *sig, int may_ask)
338 {
339   int rc;
340   unsigned int validity;
341   u32 kid[2];
342   PKT_public_key *main_pk;
343
344   if (kb && pk)
345     log_assert (keyid_cmp (pk_main_keyid (pk),
346                            pk_main_keyid (kb->pkt->pkt.public_key)) == 0);
347
348   if (! pk)
349     {
350       log_assert (kb);
351       pk = kb->pkt->pkt.public_key;
352     }
353
354   if (uid)
355     namehash_from_uid (uid);
356
357   keyid_from_pk (pk, kid);
358   if (pk->main_keyid[0] != kid[0] || pk->main_keyid[1] != kid[1])
359     {
360       /* This is a subkey - get the mainkey. */
361       if (kb)
362         main_pk = kb->pkt->pkt.public_key;
363       else
364         {
365           main_pk = xmalloc_clear (sizeof *main_pk);
366           rc = get_pubkey (ctrl, main_pk, pk->main_keyid);
367           if (rc)
368             {
369               char *tempkeystr = xstrdup (keystr (pk->main_keyid));
370               log_error ("error getting main key %s of subkey %s: %s\n",
371                          tempkeystr, keystr (kid), gpg_strerror (rc));
372               xfree (tempkeystr);
373               validity = TRUST_UNKNOWN;
374               goto leave;
375             }
376         }
377     }
378   else
379     main_pk = pk;
380
381 #ifdef NO_TRUST_MODELS
382   validity = TRUST_UNKNOWN;
383 #else
384   validity = tdb_get_validity_core (ctrl, kb, pk, uid, main_pk, sig, may_ask);
385 #endif
386
387  leave:
388   /* Set some flags direct from the key */
389   if (main_pk->flags.revoked)
390     validity |= TRUST_FLAG_REVOKED;
391   if (main_pk != pk && pk->flags.revoked)
392     validity |= TRUST_FLAG_SUB_REVOKED;
393   /* Note: expiration is a trust value and not a flag - don't know why
394    * I initially designed it that way.  */
395   if (main_pk->has_expired || pk->has_expired)
396     validity = ((validity & (~TRUST_MASK | TRUST_FLAG_PENDING_CHECK))
397                 | TRUST_EXPIRED);
398
399   if (main_pk != pk && !kb)
400     free_public_key (main_pk);
401   return validity;
402 }
403
404
405 int
406 get_validity_info (ctrl_t ctrl, kbnode_t kb, PKT_public_key *pk,
407                    PKT_user_id *uid)
408 {
409   int trustlevel;
410
411   if (kb && pk)
412     log_assert (keyid_cmp (pk_main_keyid (pk),
413                            pk_main_keyid (kb->pkt->pkt.public_key)) == 0);
414
415   if (! pk && kb)
416     pk = kb->pkt->pkt.public_key;
417   if (!pk)
418     return '?';  /* Just in case a NULL PK is passed.  */
419
420   trustlevel = get_validity (ctrl, kb, pk, uid, NULL, 0);
421   if ((trustlevel & TRUST_FLAG_REVOKED))
422     return 'r';
423   return trust_letter (trustlevel);
424 }
425
426
427 const char *
428 get_validity_string (ctrl_t ctrl, PKT_public_key *pk, PKT_user_id *uid)
429 {
430   int trustlevel;
431
432   if (!pk)
433     return "err";  /* Just in case a NULL PK is passed.  */
434
435   trustlevel = get_validity (ctrl, NULL, pk, uid, NULL, 0);
436   if ((trustlevel & TRUST_FLAG_REVOKED))
437     return _("revoked");
438   return trust_value_to_string (trustlevel);
439 }
440
441
442 \f
443 /*
444  * Mark the signature of the given UID which are used to certify it.
445  * To do this, we first revmove all signatures which are not valid and
446  * from the remain ones we look for the latest one.  If this is not a
447  * certification revocation signature we mark the signature by setting
448  * node flag bit 8.  Revocations are marked with flag 11, and sigs
449  * from unavailable keys are marked with flag 12.  Note that flag bits
450  * 9 and 10 are used for internal purposes.
451  */
452 void
453 mark_usable_uid_certs (ctrl_t ctrl, kbnode_t keyblock, kbnode_t uidnode,
454                        u32 *main_kid, struct key_item *klist,
455                        u32 curtime, u32 *next_expire)
456 {
457   kbnode_t node;
458   PKT_signature *sig;
459
460   /* First check all signatures.  */
461   for (node=uidnode->next; node; node = node->next)
462     {
463       int rc;
464
465       node->flag &= ~(1<<8 | 1<<9 | 1<<10 | 1<<11 | 1<<12);
466       if (node->pkt->pkttype == PKT_USER_ID
467           || node->pkt->pkttype == PKT_PUBLIC_SUBKEY
468           || node->pkt->pkttype == PKT_SECRET_SUBKEY)
469         break; /* ready */
470       if (node->pkt->pkttype != PKT_SIGNATURE)
471         continue;
472       sig = node->pkt->pkt.signature;
473       if (main_kid
474           && sig->keyid[0] == main_kid[0] && sig->keyid[1] == main_kid[1])
475         continue; /* ignore self-signatures if we pass in a main_kid */
476       if (!IS_UID_SIG(sig) && !IS_UID_REV(sig))
477         continue; /* we only look at these signature classes */
478       if(sig->sig_class>=0x11 && sig->sig_class<=0x13 &&
479          sig->sig_class-0x10<opt.min_cert_level)
480         continue; /* treat anything under our min_cert_level as an
481                      invalid signature */
482       if (klist && !is_in_klist (klist, sig))
483         continue;  /* no need to check it then */
484       if ((rc=check_key_signature (ctrl, keyblock, node, NULL)))
485         {
486           /* we ignore anything that won't verify, but tag the
487              no_pubkey case */
488           if (gpg_err_code (rc) == GPG_ERR_NO_PUBKEY)
489             node->flag |= 1<<12;
490           continue;
491         }
492       node->flag |= 1<<9;
493     }
494   /* Reset the remaining flags. */
495   for (; node; node = node->next)
496     node->flag &= ~(1<<8 | 1<<9 | 1<<10 | 1<<11 | 1<<12);
497
498   /* kbnode flag usage: bit 9 is here set for signatures to consider,
499    * bit 10 will be set by the loop to keep track of keyIDs already
500    * processed, bit 8 will be set for the usable signatures, and bit
501    * 11 will be set for usable revocations. */
502
503   /* For each cert figure out the latest valid one.  */
504   for (node=uidnode->next; node; node = node->next)
505     {
506       KBNODE n, signode;
507       u32 kid[2];
508       u32 sigdate;
509
510       if (node->pkt->pkttype == PKT_PUBLIC_SUBKEY
511           || node->pkt->pkttype == PKT_SECRET_SUBKEY)
512         break;
513       if ( !(node->flag & (1<<9)) )
514         continue; /* not a node to look at */
515       if ( (node->flag & (1<<10)) )
516         continue; /* signature with a keyID already processed */
517       node->flag |= (1<<10); /* mark this node as processed */
518       sig = node->pkt->pkt.signature;
519       signode = node;
520       sigdate = sig->timestamp;
521       kid[0] = sig->keyid[0]; kid[1] = sig->keyid[1];
522
523       /* Now find the latest and greatest signature */
524       for (n=uidnode->next; n; n = n->next)
525         {
526           if (n->pkt->pkttype == PKT_PUBLIC_SUBKEY
527               || n->pkt->pkttype == PKT_SECRET_SUBKEY)
528             break;
529           if ( !(n->flag & (1<<9)) )
530             continue;
531           if ( (n->flag & (1<<10)) )
532             continue; /* shortcut already processed signatures */
533           sig = n->pkt->pkt.signature;
534           if (kid[0] != sig->keyid[0] || kid[1] != sig->keyid[1])
535             continue;
536           n->flag |= (1<<10); /* mark this node as processed */
537
538           /* If signode is nonrevocable and unexpired and n isn't,
539              then take signode (skip).  It doesn't matter which is
540              older: if signode was older then we don't want to take n
541              as signode is nonrevocable.  If n was older then we're
542              automatically fine. */
543
544           if(((IS_UID_SIG(signode->pkt->pkt.signature) &&
545                !signode->pkt->pkt.signature->flags.revocable &&
546                (signode->pkt->pkt.signature->expiredate==0 ||
547                 signode->pkt->pkt.signature->expiredate>curtime))) &&
548              (!(IS_UID_SIG(n->pkt->pkt.signature) &&
549                 !n->pkt->pkt.signature->flags.revocable &&
550                 (n->pkt->pkt.signature->expiredate==0 ||
551                  n->pkt->pkt.signature->expiredate>curtime))))
552             continue;
553
554           /* If n is nonrevocable and unexpired and signode isn't,
555              then take n.  Again, it doesn't matter which is older: if
556              n was older then we don't want to take signode as n is
557              nonrevocable.  If signode was older then we're
558              automatically fine. */
559
560           if((!(IS_UID_SIG(signode->pkt->pkt.signature) &&
561                 !signode->pkt->pkt.signature->flags.revocable &&
562                 (signode->pkt->pkt.signature->expiredate==0 ||
563                  signode->pkt->pkt.signature->expiredate>curtime))) &&
564              ((IS_UID_SIG(n->pkt->pkt.signature) &&
565                !n->pkt->pkt.signature->flags.revocable &&
566                (n->pkt->pkt.signature->expiredate==0 ||
567                 n->pkt->pkt.signature->expiredate>curtime))))
568             {
569               signode = n;
570               sigdate = sig->timestamp;
571               continue;
572             }
573
574           /* At this point, if it's newer, it goes in as the only
575              remaining possibilities are signode and n are both either
576              revocable or expired or both nonrevocable and unexpired.
577              If the timestamps are equal take the later ordered
578              packet, presuming that the key packets are hopefully in
579              their original order. */
580
581           if (sig->timestamp >= sigdate)
582             {
583               signode = n;
584               sigdate = sig->timestamp;
585             }
586         }
587
588       sig = signode->pkt->pkt.signature;
589       if (IS_UID_SIG (sig))
590         { /* this seems to be a usable one which is not revoked.
591            * Just need to check whether there is an expiration time,
592            * We do the expired certification after finding a suitable
593            * certification, the assumption is that a signator does not
594            * want that after the expiration of his certificate the
595            * system falls back to an older certification which has a
596            * different expiration time */
597           const byte *p;
598           u32 expire;
599
600           p = parse_sig_subpkt (sig->hashed, SIGSUBPKT_SIG_EXPIRE, NULL );
601           expire = p? sig->timestamp + buf32_to_u32(p) : 0;
602
603           if (expire==0 || expire > curtime )
604             {
605               signode->flag |= (1<<8); /* yeah, found a good cert */
606               if (next_expire && expire && expire < *next_expire)
607                 *next_expire = expire;
608             }
609         }
610       else
611         signode->flag |= (1<<11);
612     }
613 }
614
615
616 static int
617 clean_sigs_from_uid (ctrl_t ctrl, kbnode_t keyblock, kbnode_t uidnode,
618                      int noisy, int self_only)
619 {
620   int deleted = 0;
621   kbnode_t node;
622   u32 keyid[2];
623
624   log_assert (keyblock->pkt->pkttype == PKT_PUBLIC_KEY
625               || keyblock->pkt->pkttype == PKT_SECRET_KEY);
626
627   keyid_from_pk (keyblock->pkt->pkt.public_key, keyid);
628
629   /* Passing in a 0 for current time here means that we'll never weed
630      out an expired sig.  This is correct behavior since we want to
631      keep the most recent expired sig in a series. */
632   mark_usable_uid_certs (ctrl, keyblock, uidnode, NULL, NULL, 0, NULL);
633
634   /* What we want to do here is remove signatures that are not
635      considered as part of the trust calculations.  Thus, all invalid
636      signatures are out, as are any signatures that aren't the last of
637      a series of uid sigs or revocations It breaks down like this:
638      coming out of mark_usable_uid_certs, if a sig is unflagged, it is
639      not even a candidate.  If a sig has flag 9 or 10, that means it
640      was selected as a candidate and vetted.  If a sig has flag 8 it
641      is a usable signature.  If a sig has flag 11 it is a usable
642      revocation.  If a sig has flag 12 it was issued by an unavailable
643      key.  "Usable" here means the most recent valid
644      signature/revocation in a series from a particular signer.
645
646      Delete everything that isn't a usable uid sig (which might be
647      expired), a usable revocation, or a sig from an unavailable
648      key. */
649
650   for (node=uidnode->next;
651        node && node->pkt->pkttype==PKT_SIGNATURE;
652        node=node->next)
653     {
654       int keep;
655
656       keep = self_only? (node->pkt->pkt.signature->keyid[0] == keyid[0]
657                          && node->pkt->pkt.signature->keyid[1] == keyid[1]) : 1;
658
659       /* Keep usable uid sigs ... */
660       if ((node->flag & (1<<8)) && keep)
661         continue;
662
663       /* ... and usable revocations... */
664       if ((node->flag & (1<<11)) && keep)
665         continue;
666
667       /* ... and sigs from unavailable keys. */
668       /* disabled for now since more people seem to want sigs from
669          unavailable keys removed altogether.  */
670       /*
671         if(node->flag & (1<<12))
672         continue;
673       */
674
675       /* Everything else we delete */
676
677       /* At this point, if 12 is set, the signing key was unavailable.
678          If 9 or 10 is set, it's superseded.  Otherwise, it's
679          invalid. */
680
681       if (noisy)
682         log_info ("removing signature from key %s on user ID \"%s\": %s\n",
683                   keystr (node->pkt->pkt.signature->keyid),
684                   uidnode->pkt->pkt.user_id->name,
685                   node->flag&(1<<12)? "key unavailable":
686                   node->flag&(1<<9)?  "signature superseded"
687                   /* */               :"invalid signature"  );
688
689       delete_kbnode (node);
690       deleted++;
691     }
692
693   return deleted;
694 }
695
696
697 /* This is substantially easier than clean_sigs_from_uid since we just
698    have to establish if the uid has a valid self-sig, is not revoked,
699    and is not expired.  Note that this does not take into account
700    whether the uid has a trust path to it - just whether the keyholder
701    themselves has certified the uid.  Returns true if the uid was
702    compacted.  To "compact" a user ID, we simply remove ALL signatures
703    except the self-sig that caused the user ID to be remove-worthy.
704    We don't actually remove the user ID packet itself since it might
705    be resurrected in a later merge.  Note that this function requires
706    that the caller has already done a merge_keys_and_selfsig().
707
708    TODO: change the import code to allow importing a uid with only a
709    revocation if the uid already exists on the keyring. */
710
711 static int
712 clean_uid_from_key (kbnode_t keyblock, kbnode_t uidnode, int noisy)
713 {
714   kbnode_t node;
715   PKT_user_id *uid = uidnode->pkt->pkt.user_id;
716   int deleted = 0;
717
718   log_assert (keyblock->pkt->pkttype == PKT_PUBLIC_KEY
719               || keyblock->pkt->pkttype == PKT_SECRET_KEY);
720   log_assert (uidnode->pkt->pkttype==PKT_USER_ID);
721
722   /* Skip valid user IDs, compacted user IDs, and non-self-signed user
723      IDs if --allow-non-selfsigned-uid is set. */
724   if (uid->created
725       || uid->flags.compacted
726       || (!uid->flags.expired && !uid->flags.revoked && opt.allow_non_selfsigned_uid))
727     return 0;
728
729   for (node=uidnode->next;
730        node && node->pkt->pkttype == PKT_SIGNATURE;
731       node=node->next)
732     {
733       if (!node->pkt->pkt.signature->flags.chosen_selfsig)
734         {
735           delete_kbnode (node);
736           deleted = 1;
737           uidnode->pkt->pkt.user_id->flags.compacted = 1;
738         }
739     }
740
741   if (noisy)
742     {
743       const char *reason;
744       char *user = utf8_to_native (uid->name, uid->len, 0);
745
746       if (uid->flags.revoked)
747         reason = _("revoked");
748       else if (uid->flags.expired)
749         reason = _("expired");
750       else
751         reason = _("invalid");
752
753       log_info ("compacting user ID \"%s\" on key %s: %s\n",
754                 user, keystr_from_pk (keyblock->pkt->pkt.public_key),
755                 reason);
756
757       xfree (user);
758     }
759
760   return deleted;
761 }
762
763
764 /* Needs to be called after a merge_keys_and_selfsig() */
765 void
766 clean_one_uid (ctrl_t ctrl, kbnode_t keyblock, kbnode_t uidnode,
767                int noisy, int self_only, int *uids_cleaned, int *sigs_cleaned)
768 {
769   int dummy = 0;
770
771   log_assert (keyblock->pkt->pkttype == PKT_PUBLIC_KEY
772               || keyblock->pkt->pkttype == PKT_SECRET_KEY);
773   log_assert (uidnode->pkt->pkttype==PKT_USER_ID);
774
775   if (!uids_cleaned)
776     uids_cleaned = &dummy;
777
778   if (!sigs_cleaned)
779     sigs_cleaned = &dummy;
780
781   /* Do clean_uid_from_key first since if it fires off, we don't have
782      to bother with the other.  */
783   *uids_cleaned += clean_uid_from_key (keyblock, uidnode, noisy);
784   if (!uidnode->pkt->pkt.user_id->flags.compacted)
785     *sigs_cleaned += clean_sigs_from_uid (ctrl, keyblock, uidnode,
786                                           noisy, self_only);
787 }
788
789
790 /* NB: This function marks the deleted nodes only and the caller is
791  * responsible to skip or remove them.  */
792 void
793 clean_key (ctrl_t ctrl, kbnode_t keyblock, int noisy, int self_only,
794            int *uids_cleaned, int *sigs_cleaned)
795 {
796   kbnode_t node;
797
798   merge_keys_and_selfsig (ctrl, keyblock);
799
800   for (node = keyblock->next;
801        node && !(node->pkt->pkttype == PKT_PUBLIC_SUBKEY
802                     || node->pkt->pkttype == PKT_SECRET_SUBKEY);
803        node = node->next)
804     {
805       if (node->pkt->pkttype == PKT_USER_ID)
806         clean_one_uid (ctrl, keyblock, node, noisy, self_only,
807                        uids_cleaned, sigs_cleaned);
808     }
809
810   /* Remove bogus subkey binding signatures: The only signatures
811    * allowed are of class 0x18 and 0x28.  */
812   log_assert (!node || (node->pkt->pkttype == PKT_PUBLIC_SUBKEY
813                         || node->pkt->pkttype == PKT_SECRET_SUBKEY));
814   for (; node; node = node->next)
815     {
816       if (is_deleted_kbnode (node))
817         continue;
818       if (node->pkt->pkttype == PKT_SIGNATURE
819           && !(IS_SUBKEY_SIG (node->pkt->pkt.signature)
820                 || IS_SUBKEY_REV (node->pkt->pkt.signature)))
821         {
822           delete_kbnode (node);
823           if (sigs_cleaned)
824             ++*sigs_cleaned;
825         }
826     }
827 }