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 "util.h"
  30 #include "options.h"
  31 #include "packet.h"
  32 #include "main.h"
  33 #include "i18n.h"
  34 #include "trustdb.h"
  35 #include "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 (PKT_public_key *pk)
  42 {
  43 #ifdef NO_TRUST_MODELS
  44   (void)pk;
  45   return 0;
  46 #else
  47   return tdb_cache_disabled_value (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->is_revoked || (key && key->flags.revoked))
 149     return                         _("[ revoked]");
 150   else if(uid->is_expired)
 151     return                         _("[ expired]");
 152   else if(key)
 153     {
 154       switch (get_validity (ctrl, 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 (PKT_public_key *pk)
 177 {
 178 #ifdef NO_TRUST_MODELS
 179   (void)pk;
 180   return TRUST_UNKNOWN;
 181 #else
 182   return tdb_get_ownertrust (pk);
 183 #endif
 184 }
 185
 186
 187 /*
 188  * Same as get_ownertrust but this takes the minimum ownertrust value
 189  * into into account, and will bump up the value as needed.
 190  */
 191 static int
 192 get_ownertrust_with_min (PKT_public_key *pk)
 193 {
 194 #ifdef NO_TRUST_MODELS
 195   (void)pk;
 196   return TRUST_UNKNOWN;
 197 #else
 198   unsigned int otrust, otrust_min;
 199
 200   otrust = (tdb_get_ownertrust (pk) & TRUST_MASK);
 201   otrust_min = tdb_get_min_ownertrust (pk);
 202   if (otrust < otrust_min)
 203     {
 204       /* If the trust that the user has set is less than the trust
 205          that was calculated from a trust signature chain, use the
 206          higher of the two.  We do this here and not in
 207          get_ownertrust since the underlying ownertrust should not
 208          really be set - just the appearance of the ownertrust. */
 209
 210       otrust = otrust_min;
 211     }
 212
 213   return otrust;
 214 #endif
 215 }
 216
 217
 218 /*
 219  * Same as get_ownertrust but return a trust letter instead of an
 220  * value.  This takes the minimum ownertrust value into account.
 221  */
 222 int
 223 get_ownertrust_info (PKT_public_key *pk)
 224 {
 225   return trust_letter (get_ownertrust_with_min (pk));
 226 }
 227
 228
 229 /*
 230  * Same as get_ownertrust but return a trust string instead of an
 231  * value.  This takes the minimum ownertrust value into account.
 232  */
 233 const char *
 234 get_ownertrust_string (PKT_public_key *pk)
 235 {
 236   return trust_value_to_string (get_ownertrust_with_min (pk));
 237 }
 238
 239
 240 /*
 241  * Set the trust value of the given public key to the new value.
 242  * The key should be a primary one.
 243  */
 244 void
 245 update_ownertrust (PKT_public_key *pk, unsigned int new_trust)
 246 {
 247 #ifdef NO_TRUST_MODELS
 248   (void)pk;
 249   (void)new_trust;
 250 #else
 251   tdb_update_ownertrust (pk, new_trust);
 252 #endif
 253 }
 254
 255
 256 int
 257 clear_ownertrusts (PKT_public_key *pk)
 258 {
 259 #ifdef NO_TRUST_MODELS
 260   (void)pk;
 261   return 0;
 262 #else
 263   return tdb_clear_ownertrusts (pk);
 264 #endif
 265 }
 266
 267
 268 void
 269 revalidation_mark (void)
 270 {
 271 #ifndef NO_TRUST_MODELS
 272   tdb_revalidation_mark ();
 273 #endif
 274 }
 275
 276
 277 void
 278 check_trustdb_stale (ctrl_t ctrl)
 279 {
 280 #ifndef NO_TRUST_MODELS
 281   tdb_check_trustdb_stale (ctrl);
 282 #else
 283   (void)ctrl;
 284 #endif
 285 }
 286
 287
 288 void
 289 check_or_update_trustdb (ctrl_t ctrl)
 290 {
 291 #ifndef NO_TRUST_MODELS
 292   tdb_check_or_update (ctrl);
 293 #else
 294   (void)ctrl;
 295 #endif
 296 }
 297
 298
 299 /*
 300  * Return the validity information for PK.  If the namehash is not
 301  * NULL, the validity of the corresponding user ID is returned,
 302  * otherwise, a reasonable value for the entire key is returned.
 303  */
 304 unsigned int
 305 get_validity (ctrl_t ctrl, PKT_public_key *pk, PKT_user_id *uid,
 306               PKT_signature *sig, int may_ask)
 307 {
 308   int rc;
 309   unsigned int validity;
 310   u32 kid[2];
 311   PKT_public_key *main_pk;
 312
 313   if (uid)
 314     namehash_from_uid (uid);
 315
 316   keyid_from_pk (pk, kid);
 317   if (pk->main_keyid[0] != kid[0] || pk->main_keyid[1] != kid[1])
 318     {
 319       /* This is a subkey - get the mainkey. */
 320       main_pk = xmalloc_clear (sizeof *main_pk);
 321       rc = get_pubkey (main_pk, pk->main_keyid);
 322       if (rc)
 323         {
 324           char *tempkeystr = xstrdup (keystr (pk->main_keyid));
 325           log_error ("error getting main key %s of subkey %s: %s\n",
 326                      tempkeystr, keystr (kid), gpg_strerror (rc));
 327           xfree (tempkeystr);
 328           validity = TRUST_UNKNOWN;
 329           goto leave;
 330         }
 331     }
 332   else
 333     main_pk = pk;
 334
 335 #ifdef NO_TRUST_MODELS
 336   validity = TRUST_UNKNOWN;
 337 #else
 338   validity = tdb_get_validity_core (ctrl, pk, uid, main_pk, sig, may_ask);
 339 #endif
 340
 341  leave:
 342   /* Set some flags direct from the key */
 343   if (main_pk->flags.revoked)
 344     validity |= TRUST_FLAG_REVOKED;
 345   if (main_pk != pk && pk->flags.revoked)
 346     validity |= TRUST_FLAG_SUB_REVOKED;
 347   /* Note: expiration is a trust value and not a flag - don't know why
 348    * I initially designed it that way.  */
 349   if (main_pk->has_expired || pk->has_expired)
 350     validity = ((validity & (~TRUST_MASK | TRUST_FLAG_PENDING_CHECK))
 351                 | TRUST_EXPIRED);
 352
 353   if (main_pk != pk)
 354     free_public_key (main_pk);
 355   return validity;
 356 }
 357
 358
 359 int
 360 get_validity_info (ctrl_t ctrl, PKT_public_key *pk, PKT_user_id *uid)
 361 {
 362   int trustlevel;
 363
 364   if (!pk)
 365     return '?';  /* Just in case a NULL PK is passed.  */
 366
 367   trustlevel = get_validity (ctrl, pk, uid, NULL, 0);
 368   if ((trustlevel & TRUST_FLAG_REVOKED))
 369     return 'r';
 370   return trust_letter (trustlevel);
 371 }
 372
 373
 374 const char *
 375 get_validity_string (ctrl_t ctrl, PKT_public_key *pk, PKT_user_id *uid)
 376 {
 377   int trustlevel;
 378
 379   if (!pk)
 380     return "err";  /* Just in case a NULL PK is passed.  */
 381
 382   trustlevel = get_validity (ctrl, pk, uid, NULL, 0);
 383   if ((trustlevel & TRUST_FLAG_REVOKED))
 384     return _("revoked");
 385   return trust_value_to_string (trustlevel);
 386 }
 387
 388
 389 \f
 390 /*
 391  * Mark the signature of the given UID which are used to certify it.
 392  * To do this, we first revmove all signatures which are not valid and
 393  * from the remain ones we look for the latest one.  If this is not a
 394  * certification revocation signature we mark the signature by setting
 395  * node flag bit 8.  Revocations are marked with flag 11, and sigs
 396  * from unavailable keys are marked with flag 12.  Note that flag bits
 397  * 9 and 10 are used for internal purposes.
 398  */
 399 void
 400 mark_usable_uid_certs (kbnode_t keyblock, kbnode_t uidnode,
 401                        u32 *main_kid, struct key_item *klist,
 402                        u32 curtime, u32 *next_expire)
 403 {
 404   kbnode_t node;
 405   PKT_signature *sig;
 406
 407   /* First check all signatures.  */
 408   for (node=uidnode->next; node; node = node->next)
 409     {
 410       int rc;
 411
 412       node->flag &= ~(1<<8 | 1<<9 | 1<<10 | 1<<11 | 1<<12);
 413       if (node->pkt->pkttype == PKT_USER_ID
 414           || node->pkt->pkttype == PKT_PUBLIC_SUBKEY)
 415         break; /* ready */
 416       if (node->pkt->pkttype != PKT_SIGNATURE)
 417         continue;
 418       sig = node->pkt->pkt.signature;
 419       if (main_kid
 420           && sig->keyid[0] == main_kid[0] && sig->keyid[1] == main_kid[1])
 421         continue; /* ignore self-signatures if we pass in a main_kid */
 422       if (!IS_UID_SIG(sig) && !IS_UID_REV(sig))
 423         continue; /* we only look at these signature classes */
 424       if(sig->sig_class>=0x11 && sig->sig_class<=0x13 &&
 425          sig->sig_class-0x10<opt.min_cert_level)
 426         continue; /* treat anything under our min_cert_level as an
 427                      invalid signature */
 428       if (klist && !is_in_klist (klist, sig))
 429         continue;  /* no need to check it then */
 430       if ((rc=check_key_signature (keyblock, node, NULL)))
 431         {
 432           /* we ignore anything that won't verify, but tag the
 433              no_pubkey case */
 434           if (gpg_err_code (rc) == GPG_ERR_NO_PUBKEY)
 435             node->flag |= 1<<12;
 436           continue;
 437         }
 438       node->flag |= 1<<9;
 439     }
 440   /* Reset the remaining flags. */
 441   for (; node; node = node->next)
 442     node->flag &= ~(1<<8 | 1<<9 | 1<<10 | 1<<11 | 1<<12);
 443
 444   /* kbnode flag usage: bit 9 is here set for signatures to consider,
 445    * bit 10 will be set by the loop to keep track of keyIDs already
 446    * processed, bit 8 will be set for the usable signatures, and bit
 447    * 11 will be set for usable revocations. */
 448
 449   /* For each cert figure out the latest valid one.  */
 450   for (node=uidnode->next; node; node = node->next)
 451     {
 452       KBNODE n, signode;
 453       u32 kid[2];
 454       u32 sigdate;
 455
 456       if (node->pkt->pkttype == PKT_PUBLIC_SUBKEY)
 457         break;
 458       if ( !(node->flag & (1<<9)) )
 459         continue; /* not a node to look at */
 460       if ( (node->flag & (1<<10)) )
 461         continue; /* signature with a keyID already processed */
 462       node->flag |= (1<<10); /* mark this node as processed */
 463       sig = node->pkt->pkt.signature;
 464       signode = node;
 465       sigdate = sig->timestamp;
 466       kid[0] = sig->keyid[0]; kid[1] = sig->keyid[1];
 467
 468       /* Now find the latest and greatest signature */
 469       for (n=uidnode->next; n; n = n->next)
 470         {
 471           if (n->pkt->pkttype == PKT_PUBLIC_SUBKEY)
 472             break;
 473           if ( !(n->flag & (1<<9)) )
 474             continue;
 475           if ( (n->flag & (1<<10)) )
 476             continue; /* shortcut already processed signatures */
 477           sig = n->pkt->pkt.signature;
 478           if (kid[0] != sig->keyid[0] || kid[1] != sig->keyid[1])
 479             continue;
 480           n->flag |= (1<<10); /* mark this node as processed */
 481
 482           /* If signode is nonrevocable and unexpired and n isn't,
 483              then take signode (skip).  It doesn't matter which is
 484              older: if signode was older then we don't want to take n
 485              as signode is nonrevocable.  If n was older then we're
 486              automatically fine. */
 487
 488           if(((IS_UID_SIG(signode->pkt->pkt.signature) &&
 489                !signode->pkt->pkt.signature->flags.revocable &&
 490                (signode->pkt->pkt.signature->expiredate==0 ||
 491                 signode->pkt->pkt.signature->expiredate>curtime))) &&
 492              (!(IS_UID_SIG(n->pkt->pkt.signature) &&
 493                 !n->pkt->pkt.signature->flags.revocable &&
 494                 (n->pkt->pkt.signature->expiredate==0 ||
 495                  n->pkt->pkt.signature->expiredate>curtime))))
 496             continue;
 497
 498           /* If n is nonrevocable and unexpired and signode isn't,
 499              then take n.  Again, it doesn't matter which is older: if
 500              n was older then we don't want to take signode as n is
 501              nonrevocable.  If signode was older then we're
 502              automatically fine. */
 503
 504           if((!(IS_UID_SIG(signode->pkt->pkt.signature) &&
 505                 !signode->pkt->pkt.signature->flags.revocable &&
 506                 (signode->pkt->pkt.signature->expiredate==0 ||
 507                  signode->pkt->pkt.signature->expiredate>curtime))) &&
 508              ((IS_UID_SIG(n->pkt->pkt.signature) &&
 509                !n->pkt->pkt.signature->flags.revocable &&
 510                (n->pkt->pkt.signature->expiredate==0 ||
 511                 n->pkt->pkt.signature->expiredate>curtime))))
 512             {
 513               signode = n;
 514               sigdate = sig->timestamp;
 515               continue;
 516             }
 517
 518           /* At this point, if it's newer, it goes in as the only
 519              remaining possibilities are signode and n are both either
 520              revocable or expired or both nonrevocable and unexpired.
 521              If the timestamps are equal take the later ordered
 522              packet, presuming that the key packets are hopefully in
 523              their original order. */
 524
 525           if (sig->timestamp >= sigdate)
 526             {
 527               signode = n;
 528               sigdate = sig->timestamp;
 529             }
 530         }
 531
 532       sig = signode->pkt->pkt.signature;
 533       if (IS_UID_SIG (sig))
 534         { /* this seems to be a usable one which is not revoked.
 535            * Just need to check whether there is an expiration time,
 536            * We do the expired certification after finding a suitable
 537            * certification, the assumption is that a signator does not
 538            * want that after the expiration of his certificate the
 539            * system falls back to an older certification which has a
 540            * different expiration time */
 541           const byte *p;
 542           u32 expire;
 543
 544           p = parse_sig_subpkt (sig->hashed, SIGSUBPKT_SIG_EXPIRE, NULL );
 545           expire = p? sig->timestamp + buf32_to_u32(p) : 0;
 546
 547           if (expire==0 || expire > curtime )
 548             {
 549               signode->flag |= (1<<8); /* yeah, found a good cert */
 550               if (next_expire && expire && expire < *next_expire)
 551                 *next_expire = expire;
 552             }
 553         }
 554       else
 555         signode->flag |= (1<<11);
 556     }
 557 }
 558
 559
 560 static int
 561 clean_sigs_from_uid (kbnode_t keyblock, kbnode_t uidnode,
 562                      int noisy, int self_only)
 563 {
 564   int deleted = 0;
 565   kbnode_t node;
 566   u32 keyid[2];
 567
 568   log_assert (keyblock->pkt->pkttype==PKT_PUBLIC_KEY);
 569
 570   keyid_from_pk (keyblock->pkt->pkt.public_key, keyid);
 571
 572   /* Passing in a 0 for current time here means that we'll never weed
 573      out an expired sig.  This is correct behavior since we want to
 574      keep the most recent expired sig in a series. */
 575   mark_usable_uid_certs (keyblock, uidnode, NULL, NULL, 0, NULL);
 576
 577   /* What we want to do here is remove signatures that are not
 578      considered as part of the trust calculations.  Thus, all invalid
 579      signatures are out, as are any signatures that aren't the last of
 580      a series of uid sigs or revocations It breaks down like this:
 581      coming out of mark_usable_uid_certs, if a sig is unflagged, it is
 582      not even a candidate.  If a sig has flag 9 or 10, that means it
 583      was selected as a candidate and vetted.  If a sig has flag 8 it
 584      is a usable signature.  If a sig has flag 11 it is a usable
 585      revocation.  If a sig has flag 12 it was issued by an unavailable
 586      key.  "Usable" here means the most recent valid
 587      signature/revocation in a series from a particular signer.
 588
 589      Delete everything that isn't a usable uid sig (which might be
 590      expired), a usable revocation, or a sig from an unavailable
 591      key. */
 592
 593   for (node=uidnode->next;
 594        node && node->pkt->pkttype==PKT_SIGNATURE;
 595        node=node->next)
 596     {
 597       int keep;
 598
 599       keep = self_only? (node->pkt->pkt.signature->keyid[0] == keyid[0]
 600                          && node->pkt->pkt.signature->keyid[1] == keyid[1]) : 1;
 601
 602       /* Keep usable uid sigs ... */
 603       if ((node->flag & (1<<8)) && keep)
 604         continue;
 605
 606       /* ... and usable revocations... */
 607       if ((node->flag & (1<<11)) && keep)
 608         continue;
 609
 610       /* ... and sigs from unavailable keys. */
 611       /* disabled for now since more people seem to want sigs from
 612          unavailable keys removed altogether.  */
 613       /*
 614         if(node->flag & (1<<12))
 615         continue;
 616       */
 617
 618       /* Everything else we delete */
 619
 620       /* At this point, if 12 is set, the signing key was unavailable.
 621          If 9 or 10 is set, it's superseded.  Otherwise, it's
 622          invalid. */
 623
 624       if (noisy)
 625         log_info ("removing signature from key %s on user ID \"%s\": %s\n",
 626                   keystr (node->pkt->pkt.signature->keyid),
 627                   uidnode->pkt->pkt.user_id->name,
 628                   node->flag&(1<<12)? "key unavailable":
 629                   node->flag&(1<<9)?  "signature superseded"
 630                   /* */               :"invalid signature"  );
 631
 632       delete_kbnode (node);
 633       deleted++;
 634     }
 635
 636   return deleted;
 637 }
 638
 639
 640 /* This is substantially easier than clean_sigs_from_uid since we just
 641    have to establish if the uid has a valid self-sig, is not revoked,
 642    and is not expired.  Note that this does not take into account
 643    whether the uid has a trust path to it - just whether the keyholder
 644    themselves has certified the uid.  Returns true if the uid was
 645    compacted.  To "compact" a user ID, we simply remove ALL signatures
 646    except the self-sig that caused the user ID to be remove-worthy.
 647    We don't actually remove the user ID packet itself since it might
 648    be resurrected in a later merge.  Note that this function requires
 649    that the caller has already done a merge_keys_and_selfsig().
 650
 651    TODO: change the import code to allow importing a uid with only a
 652    revocation if the uid already exists on the keyring. */
 653
 654 static int
 655 clean_uid_from_key (kbnode_t keyblock, kbnode_t uidnode, int noisy)
 656 {
 657   kbnode_t node;
 658   PKT_user_id *uid = uidnode->pkt->pkt.user_id;
 659   int deleted = 0;
 660
 661   log_assert (keyblock->pkt->pkttype==PKT_PUBLIC_KEY);
 662   log_assert (uidnode->pkt->pkttype==PKT_USER_ID);
 663
 664   /* Skip valid user IDs, compacted user IDs, and non-self-signed user
 665      IDs if --allow-non-selfsigned-uid is set. */
 666   if (uid->created
 667       || uid->flags.compacted
 668       || (!uid->is_expired && !uid->is_revoked && opt.allow_non_selfsigned_uid))
 669     return 0;
 670
 671   for (node=uidnode->next;
 672        node && node->pkt->pkttype == PKT_SIGNATURE;
 673       node=node->next)
 674     {
 675       if (!node->pkt->pkt.signature->flags.chosen_selfsig)
 676         {
 677           delete_kbnode (node);
 678           deleted = 1;
 679           uidnode->pkt->pkt.user_id->flags.compacted = 1;
 680         }
 681     }
 682
 683   if (noisy)
 684     {
 685       const char *reason;
 686       char *user = utf8_to_native (uid->name, uid->len, 0);
 687
 688       if (uid->is_revoked)
 689         reason = _("revoked");
 690       else if (uid->is_expired)
 691         reason = _("expired");
 692       else
 693         reason = _("invalid");
 694
 695       log_info ("compacting user ID \"%s\" on key %s: %s\n",
 696                 user, keystr_from_pk (keyblock->pkt->pkt.public_key),
 697                 reason);
 698
 699       xfree (user);
 700     }
 701
 702   return deleted;
 703 }
 704
 705
 706 /* Needs to be called after a merge_keys_and_selfsig() */
 707 void
 708 clean_one_uid (kbnode_t keyblock, kbnode_t uidnode, int noisy, int self_only,
 709                int *uids_cleaned, int *sigs_cleaned)
 710 {
 711   int dummy = 0;
 712
 713   log_assert (keyblock->pkt->pkttype==PKT_PUBLIC_KEY);
 714   log_assert (uidnode->pkt->pkttype==PKT_USER_ID);
 715
 716   if (!uids_cleaned)
 717     uids_cleaned = &dummy;
 718
 719   if (!sigs_cleaned)
 720     sigs_cleaned = &dummy;
 721
 722   /* Do clean_uid_from_key first since if it fires off, we don't have
 723      to bother with the other.  */
 724   *uids_cleaned += clean_uid_from_key (keyblock, uidnode, noisy);
 725   if (!uidnode->pkt->pkt.user_id->flags.compacted)
 726     *sigs_cleaned += clean_sigs_from_uid (keyblock, uidnode, noisy, self_only);
 727 }
 728
 729
 730 void
 731 clean_key (kbnode_t keyblock, int noisy, int self_only,
 732            int *uids_cleaned, int *sigs_cleaned)
 733 {
 734   kbnode_t uidnode;
 735
 736   merge_keys_and_selfsig (keyblock);
 737
 738   for (uidnode = keyblock->next;
 739        uidnode && uidnode->pkt->pkttype != PKT_PUBLIC_SUBKEY;
 740        uidnode = uidnode->next)
 741     {
 742       if (uidnode->pkt->pkttype == PKT_USER_ID)
 743         clean_one_uid (keyblock, uidnode,noisy, self_only,
 744                        uids_cleaned, sigs_cleaned);
 745     }
 746 }