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