g10/keyedit.c

   1 /* keyedit.c - keyedit stuff
   2  * Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007,
   3  *               2008, 2009, 2010 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 3 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, see <http://www.gnu.org/licenses/>.
  19  */
  20
  21 #include <config.h>
  22 #include <stdio.h>
  23 #include <stdlib.h>
  24 #include <string.h>
  25 #include <errno.h>
  26 #include <assert.h>
  27 #include <ctype.h>
  28 #ifdef HAVE_LIBREADLINE
  29 # define GNUPG_LIBREADLINE_H_INCLUDED
  30 # include <readline/readline.h>
  31 #endif
  32
  33 #define JNLIB_NEED_LOG_LOGV
  34 #include "gpg.h"
  35 #include "options.h"
  36 #include "packet.h"
  37 #include "status.h"
  38 #include "iobuf.h"
  39 #include "keydb.h"
  40 #include "photoid.h"
  41 #include "util.h"
  42 #include "main.h"
  43 #include "trustdb.h"
  44 #include "filter.h"
  45 #include "ttyio.h"
  46 #include "status.h"
  47 #include "i18n.h"
  48 #include "keyserver-internal.h"
  49 #include "call-agent.h"
  50
  51 static void show_prefs (PKT_user_id * uid, PKT_signature * selfsig,
  52                         int verbose);
  53 static void show_names (KBNODE keyblock, PKT_public_key * pk,
  54                         unsigned int flag, int with_prefs);
  55 static void show_key_with_all_names (KBNODE keyblock, int only_marked,
  56                                      int with_revoker, int with_fpr,
  57                                      int with_subkeys, int with_prefs);
  58 static void show_key_and_fingerprint (KBNODE keyblock);
  59 static int menu_adduid (KBNODE keyblock, int photo, const char *photo_name);
  60 static void menu_deluid (KBNODE pub_keyblock);
  61 static int menu_delsig (KBNODE pub_keyblock);
  62 static int menu_clean (KBNODE keyblock, int self_only);
  63 static void menu_delkey (KBNODE pub_keyblock);
  64 static int menu_addrevoker (ctrl_t ctrl, kbnode_t pub_keyblock, int sensitive);
  65 static int menu_expire (KBNODE pub_keyblock);
  66 static int menu_backsign (KBNODE pub_keyblock);
  67 static int menu_set_primary_uid (KBNODE pub_keyblock);
  68 static int menu_set_preferences (KBNODE pub_keyblock);
  69 static int menu_set_keyserver_url (const char *url, KBNODE pub_keyblock);
  70 static int menu_set_notation (const char *string, KBNODE pub_keyblock);
  71 static int menu_select_uid (KBNODE keyblock, int idx);
  72 static int menu_select_uid_namehash (KBNODE keyblock, const char *namehash);
  73 static int menu_select_key (KBNODE keyblock, int idx);
  74 static int count_uids (KBNODE keyblock);
  75 static int count_uids_with_flag (KBNODE keyblock, unsigned flag);
  76 static int count_keys_with_flag (KBNODE keyblock, unsigned flag);
  77 static int count_selected_uids (KBNODE keyblock);
  78 static int real_uids_left (KBNODE keyblock);
  79 static int count_selected_keys (KBNODE keyblock);
  80 static int menu_revsig (KBNODE keyblock);
  81 static int menu_revuid (KBNODE keyblock);
  82 static int menu_revkey (KBNODE pub_keyblock);
  83 static int menu_revsubkey (KBNODE pub_keyblock);
  84 static int enable_disable_key (KBNODE keyblock, int disable);
  85 static void menu_showphoto (KBNODE keyblock);
  86
  87 static int update_trust = 0;
  88
  89 #define CONTROL_D ('D' - 'A' + 1)
  90
  91 #define NODFLG_BADSIG (1<<0)    /* Bad signature.  */
  92 #define NODFLG_NOKEY  (1<<1)    /* No public key.  */
  93 #define NODFLG_SIGERR (1<<2)    /* Other sig error.  */
  94
  95 #define NODFLG_MARK_A (1<<4)    /* Temporary mark.  */
  96 #define NODFLG_DELSIG (1<<5)    /* To be deleted.  */
  97
  98 #define NODFLG_SELUID (1<<8)    /* Indicate the selected userid. */
  99 #define NODFLG_SELKEY (1<<9)    /* Indicate the selected key.  */
 100 #define NODFLG_SELSIG (1<<10)   /* Indicate a selected signature.  */
 101
 102 struct sign_attrib
 103 {
 104   int non_exportable, non_revocable;
 105   struct revocation_reason_info *reason;
 106   byte trust_depth, trust_value;
 107   char *trust_regexp;
 108 };
 109
 110
 111
 112 /* TODO: Fix duplicated code between here and the check-sigs/list-sigs
 113    code in keylist.c. */
 114 static int
 115 print_and_check_one_sig_colon (KBNODE keyblock, KBNODE node,
 116                                int *inv_sigs, int *no_key, int *oth_err,
 117                                int *is_selfsig, int print_without_key)
 118 {
 119   PKT_signature *sig = node->pkt->pkt.signature;
 120   int rc, sigrc;
 121
 122   /* TODO: Make sure a cached sig record here still has the pk that
 123      issued it.  See also keylist.c:list_keyblock_print */
 124
 125   switch ((rc = check_key_signature (keyblock, node, is_selfsig)))
 126     {
 127     case 0:
 128       node->flag &= ~(NODFLG_BADSIG | NODFLG_NOKEY | NODFLG_SIGERR);
 129       sigrc = '!';
 130       break;
 131     case G10ERR_BAD_SIGN:
 132       node->flag = NODFLG_BADSIG;
 133       sigrc = '-';
 134       if (inv_sigs)
 135         ++ * inv_sigs;
 136       break;
 137     case G10ERR_NO_PUBKEY:
 138     case G10ERR_UNU_PUBKEY:
 139       node->flag = NODFLG_NOKEY;
 140       sigrc = '?';
 141       if (no_key)
 142         ++ * no_key;
 143       break;
 144     default:
 145       node->flag = NODFLG_SIGERR;
 146       sigrc = '%';
 147       if (oth_err)
 148         ++ * oth_err;
 149       break;
 150     }
 151
 152   if (sigrc != '?' || print_without_key)
 153     {
 154       printf ("sig:%c::%d:%08lX%08lX:%lu:%lu:",
 155               sigrc, sig->pubkey_algo, (ulong) sig->keyid[0],
 156               (ulong) sig->keyid[1], (ulong) sig->timestamp,
 157               (ulong) sig->expiredate);
 158
 159       if (sig->trust_depth || sig->trust_value)
 160         printf ("%d %d", sig->trust_depth, sig->trust_value);
 161
 162       printf (":");
 163
 164       if (sig->trust_regexp)
 165         es_write_sanitized (es_stdout,
 166                             sig->trust_regexp, strlen (sig->trust_regexp),
 167                             ":", NULL);
 168
 169       printf ("::%02x%c\n", sig->sig_class,
 170               sig->flags.exportable ? 'x' : 'l');
 171
 172       if (opt.show_subpackets)
 173         print_subpackets_colon (sig);
 174     }
 175
 176   return (sigrc == '!');
 177 }
 178
 179
 180 /*
 181  * Print information about a signature, check it and return true
 182  * if the signature is okay. NODE must be a signature packet.
 183  */
 184 static int
 185 print_and_check_one_sig (KBNODE keyblock, KBNODE node,
 186                          int *inv_sigs, int *no_key, int *oth_err,
 187                          int *is_selfsig, int print_without_key)
 188 {
 189   PKT_signature *sig = node->pkt->pkt.signature;
 190   int rc, sigrc;
 191   int is_rev = sig->sig_class == 0x30;
 192
 193   /* TODO: Make sure a cached sig record here still has the pk that
 194      issued it.  See also keylist.c:list_keyblock_print */
 195
 196   switch ((rc = check_key_signature (keyblock, node, is_selfsig)))
 197     {
 198     case 0:
 199       node->flag &= ~(NODFLG_BADSIG | NODFLG_NOKEY | NODFLG_SIGERR);
 200       sigrc = '!';
 201       break;
 202     case G10ERR_BAD_SIGN:
 203       node->flag = NODFLG_BADSIG;
 204       sigrc = '-';
 205       if (inv_sigs)
 206         ++ * inv_sigs;
 207       break;
 208     case G10ERR_NO_PUBKEY:
 209     case G10ERR_UNU_PUBKEY:
 210       node->flag = NODFLG_NOKEY;
 211       sigrc = '?';
 212       if (no_key)
 213         ++ * no_key;
 214       break;
 215     default:
 216       node->flag = NODFLG_SIGERR;
 217       sigrc = '%';
 218       if (oth_err)
 219         ++ * oth_err;
 220       break;
 221     }
 222   if (sigrc != '?' || print_without_key)
 223     {
 224       tty_printf ("%s%c%c %c%c%c%c%c%c %s %s",
 225                   is_rev ? "rev" : "sig", sigrc,
 226                   (sig->sig_class - 0x10 > 0 &&
 227                    sig->sig_class - 0x10 <
 228                    4) ? '0' + sig->sig_class - 0x10 : ' ',
 229                   sig->flags.exportable ? ' ' : 'L',
 230                   sig->flags.revocable ? ' ' : 'R',
 231                   sig->flags.policy_url ? 'P' : ' ',
 232                   sig->flags.notation ? 'N' : ' ',
 233                   sig->flags.expired ? 'X' : ' ',
 234                   (sig->trust_depth > 9) ? 'T' : (sig->trust_depth >
 235                                                   0) ? '0' +
 236                   sig->trust_depth : ' ', keystr (sig->keyid),
 237                   datestr_from_sig (sig));
 238       if (opt.list_options & LIST_SHOW_SIG_EXPIRE)
 239         tty_printf (" %s", expirestr_from_sig (sig));
 240       tty_printf ("  ");
 241       if (sigrc == '%')
 242         tty_printf ("[%s] ", g10_errstr (rc));
 243       else if (sigrc == '?')
 244         ;
 245       else if (*is_selfsig)
 246         {
 247           tty_printf (is_rev ? _("[revocation]") : _("[self-signature]"));
 248         }
 249       else
 250         {
 251           size_t n;
 252           char *p = get_user_id (sig->keyid, &n);
 253           tty_print_utf8_string2 (p, n,
 254                                   opt.screen_columns - keystrlen () - 26 -
 255                                   ((opt.
 256                                     list_options & LIST_SHOW_SIG_EXPIRE) ? 11
 257                                    : 0));
 258           xfree (p);
 259         }
 260       tty_printf ("\n");
 261
 262       if (sig->flags.policy_url && (opt.list_options & LIST_SHOW_POLICY_URLS))
 263         show_policy_url (sig, 3, 0);
 264
 265       if (sig->flags.notation && (opt.list_options & LIST_SHOW_NOTATIONS))
 266         show_notation (sig, 3, 0,
 267                        ((opt.
 268                          list_options & LIST_SHOW_STD_NOTATIONS) ? 1 : 0) +
 269                        ((opt.
 270                          list_options & LIST_SHOW_USER_NOTATIONS) ? 2 : 0));
 271
 272       if (sig->flags.pref_ks && (opt.list_options & LIST_SHOW_KEYSERVER_URLS))
 273         show_keyserver_url (sig, 3, 0);
 274     }
 275
 276   return (sigrc == '!');
 277 }
 278
 279
 280
 281 /*
 282  * Check the keysigs and set the flags to indicate errors.
 283  * Returns true if error found.
 284  */
 285 static int
 286 check_all_keysigs (KBNODE keyblock, int only_selected)
 287 {
 288   KBNODE kbctx;
 289   KBNODE node;
 290   int inv_sigs = 0;
 291   int no_key = 0;
 292   int oth_err = 0;
 293   int has_selfsig = 0;
 294   int mis_selfsig = 0;
 295   int selected = !only_selected;
 296   int anyuid = 0;
 297
 298   for (kbctx = NULL; (node = walk_kbnode (keyblock, &kbctx, 0));)
 299     {
 300       if (node->pkt->pkttype == PKT_USER_ID)
 301         {
 302           PKT_user_id *uid = node->pkt->pkt.user_id;
 303
 304           if (only_selected)
 305             selected = (node->flag & NODFLG_SELUID);
 306           if (selected)
 307             {
 308               tty_printf ("uid  ");
 309               tty_print_utf8_string (uid->name, uid->len);
 310               tty_printf ("\n");
 311               if (anyuid && !has_selfsig)
 312                 mis_selfsig++;
 313               has_selfsig = 0;
 314               anyuid = 1;
 315             }
 316         }
 317       else if (selected && node->pkt->pkttype == PKT_SIGNATURE
 318                && ((node->pkt->pkt.signature->sig_class & ~3) == 0x10
 319                    || node->pkt->pkt.signature->sig_class == 0x30))
 320         {
 321           int selfsig;
 322
 323           if (print_and_check_one_sig (keyblock, node, &inv_sigs,
 324                                        &no_key, &oth_err, &selfsig, 0))
 325             {
 326               if (selfsig)
 327                 has_selfsig = 1;
 328             }
 329           /* Hmmm: should we update the trustdb here? */
 330         }
 331     }
 332   if (!has_selfsig)
 333     mis_selfsig++;
 334   if (inv_sigs == 1)
 335     tty_printf (_("1 bad signature\n"));
 336   else if (inv_sigs)
 337     tty_printf (_("%d bad signatures\n"), inv_sigs);
 338   if (no_key == 1)
 339     tty_printf (_("1 signature not checked due to a missing key\n"));
 340   else if (no_key)
 341     tty_printf (_("%d signatures not checked due to missing keys\n"), no_key);
 342   if (oth_err == 1)
 343     tty_printf (_("1 signature not checked due to an error\n"));
 344   else if (oth_err)
 345     tty_printf (_("%d signatures not checked due to errors\n"), oth_err);
 346   if (mis_selfsig == 1)
 347     tty_printf (_("1 user ID without valid self-signature detected\n"));
 348   else if (mis_selfsig)
 349     tty_printf (_("%d user IDs without valid self-signatures detected\n"),
 350                 mis_selfsig);
 351
 352   return inv_sigs || no_key || oth_err || mis_selfsig;
 353 }
 354
 355
 356 static int
 357 sign_mk_attrib (PKT_signature * sig, void *opaque)
 358 {
 359   struct sign_attrib *attrib = opaque;
 360   byte buf[8];
 361
 362   if (attrib->non_exportable)
 363     {
 364       buf[0] = 0;               /* not exportable */
 365       build_sig_subpkt (sig, SIGSUBPKT_EXPORTABLE, buf, 1);
 366     }
 367
 368   if (attrib->non_revocable)
 369     {
 370       buf[0] = 0;               /* not revocable */
 371       build_sig_subpkt (sig, SIGSUBPKT_REVOCABLE, buf, 1);
 372     }
 373
 374   if (attrib->reason)
 375     revocation_reason_build_cb (sig, attrib->reason);
 376
 377   if (attrib->trust_depth)
 378     {
 379       /* Not critical.  If someone doesn't understand trust sigs,
 380          this can still be a valid regular signature. */
 381       buf[0] = attrib->trust_depth;
 382       buf[1] = attrib->trust_value;
 383       build_sig_subpkt (sig, SIGSUBPKT_TRUST, buf, 2);
 384
 385       /* Critical.  If someone doesn't understands regexps, this
 386          whole sig should be invalid.  Note the +1 for the length -
 387          regexps are null terminated. */
 388       if (attrib->trust_regexp)
 389         build_sig_subpkt (sig, SIGSUBPKT_FLAG_CRITICAL | SIGSUBPKT_REGEXP,
 390                           attrib->trust_regexp,
 391                           strlen (attrib->trust_regexp) + 1);
 392     }
 393
 394   return 0;
 395 }
 396
 397
 398 static void
 399 trustsig_prompt (byte * trust_value, byte * trust_depth, char **regexp)
 400 {
 401   char *p;
 402
 403   *trust_value = 0;
 404   *trust_depth = 0;
 405   *regexp = NULL;
 406
 407   /* Same string as pkclist.c:do_edit_ownertrust */
 408   tty_printf (_
 409               ("Please decide how far you trust this user to correctly verify"
 410                " other users' keys\n(by looking at passports, checking"
 411                " fingerprints from different sources, etc.)\n"));
 412   tty_printf ("\n");
 413   tty_printf (_("  %d = I trust marginally\n"), 1);
 414   tty_printf (_("  %d = I trust fully\n"), 2);
 415   tty_printf ("\n");
 416
 417   while (*trust_value == 0)
 418     {
 419       p = cpr_get ("trustsig_prompt.trust_value", _("Your selection? "));
 420       trim_spaces (p);
 421       cpr_kill_prompt ();
 422       /* 60 and 120 are as per RFC2440 */
 423       if (p[0] == '1' && !p[1])
 424         *trust_value = 60;
 425       else if (p[0] == '2' && !p[1])
 426         *trust_value = 120;
 427       xfree (p);
 428     }
 429
 430   tty_printf ("\n");
 431
 432   tty_printf (_("Please enter the depth of this trust signature.\n"
 433                 "A depth greater than 1 allows the key you are signing to make\n"
 434                 "trust signatures on your behalf.\n"));
 435   tty_printf ("\n");
 436
 437   while (*trust_depth == 0)
 438     {
 439       p = cpr_get ("trustsig_prompt.trust_depth", _("Your selection? "));
 440       trim_spaces (p);
 441       cpr_kill_prompt ();
 442       *trust_depth = atoi (p);
 443       xfree (p);
 444     }
 445
 446   tty_printf ("\n");
 447
 448   tty_printf (_("Please enter a domain to restrict this signature, "
 449                 "or enter for none.\n"));
 450
 451   tty_printf ("\n");
 452
 453   p = cpr_get ("trustsig_prompt.trust_regexp", _("Your selection? "));
 454   trim_spaces (p);
 455   cpr_kill_prompt ();
 456
 457   if (strlen (p) > 0)
 458     {
 459       char *q = p;
 460       int regexplen = 100, ind;
 461
 462       *regexp = xmalloc (regexplen);
 463
 464       /* Now mangle the domain the user entered into a regexp.  To do
 465          this, \-escape everything that isn't alphanumeric, and attach
 466          "<[^>]+[@.]" to the front, and ">$" to the end. */
 467
 468       strcpy (*regexp, "<[^>]+[@.]");
 469       ind = strlen (*regexp);
 470
 471       while (*q)
 472         {
 473           if (!((*q >= 'A' && *q <= 'Z')
 474                 || (*q >= 'a' && *q <= 'z') || (*q >= '0' && *q <= '9')))
 475             (*regexp)[ind++] = '\\';
 476
 477           (*regexp)[ind++] = *q;
 478
 479           if ((regexplen - ind) < 3)
 480             {
 481               regexplen += 100;
 482               *regexp = xrealloc (*regexp, regexplen);
 483             }
 484
 485           q++;
 486         }
 487
 488       (*regexp)[ind] = '\0';
 489       strcat (*regexp, ">$");
 490     }
 491
 492   xfree (p);
 493   tty_printf ("\n");
 494 }
 495
 496
 497 /*
 498  * Loop over all LOCUSR and and sign the uids after asking.
 499  * If no user id is marked, all user ids will be signed;
 500  * if some user_ids are marked those will be signed.
 501  */
 502 static int
 503 sign_uids (KBNODE keyblock, strlist_t locusr, int *ret_modified,
 504            int local, int nonrevocable, int trust, int interactive)
 505 {
 506   int rc = 0;
 507   SK_LIST sk_list = NULL;
 508   SK_LIST sk_rover = NULL;
 509   PKT_public_key *pk = NULL;
 510   KBNODE node, uidnode;
 511   PKT_public_key *primary_pk = NULL;
 512   int select_all = !count_selected_uids (keyblock) || interactive;
 513   int all_v3 = 1;
 514
 515   /* Are there any non-v3 sigs on this key already? */
 516   if (PGP2)
 517     for (node = keyblock; node; node = node->next)
 518       if (node->pkt->pkttype == PKT_SIGNATURE &&
 519           node->pkt->pkt.signature->version > 3)
 520         {
 521           all_v3 = 0;
 522           break;
 523         }
 524
 525   /* Build a list of all signators.
 526    *
 527    * We use the CERT flag to request the primary which must always
 528    * be one which is capable of signing keys.  I can't see a reason
 529    * why to sign keys using a subkey.  Implementation of USAGE_CERT
 530    * is just a hack in getkey.c and does not mean that a subkey
 531    * marked as certification capable will be used. */
 532   rc = build_sk_list (locusr, &sk_list, PUBKEY_USAGE_CERT);
 533   if (rc)
 534     goto leave;
 535
 536   /* Loop over all signators.  */
 537   for (sk_rover = sk_list; sk_rover; sk_rover = sk_rover->next)
 538     {
 539       u32 sk_keyid[2], pk_keyid[2];
 540       char *p, *trust_regexp = NULL;
 541       int force_v4 = 0, class = 0, selfsig = 0;
 542       u32 duration = 0, timestamp = 0;
 543       byte trust_depth = 0, trust_value = 0;
 544
 545       if (local || nonrevocable || trust
 546           || opt.cert_policy_url || opt.cert_notations)
 547         force_v4 = 1;
 548
 549       pk = sk_rover->pk;
 550       keyid_from_pk (pk, sk_keyid);
 551
 552       /* Set mark A for all selected user ids.  */
 553       for (node = keyblock; node; node = node->next)
 554         {
 555           if (select_all || (node->flag & NODFLG_SELUID))
 556             node->flag |= NODFLG_MARK_A;
 557           else
 558             node->flag &= ~NODFLG_MARK_A;
 559         }
 560
 561       /* Reset mark for uids which are already signed.  */
 562       uidnode = NULL;
 563       for (node = keyblock; node; node = node->next)
 564         {
 565           if (node->pkt->pkttype == PKT_PUBLIC_KEY)
 566             {
 567               primary_pk = node->pkt->pkt.public_key;
 568               keyid_from_pk (primary_pk, pk_keyid);
 569
 570               /* Is this a self-sig? */
 571               if (pk_keyid[0] == sk_keyid[0] && pk_keyid[1] == sk_keyid[1])
 572                 {
 573                   selfsig = 1;
 574                   /* Do not force a v4 sig here, otherwise it would
 575                      be difficult to remake a v3 selfsig.  If this
 576                      is a v3->v4 promotion case, then we set
 577                      force_v4 later anyway. */
 578                   force_v4 = 0;
 579                 }
 580             }
 581           else if (node->pkt->pkttype == PKT_USER_ID)
 582             {
 583               uidnode = (node->flag & NODFLG_MARK_A) ? node : NULL;
 584               if (uidnode)
 585                 {
 586                   int yesreally = 0;
 587                   char *user;
 588
 589                   user = utf8_to_native (uidnode->pkt->pkt.user_id->name,
 590                                          uidnode->pkt->pkt.user_id->len, 0);
 591
 592                   if (uidnode->pkt->pkt.user_id->is_revoked)
 593                     {
 594                       tty_printf (_("User ID \"%s\" is revoked."), user);
 595
 596                       if (selfsig)
 597                         tty_printf ("\n");
 598                       else if (opt.expert)
 599                         {
 600                           tty_printf ("\n");
 601                           /* No, so remove the mark and continue */
 602                           if (!cpr_get_answer_is_yes ("sign_uid.revoke_okay",
 603                                                       _("Are you sure you "
 604                                                         "still want to sign "
 605                                                         "it? (y/N) ")))
 606                             {
 607                               uidnode->flag &= ~NODFLG_MARK_A;
 608                               uidnode = NULL;
 609                             }
 610                           else if (interactive)
 611                             yesreally = 1;
 612                         }
 613                       else
 614                         {
 615                           uidnode->flag &= ~NODFLG_MARK_A;
 616                           uidnode = NULL;
 617                           tty_printf (_("  Unable to sign.\n"));
 618                         }
 619                     }
 620                   else if (uidnode->pkt->pkt.user_id->is_expired)
 621                     {
 622                       tty_printf (_("User ID \"%s\" is expired."), user);
 623
 624                       if (selfsig)
 625                         tty_printf ("\n");
 626                       else if (opt.expert)
 627                         {
 628                           tty_printf ("\n");
 629                           /* No, so remove the mark and continue */
 630                           if (!cpr_get_answer_is_yes ("sign_uid.expire_okay",
 631                                                       _("Are you sure you "
 632                                                         "still want to sign "
 633                                                         "it? (y/N) ")))
 634                             {
 635                               uidnode->flag &= ~NODFLG_MARK_A;
 636                               uidnode = NULL;
 637                             }
 638                           else if (interactive)
 639                             yesreally = 1;
 640                         }
 641                       else
 642                         {
 643                           uidnode->flag &= ~NODFLG_MARK_A;
 644                           uidnode = NULL;
 645                           tty_printf (_("  Unable to sign.\n"));
 646                         }
 647                     }
 648                   else if (!uidnode->pkt->pkt.user_id->created && !selfsig)
 649                     {
 650                       tty_printf (_("User ID \"%s\" is not self-signed."),
 651                                   user);
 652
 653                       if (opt.expert)
 654                         {
 655                           tty_printf ("\n");
 656                           /* No, so remove the mark and continue */
 657                           if (!cpr_get_answer_is_yes ("sign_uid.nosig_okay",
 658                                                       _("Are you sure you "
 659                                                         "still want to sign "
 660                                                         "it? (y/N) ")))
 661                             {
 662                               uidnode->flag &= ~NODFLG_MARK_A;
 663                               uidnode = NULL;
 664                             }
 665                           else if (interactive)
 666                             yesreally = 1;
 667                         }
 668                       else
 669                         {
 670                           uidnode->flag &= ~NODFLG_MARK_A;
 671                           uidnode = NULL;
 672                           tty_printf (_("  Unable to sign.\n"));
 673                         }
 674                     }
 675
 676                   if (uidnode && interactive && !yesreally)
 677                     {
 678                       tty_printf (_("User ID \"%s\" is signable.  "), user);
 679                       if (!cpr_get_answer_is_yes ("sign_uid.sign_okay",
 680                                                   _("Sign it? (y/N) ")))
 681                         {
 682                           uidnode->flag &= ~NODFLG_MARK_A;
 683                           uidnode = NULL;
 684                         }
 685                     }
 686
 687                   xfree (user);
 688                 }
 689             }
 690           else if (uidnode && node->pkt->pkttype == PKT_SIGNATURE
 691                    && (node->pkt->pkt.signature->sig_class & ~3) == 0x10)
 692             {
 693               if (sk_keyid[0] == node->pkt->pkt.signature->keyid[0]
 694                   && sk_keyid[1] == node->pkt->pkt.signature->keyid[1])
 695                 {
 696                   char buf[50];
 697                   char *user;
 698
 699                   user = utf8_to_native (uidnode->pkt->pkt.user_id->name,
 700                                          uidnode->pkt->pkt.user_id->len, 0);
 701
 702                   /* It's a v3 self-sig.  Make it into a v4 self-sig? */
 703                   if (node->pkt->pkt.signature->version < 4 && selfsig)
 704                     {
 705                       tty_printf (_("The self-signature on \"%s\"\n"
 706                                     "is a PGP 2.x-style signature.\n"), user);
 707
 708                       /* Note that the regular PGP2 warning below
 709                          still applies if there are no v4 sigs on
 710                          this key at all. */
 711
 712                       if (opt.expert)
 713                         if (cpr_get_answer_is_yes ("sign_uid.v4_promote_okay",
 714                                                    _("Do you want to promote "
 715                                                      "it to an OpenPGP self-"
 716                                                      "signature? (y/N) ")))
 717                           {
 718                             force_v4 = 1;
 719                             node->flag |= NODFLG_DELSIG;
 720                             xfree (user);
 721                             continue;
 722                           }
 723                     }
 724
 725                   /* Is the current signature expired? */
 726                   if (node->pkt->pkt.signature->flags.expired)
 727                     {
 728                       tty_printf (_("Your current signature on \"%s\"\n"
 729                                     "has expired.\n"), user);
 730
 731                       if (cpr_get_answer_is_yes
 732                           ("sign_uid.replace_expired_okay",
 733                            _("Do you want to issue a "
 734                              "new signature to replace "
 735                              "the expired one? (y/N) ")))
 736                         {
 737                           /* Mark these for later deletion.  We
 738                              don't want to delete them here, just in
 739                              case the replacement signature doesn't
 740                              happen for some reason.  We only delete
 741                              these after the replacement is already
 742                              in place. */
 743
 744                           node->flag |= NODFLG_DELSIG;
 745                           xfree (user);
 746                           continue;
 747                         }
 748                     }
 749
 750                   if (!node->pkt->pkt.signature->flags.exportable && !local)
 751                     {
 752                       /* It's a local sig, and we want to make a
 753                          exportable sig. */
 754                       tty_printf (_("Your current signature on \"%s\"\n"
 755                                     "is a local signature.\n"), user);
 756
 757                       if (cpr_get_answer_is_yes
 758                           ("sign_uid.local_promote_okay",
 759                            _("Do you want to promote "
 760                              "it to a full exportable " "signature? (y/N) ")))
 761                         {
 762                           /* Mark these for later deletion.  We
 763                              don't want to delete them here, just in
 764                              case the replacement signature doesn't
 765                              happen for some reason.  We only delete
 766                              these after the replacement is already
 767                              in place. */
 768
 769                           node->flag |= NODFLG_DELSIG;
 770                           xfree (user);
 771                           continue;
 772                         }
 773                     }
 774
 775                   /* Fixme: see whether there is a revocation in which
 776                    * case we should allow to sign it again. */
 777                   if (!node->pkt->pkt.signature->flags.exportable && local)
 778                     tty_printf
 779                       (_("\"%s\" was already locally signed by key %s\n"),
 780                        user, keystr_from_pk (pk));
 781                   else
 782                     tty_printf (_("\"%s\" was already signed by key %s\n"),
 783                                 user, keystr_from_pk (pk));
 784
 785                   if (opt.expert
 786                       && cpr_get_answer_is_yes ("sign_uid.dupe_okay",
 787                                                 _("Do you want to sign it "
 788                                                   "again anyway? (y/N) ")))
 789                     {
 790                       /* Don't delete the old sig here since this is
 791                          an --expert thing. */
 792                       xfree (user);
 793                       continue;
 794                     }
 795
 796                   snprintf (buf, sizeof buf, "%08lX%08lX",
 797                             (ulong) pk->keyid[0], (ulong) pk->keyid[1]);
 798                   write_status_text (STATUS_ALREADY_SIGNED, buf);
 799                   uidnode->flag &= ~NODFLG_MARK_A;      /* remove mark */
 800
 801                   xfree (user);
 802                 }
 803             }
 804         }
 805
 806       /* Check whether any uids are left for signing.  */
 807       if (!count_uids_with_flag (keyblock, NODFLG_MARK_A))
 808         {
 809           tty_printf (_("Nothing to sign with key %s\n"),
 810                       keystr_from_pk (pk));
 811           continue;
 812         }
 813
 814       /* Ask whether we really should sign these user id(s). */
 815       tty_printf ("\n");
 816       show_key_with_all_names (keyblock, 1, 0, 1, 0, 0);
 817       tty_printf ("\n");
 818
 819       if (primary_pk->expiredate && !selfsig)
 820         {
 821           u32 now = make_timestamp ();
 822
 823           if (primary_pk->expiredate <= now)
 824             {
 825               tty_printf (_("This key has expired!"));
 826
 827               if (opt.expert)
 828                 {
 829                   tty_printf ("  ");
 830                   if (!cpr_get_answer_is_yes ("sign_uid.expired_okay",
 831                                               _("Are you sure you still "
 832                                                 "want to sign it? (y/N) ")))
 833                     continue;
 834                 }
 835               else
 836                 {
 837                   tty_printf (_("  Unable to sign.\n"));
 838                   continue;
 839                 }
 840             }
 841           else
 842             {
 843               tty_printf (_("This key is due to expire on %s.\n"),
 844                           expirestr_from_pk (primary_pk));
 845
 846               if (opt.ask_cert_expire)
 847                 {
 848                   char *answer = cpr_get ("sign_uid.expire",
 849                                           _("Do you want your signature to "
 850                                             "expire at the same time? (Y/n) "));
 851                   if (answer_is_yes_no_default (answer, 1))
 852                     {
 853                       /* This fixes the signature timestamp we're
 854                          going to make as now.  This is so the
 855                          expiration date is exactly correct, and not
 856                          a few seconds off (due to the time it takes
 857                          to answer the questions, enter the
 858                          passphrase, etc). */
 859                       timestamp = now;
 860                       duration = primary_pk->expiredate - now;
 861                       force_v4 = 1;
 862                     }
 863
 864                   cpr_kill_prompt ();
 865                   xfree (answer);
 866                 }
 867             }
 868         }
 869
 870       /* Only ask for duration if we haven't already set it to match
 871          the expiration of the pk */
 872       if (!duration && !selfsig)
 873         {
 874           if (opt.ask_cert_expire)
 875             duration = ask_expire_interval (1, opt.def_cert_expire);
 876           else
 877             duration = parse_expire_string (opt.def_cert_expire);
 878         }
 879
 880       if (duration)
 881         force_v4 = 1;
 882
 883       /* Is --pgp2 on, it's a v3 key, all the sigs on the key are
 884          currently v3 and we're about to sign it with a v4 sig?  If
 885          so, danger! */
 886       if (PGP2 && all_v3 &&
 887           (pk->version > 3 || force_v4) && primary_pk->version <= 3)
 888         {
 889           tty_printf (_("You may not make an OpenPGP signature on a "
 890                         "PGP 2.x key while in --pgp2 mode.\n"));
 891           tty_printf (_("This would make the key unusable in PGP 2.x.\n"));
 892
 893           if (opt.expert)
 894             {
 895               if (!cpr_get_answer_is_yes ("sign_uid.v4_on_v3_okay",
 896                                           _("Are you sure you still "
 897                                             "want to sign it? (y/N) ")))
 898                 continue;
 899
 900               all_v3 = 0;
 901             }
 902           else
 903             continue;
 904         }
 905
 906       if (selfsig)
 907         ;
 908       else
 909         {
 910           if (opt.batch || !opt.ask_cert_level)
 911             class = 0x10 + opt.def_cert_level;
 912           else
 913             {
 914               char *answer;
 915
 916               tty_printf (_("How carefully have you verified the key you are "
 917                             "about to sign actually belongs\nto the person "
 918                             "named above?  If you don't know what to "
 919                             "answer, enter \"0\".\n"));
 920               tty_printf ("\n");
 921               tty_printf (_("   (0) I will not answer.%s\n"),
 922                           opt.def_cert_level == 0 ? " (default)" : "");
 923               tty_printf (_("   (1) I have not checked at all.%s\n"),
 924                           opt.def_cert_level == 1 ? " (default)" : "");
 925               tty_printf (_("   (2) I have done casual checking.%s\n"),
 926                           opt.def_cert_level == 2 ? " (default)" : "");
 927               tty_printf (_("   (3) I have done very careful checking.%s\n"),
 928                           opt.def_cert_level == 3 ? " (default)" : "");
 929               tty_printf ("\n");
 930
 931               while (class == 0)
 932                 {
 933                   answer = cpr_get ("sign_uid.class",
 934                                     _("Your selection? "
 935                                       "(enter '?' for more information): "));
 936                   if (answer[0] == '\0')
 937                     class = 0x10 + opt.def_cert_level;  /* Default */
 938                   else if (ascii_strcasecmp (answer, "0") == 0)
 939                     class = 0x10;       /* Generic */
 940                   else if (ascii_strcasecmp (answer, "1") == 0)
 941                     class = 0x11;       /* Persona */
 942                   else if (ascii_strcasecmp (answer, "2") == 0)
 943                     class = 0x12;       /* Casual */
 944                   else if (ascii_strcasecmp (answer, "3") == 0)
 945                     class = 0x13;       /* Positive */
 946                   else
 947                     tty_printf (_("Invalid selection.\n"));
 948
 949                   xfree (answer);
 950                 }
 951             }
 952
 953           if (trust)
 954             trustsig_prompt (&trust_value, &trust_depth, &trust_regexp);
 955         }
 956
 957       p = get_user_id_native (sk_keyid);
 958       tty_printf (_("Are you sure that you want to sign this key with your\n"
 959                     "key \"%s\" (%s)\n"), p, keystr_from_pk (pk));
 960       xfree (p);
 961
 962       if (selfsig)
 963         {
 964           tty_printf ("\n");
 965           tty_printf (_("This will be a self-signature.\n"));
 966
 967           if (local)
 968             {
 969               tty_printf ("\n");
 970               tty_printf (_("WARNING: the signature will not be marked "
 971                             "as non-exportable.\n"));
 972             }
 973
 974           if (nonrevocable)
 975             {
 976               tty_printf ("\n");
 977               tty_printf (_("WARNING: the signature will not be marked "
 978                             "as non-revocable.\n"));
 979             }
 980         }
 981       else
 982         {
 983           if (local)
 984             {
 985               tty_printf ("\n");
 986               tty_printf
 987                 (_("The signature will be marked as non-exportable.\n"));
 988             }
 989
 990           if (nonrevocable)
 991             {
 992               tty_printf ("\n");
 993               tty_printf
 994                 (_("The signature will be marked as non-revocable.\n"));
 995             }
 996
 997           switch (class)
 998             {
 999             case 0x11:
1000               tty_printf ("\n");
1001               tty_printf (_("I have not checked this key at all.\n"));
1002               break;
1003
1004             case 0x12:
1005               tty_printf ("\n");
1006               tty_printf (_("I have checked this key casually.\n"));
1007               break;
1008
1009             case 0x13:
1010               tty_printf ("\n");
1011               tty_printf (_("I have checked this key very carefully.\n"));
1012               break;
1013             }
1014         }
1015
1016       tty_printf ("\n");
1017
1018       if (opt.batch && opt.answer_yes)
1019         ;
1020       else if (!cpr_get_answer_is_yes ("sign_uid.okay",
1021                                        _("Really sign? (y/N) ")))
1022         continue;
1023
1024       /* Now we can sign the user ids.  */
1025     reloop:  /* (Must use this, because we are modifing the list.)  */
1026       primary_pk = NULL;
1027       for (node = keyblock; node; node = node->next)
1028         {
1029           if (node->pkt->pkttype == PKT_PUBLIC_KEY)
1030             primary_pk = node->pkt->pkt.public_key;
1031           else if (node->pkt->pkttype == PKT_USER_ID
1032                    && (node->flag & NODFLG_MARK_A))
1033             {
1034               PACKET *pkt;
1035               PKT_signature *sig;
1036               struct sign_attrib attrib;
1037
1038               assert (primary_pk);
1039               memset (&attrib, 0, sizeof attrib);
1040               attrib.non_exportable = local;
1041               attrib.non_revocable = nonrevocable;
1042               attrib.trust_depth = trust_depth;
1043               attrib.trust_value = trust_value;
1044               attrib.trust_regexp = trust_regexp;
1045               node->flag &= ~NODFLG_MARK_A;
1046
1047               /* We force creation of a v4 signature for local
1048                * signatures, otherwise we would not generate the
1049                * subpacket with v3 keys and the signature becomes
1050                * exportable.  */
1051
1052               if (selfsig)
1053                 rc = make_keysig_packet (&sig, primary_pk,
1054                                          node->pkt->pkt.user_id,
1055                                          NULL,
1056                                          pk,
1057                                          0x13, 0, force_v4 ? 4 : 0, 0, 0,
1058                                          keygen_add_std_prefs, primary_pk,
1059                                          NULL);
1060               else
1061                 rc = make_keysig_packet (&sig, primary_pk,
1062                                          node->pkt->pkt.user_id,
1063                                          NULL,
1064                                          pk,
1065                                          class, 0, force_v4 ? 4 : 0,
1066                                          timestamp, duration,
1067                                          sign_mk_attrib, &attrib,
1068                                          NULL);
1069               if (rc)
1070                 {
1071                   log_error (_("signing failed: %s\n"), g10_errstr (rc));
1072                   goto leave;
1073                 }
1074
1075               *ret_modified = 1;        /* We changed the keyblock. */
1076               update_trust = 1;
1077
1078               pkt = xmalloc_clear (sizeof *pkt);
1079               pkt->pkttype = PKT_SIGNATURE;
1080               pkt->pkt.signature = sig;
1081               insert_kbnode (node, new_kbnode (pkt), PKT_SIGNATURE);
1082               goto reloop;
1083             }
1084         }
1085
1086       /* Delete any sigs that got promoted */
1087       for (node = keyblock; node; node = node->next)
1088         if (node->flag & NODFLG_DELSIG)
1089           delete_kbnode (node);
1090     } /* End loop over signators.  */
1091
1092 leave:
1093   release_sk_list (sk_list);
1094   return rc;
1095 }
1096
1097
1098 /*
1099  * Change the passphrase of the primary and all secondary keys.  Note
1100  * that it is common to use only one passphrase for the primary and
1101  * all subkeys.  However, this is now (since GnuPG 2.1) all up to the
1102  * gpg-agent.  Returns 0 on success or an error code.
1103  */
1104 static gpg_error_t
1105 change_passphrase (ctrl_t ctrl, kbnode_t keyblock)
1106 {
1107   gpg_error_t err;
1108   kbnode_t node;
1109   PKT_public_key *pk;
1110   int any;
1111   u32 keyid[2], subid[2];
1112   char *hexgrip = NULL;
1113   char *cache_nonce = NULL;
1114   char *passwd_nonce = NULL;
1115
1116   node = find_kbnode (keyblock, PKT_PUBLIC_KEY);
1117   if (!node)
1118     {
1119       log_error ("Oops; public key missing!\n");
1120       err = gpg_error (GPG_ERR_INTERNAL);
1121       goto leave;
1122     }
1123   pk = node->pkt->pkt.public_key;
1124   keyid_from_pk (pk, keyid);
1125
1126   /* Check whether it is likely that we will be able to change the
1127      passphrase for any subkey.  */
1128   for (any = 0, node = keyblock; node; node = node->next)
1129     {
1130       if (node->pkt->pkttype == PKT_PUBLIC_KEY
1131           || node->pkt->pkttype == PKT_PUBLIC_SUBKEY)
1132         {
1133           char *serialno;
1134
1135           pk = node->pkt->pkt.public_key;
1136           keyid_from_pk (pk, subid);
1137
1138           xfree (hexgrip);
1139           err = hexkeygrip_from_pk (pk, &hexgrip);
1140           if (err)
1141             goto leave;
1142           err = agent_get_keyinfo (ctrl, hexgrip, &serialno);
1143           if (!err && serialno)
1144             ; /* Key on card.  */
1145           else if (gpg_err_code (err) == GPG_ERR_NOT_FOUND)
1146             ; /* Maybe stub key. */
1147           else if (!err)
1148             any = 1; /* Key is known.  */
1149           else
1150             log_error ("key %s: error getting keyinfo from agent: %s\n",
1151                        keystr_with_sub (keyid, subid), gpg_strerror (err));
1152           xfree (serialno);
1153         }
1154     }
1155   err = 0;
1156   if (!any)
1157     {
1158       tty_printf (_("Key has only stub or on-card key items - "
1159                     "no passphrase to change.\n"));
1160       goto leave;
1161     }
1162
1163   /* Change the passphrase for all keys.  */
1164   for (any = 0, node = keyblock; node; node = node->next)
1165     {
1166       if (node->pkt->pkttype == PKT_PUBLIC_KEY
1167           || node->pkt->pkttype == PKT_PUBLIC_SUBKEY)
1168         {
1169           char *desc;
1170
1171           pk = node->pkt->pkt.public_key;
1172           keyid_from_pk (pk, subid);
1173
1174           xfree (hexgrip);
1175           err = hexkeygrip_from_pk (pk, &hexgrip);
1176           if (err)
1177             goto leave;
1178
1179           desc = gpg_format_keydesc (pk, 0, 1);
1180           err = agent_passwd (ctrl, hexgrip, desc, &cache_nonce, &passwd_nonce);
1181           xfree (desc);
1182
1183           if (err)
1184             log_log ((gpg_err_code (err) == GPG_ERR_CANCELED
1185                       || gpg_err_code (err) == GPG_ERR_FULLY_CANCELED)
1186                      ? JNLIB_LOG_INFO : JNLIB_LOG_ERROR,
1187                      _("key %s: error changing passphrase: %s\n"),
1188                        keystr_with_sub (keyid, subid),
1189                        gpg_strerror (err));
1190           if (gpg_err_code (err) == GPG_ERR_FULLY_CANCELED)
1191             break;
1192         }
1193     }
1194
1195  leave:
1196   xfree (hexgrip);
1197   xfree (cache_nonce);
1198   xfree (passwd_nonce);
1199   return err;
1200 }
1201
1202
1203 \f
1204 /*
1205  * There are some keys out (due to a bug in gnupg), where the sequence
1206  * of the packets is wrong.  This function fixes that.
1207  * Returns: true if the keyblock has been fixed.
1208  *
1209  * Note:  This function does not work if there is more than one user ID.
1210  */
1211 static int
1212 fix_keyblock (KBNODE keyblock)
1213 {
1214   KBNODE node, last, subkey;
1215   int fixed = 0;
1216
1217   /* Locate key signatures of class 0x10..0x13 behind sub key packets.  */
1218   for (subkey = last = NULL, node = keyblock; node;
1219        last = node, node = node->next)
1220     {
1221       switch (node->pkt->pkttype)
1222         {
1223         case PKT_PUBLIC_SUBKEY:
1224         case PKT_SECRET_SUBKEY:
1225           if (!subkey)
1226             subkey = last; /* Actually it is the one before the subkey.  */
1227           break;
1228         case PKT_SIGNATURE:
1229           if (subkey)
1230             {
1231               PKT_signature *sig = node->pkt->pkt.signature;
1232               if (sig->sig_class >= 0x10 && sig->sig_class <= 0x13)
1233                 {
1234                   log_info (_("moving a key signature to the correct place\n"));
1235                   last->next = node->next;
1236                   node->next = subkey->next;
1237                   subkey->next = node;
1238                   node = last;
1239                   fixed = 1;
1240                 }
1241             }
1242           break;
1243         default:
1244           break;
1245         }
1246     }
1247
1248   return fixed;
1249 }
1250
1251
1252 static int
1253 parse_sign_type (const char *str, int *localsig, int *nonrevokesig,
1254                  int *trustsig)
1255 {
1256   const char *p = str;
1257
1258   while (*p)
1259     {
1260       if (ascii_strncasecmp (p, "l", 1) == 0)
1261         {
1262           *localsig = 1;
1263           p++;
1264         }
1265       else if (ascii_strncasecmp (p, "nr", 2) == 0)
1266         {
1267           *nonrevokesig = 1;
1268           p += 2;
1269         }
1270       else if (ascii_strncasecmp (p, "t", 1) == 0)
1271         {
1272           *trustsig = 1;
1273           p++;
1274         }
1275       else
1276         return 0;
1277     }
1278
1279   return 1;
1280 }
1281
1282
1283 \f
1284 /*
1285  * Menu driven key editor.  If seckey_check is true, then a secret key
1286  * that matches username will be looked for.  If it is false, not all
1287  * commands will be available.
1288  *
1289  * Note: to keep track of certain selections we use node->mark MARKBIT_xxxx.
1290  */
1291
1292 /* Need an SK for this command */
1293 #define KEYEDIT_NEED_SK 1
1294 /* Cannot be viewing the SK for this command */
1295 #define KEYEDIT_NOT_SK  2
1296 /* Must be viewing the SK for this command */
1297 #define KEYEDIT_ONLY_SK 4
1298 /* Match the tail of the string */
1299 #define KEYEDIT_TAIL_MATCH 8
1300
1301 enum cmdids
1302 {
1303   cmdNONE = 0,
1304   cmdQUIT, cmdHELP, cmdFPR, cmdLIST, cmdSELUID, cmdCHECK, cmdSIGN,
1305   cmdREVSIG, cmdREVKEY, cmdREVUID, cmdDELSIG, cmdPRIMARY, cmdDEBUG,
1306   cmdSAVE, cmdADDUID, cmdADDPHOTO, cmdDELUID, cmdADDKEY, cmdDELKEY,
1307   cmdADDREVOKER, cmdTOGGLE, cmdSELKEY, cmdPASSWD, cmdTRUST, cmdPREF,
1308   cmdEXPIRE, cmdBACKSIGN, cmdENABLEKEY, cmdDISABLEKEY, cmdSHOWPREF,
1309   cmdSETPREF, cmdPREFKS, cmdNOTATION, cmdINVCMD, cmdSHOWPHOTO, cmdUPDTRUST,
1310   cmdCHKTRUST, cmdADDCARDKEY, cmdKEYTOCARD, cmdBKUPTOCARD, cmdCHECKBKUPKEY,
1311   cmdCLEAN, cmdMINIMIZE, cmdNOP
1312 };
1313
1314 static struct
1315 {
1316   const char *name;
1317   enum cmdids id;
1318   int flags;
1319   const char *desc;
1320 } cmds[] =
1321 {
1322   { "quit", cmdQUIT, 0, N_("quit this menu")},
1323   { "q", cmdQUIT, 0, NULL},
1324   { "save", cmdSAVE, 0, N_("save and quit")},
1325   { "help", cmdHELP, 0, N_("show this help")},
1326   { "?", cmdHELP, 0, NULL},
1327   { "fpr", cmdFPR, 0, N_("show key fingerprint")},
1328   { "list", cmdLIST, 0, N_("list key and user IDs")},
1329   { "l", cmdLIST, 0, NULL},
1330   { "uid", cmdSELUID, 0, N_("select user ID N")},
1331   { "key", cmdSELKEY, 0, N_("select subkey N")},
1332   { "check", cmdCHECK, 0, N_("check signatures")},
1333   { "c", cmdCHECK, 0, NULL},
1334   { "cross-certify", cmdBACKSIGN, KEYEDIT_NOT_SK | KEYEDIT_NEED_SK, NULL},
1335   { "backsign", cmdBACKSIGN, KEYEDIT_NOT_SK | KEYEDIT_NEED_SK, NULL},
1336   { "sign", cmdSIGN, KEYEDIT_NOT_SK | KEYEDIT_TAIL_MATCH,
1337     N_("sign selected user IDs [* see below for related commands]")},
1338   { "s", cmdSIGN, KEYEDIT_NOT_SK, NULL},
1339     /* "lsign" and friends will never match since "sign" comes first
1340        and it is a tail match.  They are just here so they show up in
1341        the help menu. */
1342   { "lsign", cmdNOP, 0, N_("sign selected user IDs locally")},
1343   { "tsign", cmdNOP, 0, N_("sign selected user IDs with a trust signature")},
1344   { "nrsign", cmdNOP, 0,
1345     N_("sign selected user IDs with a non-revocable signature")},
1346   { "debug", cmdDEBUG, 0, NULL},
1347   { "adduid", cmdADDUID, KEYEDIT_NOT_SK | KEYEDIT_NEED_SK, N_("add a user ID")},
1348   { "addphoto", cmdADDPHOTO, KEYEDIT_NOT_SK | KEYEDIT_NEED_SK,
1349     N_("add a photo ID")},
1350   { "deluid", cmdDELUID, KEYEDIT_NOT_SK, N_("delete selected user IDs")},
1351     /* delphoto is really deluid in disguise */
1352   { "delphoto", cmdDELUID, KEYEDIT_NOT_SK, NULL},
1353   { "addkey", cmdADDKEY, KEYEDIT_NOT_SK | KEYEDIT_NEED_SK, N_("add a subkey")},
1354 #ifdef ENABLE_CARD_SUPPORT
1355   { "addcardkey", cmdADDCARDKEY, KEYEDIT_NOT_SK | KEYEDIT_NEED_SK,
1356     N_("add a key to a smartcard")},
1357   { "keytocard", cmdKEYTOCARD, KEYEDIT_NEED_SK | KEYEDIT_ONLY_SK,
1358     N_("move a key to a smartcard")},
1359   { "bkuptocard", cmdBKUPTOCARD, KEYEDIT_NEED_SK | KEYEDIT_ONLY_SK,
1360     N_("move a backup key to a smartcard")},
1361   { "checkbkupkey", cmdCHECKBKUPKEY, KEYEDIT_NEED_SK | KEYEDIT_ONLY_SK, NULL},
1362 #endif /*ENABLE_CARD_SUPPORT */
1363   { "delkey", cmdDELKEY, KEYEDIT_NOT_SK, N_("delete selected subkeys")},
1364   { "addrevoker", cmdADDREVOKER, KEYEDIT_NOT_SK | KEYEDIT_NEED_SK,
1365     N_("add a revocation key")},
1366   { "delsig", cmdDELSIG, KEYEDIT_NOT_SK,
1367     N_("delete signatures from the selected user IDs")},
1368   { "expire", cmdEXPIRE, KEYEDIT_NOT_SK | KEYEDIT_NEED_SK,
1369     N_("change the expiration date for the key or selected subkeys")},
1370   { "primary", cmdPRIMARY, KEYEDIT_NOT_SK | KEYEDIT_NEED_SK,
1371     N_("flag the selected user ID as primary")},
1372   { "toggle", cmdTOGGLE, KEYEDIT_NEED_SK,
1373     N_("toggle between the secret and public key listings")},
1374   { "t", cmdTOGGLE, KEYEDIT_NEED_SK, NULL},
1375   { "pref", cmdPREF, KEYEDIT_NOT_SK, N_("list preferences (expert)")},
1376   { "showpref", cmdSHOWPREF, KEYEDIT_NOT_SK, N_("list preferences (verbose)")},
1377   { "setpref", cmdSETPREF, KEYEDIT_NOT_SK | KEYEDIT_NEED_SK,
1378     N_("set preference list for the selected user IDs")},
1379   { "updpref", cmdSETPREF, KEYEDIT_NOT_SK | KEYEDIT_NEED_SK, NULL},
1380   { "keyserver", cmdPREFKS, KEYEDIT_NOT_SK | KEYEDIT_NEED_SK,
1381     N_("set the preferred keyserver URL for the selected user IDs")},
1382   { "notation", cmdNOTATION, KEYEDIT_NOT_SK | KEYEDIT_NEED_SK,
1383     N_("set a notation for the selected user IDs")},
1384   { "passwd", cmdPASSWD, KEYEDIT_NOT_SK | KEYEDIT_NEED_SK,
1385     N_("change the passphrase")},
1386   { "password", cmdPASSWD, KEYEDIT_NOT_SK | KEYEDIT_NEED_SK, NULL},
1387   { "trust", cmdTRUST, KEYEDIT_NOT_SK, N_("change the ownertrust")},
1388   { "revsig", cmdREVSIG, KEYEDIT_NOT_SK,
1389     N_("revoke signatures on the selected user IDs")},
1390   { "revuid", cmdREVUID, KEYEDIT_NOT_SK | KEYEDIT_NEED_SK,
1391     N_("revoke selected user IDs")},
1392   { "revphoto", cmdREVUID, KEYEDIT_NOT_SK | KEYEDIT_NEED_SK, NULL},
1393   { "revkey", cmdREVKEY, KEYEDIT_NOT_SK | KEYEDIT_NEED_SK,
1394     N_("revoke key or selected subkeys")},
1395   { "enable", cmdENABLEKEY, KEYEDIT_NOT_SK, N_("enable key")},
1396   { "disable", cmdDISABLEKEY, KEYEDIT_NOT_SK, N_("disable key")},
1397   { "showphoto", cmdSHOWPHOTO, 0, N_("show selected photo IDs")},
1398   { "clean", cmdCLEAN, KEYEDIT_NOT_SK,
1399     N_("compact unusable user IDs and remove unusable signatures from key")},
1400   { "minimize", cmdMINIMIZE, KEYEDIT_NOT_SK,
1401     N_("compact unusable user IDs and remove all signatures from key")},
1402
1403   { NULL, cmdNONE, 0, NULL}
1404 };
1405
1406
1407 \f
1408 #ifdef HAVE_LIBREADLINE
1409
1410 /*
1411    These two functions are used by readline for command completion.
1412  */
1413
1414 static char *
1415 command_generator (const char *text, int state)
1416 {
1417   static int list_index, len;
1418   const char *name;
1419
1420   /* If this is a new word to complete, initialize now.  This includes
1421      saving the length of TEXT for efficiency, and initializing the
1422      index variable to 0. */
1423   if (!state)
1424     {
1425       list_index = 0;
1426       len = strlen (text);
1427     }
1428
1429   /* Return the next partial match */
1430   while ((name = cmds[list_index].name))
1431     {
1432       /* Only complete commands that have help text */
1433       if (cmds[list_index++].desc && strncmp (name, text, len) == 0)
1434         return strdup (name);
1435     }
1436
1437   return NULL;
1438 }
1439
1440 static char **
1441 keyedit_completion (const char *text, int start, int end)
1442 {
1443   /* If we are at the start of a line, we try and command-complete.
1444      If not, just do nothing for now. */
1445
1446   (void) end;
1447
1448   if (start == 0)
1449     return rl_completion_matches (text, command_generator);
1450
1451   rl_attempted_completion_over = 1;
1452
1453   return NULL;
1454 }
1455 #endif /* HAVE_LIBREADLINE */
1456
1457
1458 \f
1459 /* Main function of the menu driven key editor.  */
1460 void
1461 keyedit_menu (ctrl_t ctrl, const char *username, strlist_t locusr,
1462               strlist_t commands, int quiet, int seckey_check)
1463 {
1464   enum cmdids cmd = 0;
1465   gpg_error_t err = 0;
1466   KBNODE keyblock = NULL;
1467   KEYDB_HANDLE kdbhd = NULL;
1468   int have_seckey = 0;
1469   char *answer = NULL;
1470   int redisplay = 1;
1471   int modified = 0;
1472   int toggle;
1473   int have_commands = !!commands;
1474
1475   if (opt.command_fd != -1)
1476     ;
1477   else if (opt.batch && !have_commands)
1478     {
1479       log_error (_("can't do this in batch mode\n"));
1480       goto leave;
1481     }
1482
1483 #ifdef HAVE_W32_SYSTEM
1484   /* Due to Windows peculiarities we need to make sure that the
1485      trustdb stale check is done before we open another file
1486      (i.e. by searching for a key).  In theory we could make sure
1487      that the files are closed after use but the open/close caches
1488      inhibits that and flushing the cache right before the stale
1489      check is not easy to implement.  Thus we take the easy way out
1490      and run the stale check as early as possible.  Note, that for
1491      non- W32 platforms it is run indirectly trough a call to
1492      get_validity ().  */
1493   check_trustdb_stale ();
1494 #endif
1495
1496   /* Get the public key */
1497   err = get_pubkey_byname (ctrl, NULL, NULL, username, &keyblock, &kdbhd, 1, 1);
1498   if (err)
1499     goto leave;
1500   if (fix_keyblock (keyblock))
1501     modified++;
1502   if (collapse_uids (&keyblock))
1503     modified++;
1504   reorder_keyblock (keyblock);
1505   /* We modified the keyblock, so let's make sure the flags are
1506      right. */
1507   if (modified)
1508     merge_keys_and_selfsig (keyblock);
1509
1510   /* See whether we have a matching secret key.  */
1511   if (seckey_check)
1512     {
1513       have_seckey = !agent_probe_any_secret_key (ctrl, keyblock);
1514       if (have_seckey && !quiet)
1515         tty_printf (_("Secret key is available.\n"));
1516     }
1517
1518   toggle = 0;
1519
1520   /* Main command loop.  */
1521   for (;;)
1522     {
1523       int i, arg_number, photo;
1524       const char *arg_string = "";
1525       char *p;
1526       PKT_public_key *pk = keyblock->pkt->pkt.public_key;
1527
1528       tty_printf ("\n");
1529
1530       if (redisplay && !quiet)
1531         {
1532           show_key_with_all_names (keyblock, 0, 1, 0, 1, 0);
1533           tty_printf ("\n");
1534           redisplay = 0;
1535         }
1536       do
1537         {
1538           xfree (answer);
1539           if (have_commands)
1540             {
1541               if (commands)
1542                 {
1543                   answer = xstrdup (commands->d);
1544                   commands = commands->next;
1545                 }
1546               else if (opt.batch)
1547                 {
1548                   answer = xstrdup ("quit");
1549                 }
1550               else
1551                 have_commands = 0;
1552             }
1553           if (!have_commands)
1554             {
1555 #ifdef HAVE_LIBREADLINE
1556               tty_enable_completion (keyedit_completion);
1557 #endif
1558               answer = cpr_get_no_help ("keyedit.prompt", "gpg> ");
1559               cpr_kill_prompt ();
1560               tty_disable_completion ();
1561             }
1562           trim_spaces (answer);
1563         }
1564       while (*answer == '#');
1565
1566       arg_number = 0; /* Here is the init which egcc complains about.  */
1567       photo = 0;      /* Same here. */
1568       if (!*answer)
1569         cmd = cmdLIST;
1570       else if (*answer == CONTROL_D)
1571         cmd = cmdQUIT;
1572       else if (digitp (answer))
1573         {
1574           cmd = cmdSELUID;
1575           arg_number = atoi (answer);
1576         }
1577       else
1578         {
1579           if ((p = strchr (answer, ' ')))
1580             {
1581               *p++ = 0;
1582               trim_spaces (answer);
1583               trim_spaces (p);
1584               arg_number = atoi (p);
1585               arg_string = p;
1586             }
1587
1588           for (i = 0; cmds[i].name; i++)
1589             {
1590               if (cmds[i].flags & KEYEDIT_TAIL_MATCH)
1591                 {
1592                   size_t l = strlen (cmds[i].name);
1593                   size_t a = strlen (answer);
1594                   if (a >= l)
1595                     {
1596                       if (!ascii_strcasecmp (&answer[a - l], cmds[i].name))
1597                         {
1598                           answer[a - l] = '\0';
1599                           break;
1600                         }
1601                     }
1602                 }
1603               else if (!ascii_strcasecmp (answer, cmds[i].name))
1604                 break;
1605             }
1606           if ((cmds[i].flags & KEYEDIT_NEED_SK) && !have_seckey)
1607             {
1608               tty_printf (_("Need the secret key to do this.\n"));
1609               cmd = cmdNOP;
1610             }
1611           else if (((cmds[i].flags & KEYEDIT_NOT_SK) && have_seckey && toggle)
1612                    || ((cmds[i].flags & KEYEDIT_ONLY_SK) && have_seckey
1613                        && !toggle))
1614             {
1615               tty_printf (_("Please use the command \"toggle\" first.\n"));
1616               cmd = cmdNOP;
1617             }
1618           else
1619             cmd = cmds[i].id;
1620         }
1621
1622       /* Dispatch the command.  */
1623       switch (cmd)
1624         {
1625         case cmdHELP:
1626           for (i = 0; cmds[i].name; i++)
1627             {
1628               if ((cmds[i].flags & KEYEDIT_NEED_SK) && !have_seckey)
1629                 ; /* Skip those item if we do not have the secret key.  */
1630               else if (cmds[i].desc)
1631                 tty_printf ("%-11s %s\n", cmds[i].name, _(cmds[i].desc));
1632             }
1633
1634           tty_printf ("\n");
1635           tty_printf
1636             (_("* The 'sign' command may be prefixed with an 'l' for local "
1637                "signatures (lsign),\n"
1638                "  a 't' for trust signatures (tsign), an 'nr' for "
1639                "non-revocable signatures\n"
1640                "  (nrsign), or any combination thereof (ltsign, "
1641                "tnrsign, etc.).\n"));
1642           break;
1643
1644         case cmdLIST:
1645           redisplay = 1;
1646           break;
1647
1648         case cmdFPR:
1649           show_key_and_fingerprint (keyblock);
1650           break;
1651
1652         case cmdSELUID:
1653           if (strlen (arg_string) == NAMEHASH_LEN * 2)
1654             redisplay = menu_select_uid_namehash (keyblock, arg_string);
1655           else
1656             {
1657               if (*arg_string == '*'
1658                   && (!arg_string[1] || spacep (arg_string + 1)))
1659                 arg_number = -1;        /* Select all. */
1660               redisplay = menu_select_uid (keyblock, arg_number);
1661             }
1662           break;
1663
1664         case cmdSELKEY:
1665           {
1666             if (*arg_string == '*'
1667                 && (!arg_string[1] || spacep (arg_string + 1)))
1668               arg_number = -1;  /* Select all. */
1669             if (menu_select_key (keyblock, arg_number))
1670               redisplay = 1;
1671           }
1672           break;
1673
1674         case cmdCHECK:
1675           check_all_keysigs (keyblock, count_selected_uids (keyblock));
1676           break;
1677
1678         case cmdSIGN:
1679           {
1680             int localsig = 0, nonrevokesig = 0, trustsig = 0, interactive = 0;
1681
1682             if (pk->flags.revoked)
1683               {
1684                 tty_printf (_("Key is revoked."));
1685
1686                 if (opt.expert)
1687                   {
1688                     tty_printf ("  ");
1689                     if (!cpr_get_answer_is_yes
1690                         ("keyedit.sign_revoked.okay",
1691                          _("Are you sure you still want to sign it? (y/N) ")))
1692                       break;
1693                   }
1694                 else
1695                   {
1696                     tty_printf (_("  Unable to sign.\n"));
1697                     break;
1698                   }
1699               }
1700
1701             if (count_uids (keyblock) > 1 && !count_selected_uids (keyblock)
1702                 && !cpr_get_answer_is_yes ("keyedit.sign_all.okay",
1703                                            _("Really sign all user IDs?"
1704                                              " (y/N) ")))
1705               {
1706                 if (opt.interactive)
1707                   interactive = 1;
1708                 else
1709                   {
1710                     tty_printf (_("Hint: Select the user IDs to sign\n"));
1711                     have_commands = 0;
1712                     break;
1713                   }
1714
1715               }
1716             /* What sort of signing are we doing? */
1717             if (!parse_sign_type
1718                 (answer, &localsig, &nonrevokesig, &trustsig))
1719               {
1720                 tty_printf (_("Unknown signature type '%s'\n"), answer);
1721                 break;
1722               }
1723
1724             sign_uids (keyblock, locusr, &modified,
1725                        localsig, nonrevokesig, trustsig, interactive);
1726           }
1727           break;
1728
1729         case cmdDEBUG:
1730           dump_kbnode (keyblock);
1731           break;
1732
1733         case cmdTOGGLE:
1734           /* The toggle command is a leftover from old gpg versions
1735              where we worked with a secret and a public keyring.  It
1736              is not necessary anymore but we keep this command for the
1737              sake of scripts using it.  */
1738           toggle = !toggle;
1739           redisplay = 1;
1740           break;
1741
1742         case cmdADDPHOTO:
1743           if (RFC2440 || RFC1991 || PGP2)
1744             {
1745               tty_printf (_("This command is not allowed while in %s mode.\n"),
1746                           compliance_option_string ());
1747               break;
1748             }
1749           photo = 1;
1750           /* fall through */
1751         case cmdADDUID:
1752           if (menu_adduid (keyblock, photo, arg_string))
1753             {
1754               update_trust = 1;
1755               redisplay = 1;
1756               modified = 1;
1757               merge_keys_and_selfsig (keyblock);
1758             }
1759           break;
1760
1761         case cmdDELUID:
1762           {
1763             int n1;
1764
1765             if (!(n1 = count_selected_uids (keyblock)))
1766               tty_printf (_("You must select at least one user ID.\n"));
1767             else if (real_uids_left (keyblock) < 1)
1768               tty_printf (_("You can't delete the last user ID!\n"));
1769             else if (cpr_get_answer_is_yes
1770                      ("keyedit.remove.uid.okay",
1771                       n1 > 1 ? _("Really remove all selected user IDs? (y/N) ")
1772                       :        _("Really remove this user ID? (y/N) ")))
1773               {
1774                 menu_deluid (keyblock);
1775                 redisplay = 1;
1776                 modified = 1;
1777               }
1778           }
1779           break;
1780
1781         case cmdDELSIG:
1782           {
1783             int n1;
1784
1785             if (!(n1 = count_selected_uids (keyblock)))
1786               tty_printf (_("You must select at least one user ID.\n"));
1787             else if (menu_delsig (keyblock))
1788               {
1789                 /* No redisplay here, because it may scroll away some
1790                  * of the status output of this command.  */
1791                 modified = 1;
1792               }
1793           }
1794           break;
1795
1796         case cmdADDKEY:
1797           if (!generate_subkeypair (ctrl, keyblock))
1798             {
1799               redisplay = 1;
1800               modified = 1;
1801               merge_keys_and_selfsig (keyblock);
1802             }
1803           break;
1804
1805 #ifdef ENABLE_CARD_SUPPORT
1806         case cmdADDCARDKEY:
1807           if (!card_generate_subkey (keyblock))
1808             {
1809               redisplay = 1;
1810               modified = 1;
1811               merge_keys_and_selfsig (keyblock);
1812             }
1813           break;
1814
1815         case cmdKEYTOCARD:
1816           {
1817             KBNODE node = NULL;
1818             switch (count_selected_keys (keyblock))
1819               {
1820               case 0:
1821                 if (cpr_get_answer_is_yes
1822                     ("keyedit.keytocard.use_primary",
1823                      /* TRANSLATORS: Please take care: This is about
1824                         moving the key and not about removing it.  */
1825                      _("Really move the primary key? (y/N) ")))
1826                   node = keyblock;
1827                 break;
1828               case 1:
1829                 for (node = keyblock; node; node = node->next)
1830                   {
1831                     if (node->pkt->pkttype == PKT_PUBLIC_SUBKEY
1832                         && node->flag & NODFLG_SELKEY)
1833                       break;
1834                   }
1835                 break;
1836               default:
1837                 tty_printf (_("You must select exactly one key.\n"));
1838                 break;
1839               }
1840             if (node)
1841               {
1842                 PKT_public_key *xxpk = node->pkt->pkt.public_key;
1843                 if (card_store_subkey (node, xxpk ? xxpk->pubkey_usage : 0))
1844                   {
1845                     redisplay = 1;
1846                     /* Only the secret key has been modified; thus
1847                        there is no need to set the modified flag.  */
1848                   }
1849               }
1850           }
1851           break;
1852
1853         case cmdBKUPTOCARD:
1854         case cmdCHECKBKUPKEY:
1855           log_debug ("FIXME: This needs to be changed\n");
1856           {
1857             /* Ask for a filename, check whether this is really a
1858                backup key as generated by the card generation, parse
1859                that key and store it on card. */
1860             KBNODE node;
1861             const char *fname;
1862             PACKET *pkt;
1863             IOBUF a;
1864
1865             fname = arg_string;
1866             if (!*fname)
1867               {
1868                 tty_printf (_("Command expects a filename argument\n"));
1869                 break;
1870               }
1871
1872             /* Open that file.  */
1873             a = iobuf_open (fname);
1874             if (a && is_secured_file (iobuf_get_fd (a)))
1875               {
1876                 iobuf_close (a);
1877                 a = NULL;
1878                 gpg_err_set_errno (EPERM);
1879               }
1880             if (!a)
1881               {
1882                 tty_printf (_("Can't open '%s': %s\n"),
1883                             fname, strerror (errno));
1884                 break;
1885               }
1886
1887             /* Parse and check that file.  */
1888             pkt = xmalloc (sizeof *pkt);
1889             init_packet (pkt);
1890             err = parse_packet (a, pkt);
1891             iobuf_close (a);
1892             iobuf_ioctl (NULL, IOBUF_IOCTL_INVALIDATE_CACHE, 0, (char *) fname);
1893             if (!err && pkt->pkttype != PKT_SECRET_KEY
1894                 && pkt->pkttype != PKT_SECRET_SUBKEY)
1895               err = G10ERR_NO_SECKEY;
1896             if (err)
1897               {
1898                 tty_printf (_("Error reading backup key from '%s': %s\n"),
1899                             fname, g10_errstr (err));
1900                 free_packet (pkt);
1901                 xfree (pkt);
1902                 break;
1903               }
1904             node = new_kbnode (pkt);
1905
1906             if (cmd == cmdCHECKBKUPKEY)
1907               {
1908                 /* PKT_public_key *sk = node->pkt->pkt.secret_key; */
1909                 /* switch (is_secret_key_protected (sk)) */
1910                 /*   { */
1911                 /*   case 0:    /\* Not protected. *\/ */
1912                 /*     tty_printf (_("This key is not protected.\n")); */
1913                 /*     break; */
1914                 /*   case -1: */
1915                 /*     log_error (_("unknown key protection algorithm\n")); */
1916                 /*     break; */
1917                 /*   default: */
1918                 /*     if (sk->protect.s2k.mode == 1001) */
1919                 /*       tty_printf (_("Secret parts of key" */
1920                 /*                  " are not available.\n")); */
1921                 /*     if (sk->protect.s2k.mode == 1002) */
1922                 /*       tty_printf (_("Secret parts of key" */
1923                 /*                  " are stored on-card.\n")); */
1924                     /* else */
1925                     /*   check_secret_key (sk, 0); */
1926                   /* } */
1927               }
1928             else                /* Store it.  */
1929               {
1930                 if (card_store_subkey (node, 0))
1931                   {
1932                     redisplay = 1;
1933                     /* FIXME:sec_modified = 1;*/
1934                   }
1935               }
1936             release_kbnode (node);
1937           }
1938           break;
1939
1940 #endif /* ENABLE_CARD_SUPPORT */
1941
1942         case cmdDELKEY:
1943           {
1944             int n1;
1945
1946             if (!(n1 = count_selected_keys (keyblock)))
1947               tty_printf (_("You must select at least one key.\n"));
1948             else if (!cpr_get_answer_is_yes
1949                      ("keyedit.remove.subkey.okay",
1950                       n1 > 1 ? _("Do you really want to delete the "
1951                                  "selected keys? (y/N) ")
1952                       :  _("Do you really want to delete this key? (y/N) ")))
1953               ;
1954             else
1955               {
1956                 menu_delkey (keyblock);
1957                 redisplay = 1;
1958                 modified = 1;
1959               }
1960           }
1961           break;
1962
1963         case cmdADDREVOKER:
1964           {
1965             int sensitive = 0;
1966
1967             if (ascii_strcasecmp (arg_string, "sensitive") == 0)
1968               sensitive = 1;
1969             if (menu_addrevoker (ctrl, keyblock, sensitive))
1970               {
1971                 redisplay = 1;
1972                 modified = 1;
1973                 merge_keys_and_selfsig (keyblock);
1974               }
1975           }
1976           break;
1977
1978         case cmdREVUID:
1979           {
1980             int n1;
1981
1982             if (!(n1 = count_selected_uids (keyblock)))
1983               tty_printf (_("You must select at least one user ID.\n"));
1984             else if (cpr_get_answer_is_yes
1985                      ("keyedit.revoke.uid.okay",
1986                       n1 > 1 ? _("Really revoke all selected user IDs? (y/N) ")
1987                       :        _("Really revoke this user ID? (y/N) ")))
1988               {
1989                 if (menu_revuid (keyblock))
1990                   {
1991                     modified = 1;
1992                     redisplay = 1;
1993                   }
1994               }
1995           }
1996           break;
1997
1998         case cmdREVKEY:
1999           {
2000             int n1;
2001
2002             if (!(n1 = count_selected_keys (keyblock)))
2003               {
2004                 if (cpr_get_answer_is_yes ("keyedit.revoke.subkey.okay",
2005                                            _("Do you really want to revoke"
2006                                              " the entire key? (y/N) ")))
2007                   {
2008                     if (menu_revkey (keyblock))
2009                       modified = 1;
2010
2011                     redisplay = 1;
2012                   }
2013               }
2014             else if (cpr_get_answer_is_yes ("keyedit.revoke.subkey.okay",
2015                                             n1 > 1 ?
2016                                             _("Do you really want to revoke"
2017                                               " the selected subkeys? (y/N) ")
2018                                             : _("Do you really want to revoke"
2019                                                 " this subkey? (y/N) ")))
2020               {
2021                 if (menu_revsubkey (keyblock))
2022                   modified = 1;
2023
2024                 redisplay = 1;
2025               }
2026
2027             if (modified)
2028               merge_keys_and_selfsig (keyblock);
2029           }
2030           break;
2031
2032         case cmdEXPIRE:
2033           if (menu_expire (keyblock))
2034             {
2035               merge_keys_and_selfsig (keyblock);
2036               modified = 1;
2037               redisplay = 1;
2038             }
2039           break;
2040
2041         case cmdBACKSIGN:
2042           if (menu_backsign (keyblock))
2043             {
2044               modified = 1;
2045               redisplay = 1;
2046             }
2047           break;
2048
2049         case cmdPRIMARY:
2050           if (menu_set_primary_uid (keyblock))
2051             {
2052               merge_keys_and_selfsig (keyblock);
2053               modified = 1;
2054               redisplay = 1;
2055             }
2056           break;
2057
2058         case cmdPASSWD:
2059           change_passphrase (ctrl, keyblock);
2060           break;
2061
2062         case cmdTRUST:
2063           if (opt.trust_model == TM_EXTERNAL)
2064             {
2065               tty_printf (_("Owner trust may not be set while "
2066                             "using a user provided trust database\n"));
2067               break;
2068             }
2069
2070           show_key_with_all_names (keyblock, 0, 0, 0, 1, 0);
2071           tty_printf ("\n");
2072           if (edit_ownertrust (find_kbnode (keyblock,
2073                                             PKT_PUBLIC_KEY)->pkt->pkt.
2074                                public_key, 1))
2075             {
2076               redisplay = 1;
2077               /* No real need to set update_trust here as
2078                  edit_ownertrust() calls revalidation_mark()
2079                  anyway. */
2080               update_trust = 1;
2081             }
2082           break;
2083
2084         case cmdPREF:
2085           {
2086             int count = count_selected_uids (keyblock);
2087             assert (keyblock->pkt->pkttype == PKT_PUBLIC_KEY);
2088             show_names (keyblock, keyblock->pkt->pkt.public_key,
2089                         count ? NODFLG_SELUID : 0, 1);
2090           }
2091           break;
2092
2093         case cmdSHOWPREF:
2094           {
2095             int count = count_selected_uids (keyblock);
2096             assert (keyblock->pkt->pkttype == PKT_PUBLIC_KEY);
2097             show_names (keyblock, keyblock->pkt->pkt.public_key,
2098                         count ? NODFLG_SELUID : 0, 2);
2099           }
2100           break;
2101
2102         case cmdSETPREF:
2103           {
2104             PKT_user_id *tempuid;
2105
2106             keygen_set_std_prefs (!*arg_string ? "default" : arg_string, 0);
2107
2108             tempuid = keygen_get_std_prefs ();
2109             tty_printf (_("Set preference list to:\n"));
2110             show_prefs (tempuid, NULL, 1);
2111             free_user_id (tempuid);
2112
2113             if (cpr_get_answer_is_yes
2114                 ("keyedit.setpref.okay",
2115                  count_selected_uids (keyblock) ?
2116                  _("Really update the preferences"
2117                    " for the selected user IDs? (y/N) ")
2118                  : _("Really update the preferences? (y/N) ")))
2119               {
2120                 if (menu_set_preferences (keyblock))
2121                   {
2122                     merge_keys_and_selfsig (keyblock);
2123                     modified = 1;
2124                     redisplay = 1;
2125                   }
2126               }
2127           }
2128           break;
2129
2130         case cmdPREFKS:
2131           if (menu_set_keyserver_url (*arg_string ? arg_string : NULL,
2132                                       keyblock))
2133             {
2134               merge_keys_and_selfsig (keyblock);
2135               modified = 1;
2136               redisplay = 1;
2137             }
2138           break;
2139
2140         case cmdNOTATION:
2141           if (menu_set_notation (*arg_string ? arg_string : NULL,
2142                                  keyblock))
2143             {
2144               merge_keys_and_selfsig (keyblock);
2145               modified = 1;
2146               redisplay = 1;
2147             }
2148           break;
2149
2150         case cmdNOP:
2151           break;
2152
2153         case cmdREVSIG:
2154           if (menu_revsig (keyblock))
2155             {
2156               redisplay = 1;
2157               modified = 1;
2158             }
2159           break;
2160
2161         case cmdENABLEKEY:
2162         case cmdDISABLEKEY:
2163           if (enable_disable_key (keyblock, cmd == cmdDISABLEKEY))
2164             {
2165               redisplay = 1;
2166               modified = 1;
2167             }
2168           break;
2169
2170         case cmdSHOWPHOTO:
2171           menu_showphoto (keyblock);
2172           break;
2173
2174         case cmdCLEAN:
2175           if (menu_clean (keyblock, 0))
2176             redisplay = modified = 1;
2177           break;
2178
2179         case cmdMINIMIZE:
2180           if (menu_clean (keyblock, 1))
2181             redisplay = modified = 1;
2182           break;
2183
2184         case cmdQUIT:
2185           if (have_commands)
2186             goto leave;
2187           if (!modified)
2188             goto leave;
2189           if (!cpr_get_answer_is_yes ("keyedit.save.okay",
2190                                       _("Save changes? (y/N) ")))
2191             {
2192               if (cpr_enabled ()
2193                   || cpr_get_answer_is_yes ("keyedit.cancel.okay",
2194                                             _("Quit without saving? (y/N) ")))
2195                 goto leave;
2196               break;
2197             }
2198           /* fall thru */
2199         case cmdSAVE:
2200           if (modified)
2201             {
2202               err = keydb_update_keyblock (kdbhd, keyblock);
2203               if (err)
2204                 {
2205                   log_error (_("update failed: %s\n"), g10_errstr (err));
2206                   break;
2207                 }
2208             }
2209           else
2210             tty_printf (_("Key not changed so no update needed.\n"));
2211
2212           if (update_trust)
2213             {
2214               revalidation_mark ();
2215               update_trust = 0;
2216             }
2217           goto leave;
2218
2219         case cmdINVCMD:
2220         default:
2221           tty_printf ("\n");
2222           tty_printf (_("Invalid command  (try \"help\")\n"));
2223           break;
2224         }
2225     } /* End of the main command loop.  */
2226
2227  leave:
2228   release_kbnode (keyblock);
2229   keydb_release (kdbhd);
2230   xfree (answer);
2231 }
2232
2233
2234 /* Change the passphrase of the secret key identified by USERNAME.  */
2235 void
2236 keyedit_passwd (ctrl_t ctrl, const char *username)
2237 {
2238   gpg_error_t err;
2239   PKT_public_key *pk;
2240   kbnode_t keyblock = NULL;
2241
2242   pk = xtrycalloc (1, sizeof *pk);
2243   if (!pk)
2244     {
2245       err = gpg_error_from_syserror ();
2246       goto leave;
2247     }
2248   err = getkey_byname (NULL, pk, username, 1, &keyblock);
2249   if (err)
2250     goto leave;
2251
2252   err = change_passphrase (ctrl, keyblock);
2253
2254 leave:
2255   release_kbnode (keyblock);
2256   free_public_key (pk);
2257   if (err)
2258     {
2259       log_info ("error changing the passphrase for '%s': %s\n",
2260                 username, gpg_strerror (err));
2261       write_status_error ("keyedit.passwd", err);
2262     }
2263   else
2264     write_status_text (STATUS_SUCCESS, "keyedit.passwd");
2265 }
2266
2267
2268 static void
2269 tty_print_notations (int indent, PKT_signature * sig)
2270 {
2271   int first = 1;
2272   struct notation *notation, *nd;
2273
2274   if (indent < 0)
2275     {
2276       first = 0;
2277       indent = -indent;
2278     }
2279
2280   notation = sig_to_notation (sig);
2281
2282   for (nd = notation; nd; nd = nd->next)
2283     {
2284       if (!first)
2285         tty_printf ("%*s", indent, "");
2286       else
2287         first = 0;
2288
2289       tty_print_utf8_string (nd->name, strlen (nd->name));
2290       tty_printf ("=");
2291       tty_print_utf8_string (nd->value, strlen (nd->value));
2292       tty_printf ("\n");
2293     }
2294
2295   free_notation (notation);
2296 }
2297
2298
2299 /*
2300  * Show preferences of a public keyblock.
2301  */
2302 static void
2303 show_prefs (PKT_user_id * uid, PKT_signature * selfsig, int verbose)
2304 {
2305   const prefitem_t fake = { 0, 0 };
2306   const prefitem_t *prefs;
2307   int i;
2308
2309   if (!uid)
2310     return;
2311
2312   if (uid->prefs)
2313     prefs = uid->prefs;
2314   else if (verbose)
2315     prefs = &fake;
2316   else
2317     return;
2318
2319   if (verbose)
2320     {
2321       int any, des_seen = 0, sha1_seen = 0, uncomp_seen = 0;
2322
2323       tty_printf ("     ");
2324       tty_printf (_("Cipher: "));
2325       for (i = any = 0; prefs[i].type; i++)
2326         {
2327           if (prefs[i].type == PREFTYPE_SYM)
2328             {
2329               if (any)
2330                 tty_printf (", ");
2331               any = 1;
2332               /* We don't want to display strings for experimental algos */
2333               if (!openpgp_cipher_test_algo (prefs[i].value)
2334                   && prefs[i].value < 100)
2335                 tty_printf ("%s", openpgp_cipher_algo_name (prefs[i].value));
2336               else
2337                 tty_printf ("[%d]", prefs[i].value);
2338               if (prefs[i].value == CIPHER_ALGO_3DES)
2339                 des_seen = 1;
2340             }
2341         }
2342       if (!des_seen)
2343         {
2344           if (any)
2345             tty_printf (", ");
2346           tty_printf ("%s", openpgp_cipher_algo_name (CIPHER_ALGO_3DES));
2347         }
2348       tty_printf ("\n     ");
2349       tty_printf (_("Digest: "));
2350       for (i = any = 0; prefs[i].type; i++)
2351         {
2352           if (prefs[i].type == PREFTYPE_HASH)
2353             {
2354               if (any)
2355                 tty_printf (", ");
2356               any = 1;
2357               /* We don't want to display strings for experimental algos */
2358               if (!gcry_md_test_algo (prefs[i].value) && prefs[i].value < 100)
2359                 tty_printf ("%s", gcry_md_algo_name (prefs[i].value));
2360               else
2361                 tty_printf ("[%d]", prefs[i].value);
2362               if (prefs[i].value == DIGEST_ALGO_SHA1)
2363                 sha1_seen = 1;
2364             }
2365         }
2366       if (!sha1_seen)
2367         {
2368           if (any)
2369             tty_printf (", ");
2370           tty_printf ("%s", gcry_md_algo_name (DIGEST_ALGO_SHA1));
2371         }
2372       tty_printf ("\n     ");
2373       tty_printf (_("Compression: "));
2374       for (i = any = 0; prefs[i].type; i++)
2375         {
2376           if (prefs[i].type == PREFTYPE_ZIP)
2377             {
2378               const char *s = compress_algo_to_string (prefs[i].value);
2379
2380               if (any)
2381                 tty_printf (", ");
2382               any = 1;
2383               /* We don't want to display strings for experimental algos */
2384               if (s && prefs[i].value < 100)
2385                 tty_printf ("%s", s);
2386               else
2387                 tty_printf ("[%d]", prefs[i].value);
2388               if (prefs[i].value == COMPRESS_ALGO_NONE)
2389                 uncomp_seen = 1;
2390             }
2391         }
2392       if (!uncomp_seen)
2393         {
2394           if (any)
2395             tty_printf (", ");
2396           else
2397             {
2398               tty_printf ("%s", compress_algo_to_string (COMPRESS_ALGO_ZIP));
2399               tty_printf (", ");
2400             }
2401           tty_printf ("%s", compress_algo_to_string (COMPRESS_ALGO_NONE));
2402         }
2403       if (uid->flags.mdc || !uid->flags.ks_modify)
2404         {
2405           tty_printf ("\n     ");
2406           tty_printf (_("Features: "));
2407           any = 0;
2408           if (uid->flags.mdc)
2409             {
2410               tty_printf ("MDC");
2411               any = 1;
2412             }
2413           if (!uid->flags.ks_modify)
2414             {
2415               if (any)
2416                 tty_printf (", ");
2417               tty_printf (_("Keyserver no-modify"));
2418             }
2419         }
2420       tty_printf ("\n");
2421
2422       if (selfsig)
2423         {
2424           const byte *pref_ks;
2425           size_t pref_ks_len;
2426
2427           pref_ks = parse_sig_subpkt (selfsig->hashed,
2428                                       SIGSUBPKT_PREF_KS, &pref_ks_len);
2429           if (pref_ks && pref_ks_len)
2430             {
2431               tty_printf ("     ");
2432               tty_printf (_("Preferred keyserver: "));
2433               tty_print_utf8_string (pref_ks, pref_ks_len);
2434               tty_printf ("\n");
2435             }
2436
2437           if (selfsig->flags.notation)
2438             {
2439               tty_printf ("     ");
2440               tty_printf (_("Notations: "));
2441               tty_print_notations (5 + strlen (_("Notations: ")), selfsig);
2442             }
2443         }
2444     }
2445   else
2446     {
2447       tty_printf ("    ");
2448       for (i = 0; prefs[i].type; i++)
2449         {
2450           tty_printf (" %c%d", prefs[i].type == PREFTYPE_SYM ? 'S' :
2451                       prefs[i].type == PREFTYPE_HASH ? 'H' :
2452                       prefs[i].type == PREFTYPE_ZIP ? 'Z' : '?',
2453                       prefs[i].value);
2454         }
2455       if (uid->flags.mdc)
2456         tty_printf (" [mdc]");
2457       if (!uid->flags.ks_modify)
2458         tty_printf (" [no-ks-modify]");
2459       tty_printf ("\n");
2460     }
2461 }
2462
2463
2464 /* This is the version of show_key_with_all_names used when
2465    opt.with_colons is used.  It prints all available data in a easy to
2466    parse format and does not translate utf8 */
2467 static void
2468 show_key_with_all_names_colon (KBNODE keyblock)
2469 {
2470   KBNODE node;
2471   int i, j, ulti_hack = 0;
2472   byte pk_version = 0;
2473   PKT_public_key *primary = NULL;
2474
2475   /* the keys */
2476   for (node = keyblock; node; node = node->next)
2477     {
2478       if (node->pkt->pkttype == PKT_PUBLIC_KEY
2479           || (node->pkt->pkttype == PKT_PUBLIC_SUBKEY))
2480         {
2481           PKT_public_key *pk = node->pkt->pkt.public_key;
2482           u32 keyid[2];
2483
2484           if (node->pkt->pkttype == PKT_PUBLIC_KEY)
2485             {
2486               pk_version = pk->version;
2487               primary = pk;
2488             }
2489
2490           keyid_from_pk (pk, keyid);
2491
2492           fputs (node->pkt->pkttype == PKT_PUBLIC_KEY ? "pub:" : "sub:",
2493                  stdout);
2494           if (!pk->flags.valid)
2495             putchar ('i');
2496           else if (pk->flags.revoked)
2497             putchar ('r');
2498           else if (pk->has_expired)
2499             putchar ('e');
2500           else if (!(opt.fast_list_mode || opt.no_expensive_trust_checks))
2501             {
2502               int trust = get_validity_info (pk, NULL);
2503               if (trust == 'u')
2504                 ulti_hack = 1;
2505               putchar (trust);
2506             }
2507
2508           printf (":%u:%d:%08lX%08lX:%lu:%lu::",
2509                   nbits_from_pk (pk),
2510                   pk->pubkey_algo,
2511                   (ulong) keyid[0], (ulong) keyid[1],
2512                   (ulong) pk->timestamp, (ulong) pk->expiredate);
2513           if (node->pkt->pkttype == PKT_PUBLIC_KEY
2514               && !(opt.fast_list_mode || opt.no_expensive_trust_checks))
2515             putchar (get_ownertrust_info (pk));
2516           putchar (':');
2517           putchar (':');
2518           putchar (':');
2519           /* Print capabilities.  */
2520           if ((pk->pubkey_usage & PUBKEY_USAGE_ENC))
2521             putchar ('e');
2522           if ((pk->pubkey_usage & PUBKEY_USAGE_SIG))
2523             putchar ('s');
2524           if ((pk->pubkey_usage & PUBKEY_USAGE_CERT))
2525             putchar ('c');
2526           if ((pk->pubkey_usage & PUBKEY_USAGE_AUTH))
2527             putchar ('a');
2528           putchar ('\n');
2529
2530           print_fingerprint (pk, 0);
2531           print_revokers (pk);
2532         }
2533     }
2534
2535   /* the user ids */
2536   i = 0;
2537   for (node = keyblock; node; node = node->next)
2538     {
2539       if (node->pkt->pkttype == PKT_USER_ID)
2540         {
2541           PKT_user_id *uid = node->pkt->pkt.user_id;
2542
2543           ++i;
2544
2545           if (uid->attrib_data)
2546             printf ("uat:");
2547           else
2548             printf ("uid:");
2549
2550           if (uid->is_revoked)
2551             printf ("r::::::::");
2552           else if (uid->is_expired)
2553             printf ("e::::::::");
2554           else if (opt.fast_list_mode || opt.no_expensive_trust_checks)
2555             printf ("::::::::");
2556           else
2557             {
2558               int uid_validity;
2559
2560               if (primary && !ulti_hack)
2561                 uid_validity = get_validity_info (primary, uid);
2562               else
2563                 uid_validity = 'u';
2564               printf ("%c::::::::", uid_validity);
2565             }
2566
2567           if (uid->attrib_data)
2568             printf ("%u %lu", uid->numattribs, uid->attrib_len);
2569           else
2570             es_write_sanitized (es_stdout, uid->name, uid->len, ":", NULL);
2571
2572           putchar (':');
2573           /* signature class */
2574           putchar (':');
2575           /* capabilities */
2576           putchar (':');
2577           /* preferences */
2578           if (pk_version > 3 || uid->selfsigversion > 3)
2579             {
2580               const prefitem_t *prefs = uid->prefs;
2581
2582               for (j = 0; prefs && prefs[j].type; j++)
2583                 {
2584                   if (j)
2585                     putchar (' ');
2586                   printf ("%c%d", prefs[j].type == PREFTYPE_SYM ? 'S' :
2587                           prefs[j].type == PREFTYPE_HASH ? 'H' :
2588                           prefs[j].type == PREFTYPE_ZIP ? 'Z' : '?',
2589                           prefs[j].value);
2590                 }
2591               if (uid->flags.mdc)
2592                 printf (",mdc");
2593               if (!uid->flags.ks_modify)
2594                 printf (",no-ks-modify");
2595             }
2596           putchar (':');
2597           /* flags */
2598           printf ("%d,", i);
2599           if (uid->is_primary)
2600             putchar ('p');
2601           if (uid->is_revoked)
2602             putchar ('r');
2603           if (uid->is_expired)
2604             putchar ('e');
2605           if ((node->flag & NODFLG_SELUID))
2606             putchar ('s');
2607           if ((node->flag & NODFLG_MARK_A))
2608             putchar ('m');
2609           putchar (':');
2610           putchar ('\n');
2611         }
2612     }
2613 }
2614
2615 static void
2616 show_names (KBNODE keyblock, PKT_public_key * pk, unsigned int flag,
2617             int with_prefs)
2618 {
2619   KBNODE node;
2620   int i = 0;
2621
2622   for (node = keyblock; node; node = node->next)
2623     {
2624       if (node->pkt->pkttype == PKT_USER_ID && !is_deleted_kbnode (node))
2625         {
2626           PKT_user_id *uid = node->pkt->pkt.user_id;
2627           ++i;
2628           if (!flag || (flag && (node->flag & flag)))
2629             {
2630               if (!(flag & NODFLG_MARK_A) && pk)
2631                 tty_printf ("%s ", uid_trust_string_fixed (pk, uid));
2632
2633               if (flag & NODFLG_MARK_A)
2634                 tty_printf ("     ");
2635               else if (node->flag & NODFLG_SELUID)
2636                 tty_printf ("(%d)* ", i);
2637               else if (uid->is_primary)
2638                 tty_printf ("(%d). ", i);
2639               else
2640                 tty_printf ("(%d)  ", i);
2641               tty_print_utf8_string (uid->name, uid->len);
2642               tty_printf ("\n");
2643               if (with_prefs && pk)
2644                 {
2645                   if (pk->version > 3 || uid->selfsigversion > 3)
2646                     {
2647                       PKT_signature *selfsig = NULL;
2648                       KBNODE signode;
2649
2650                       for (signode = node->next;
2651                            signode && signode->pkt->pkttype == PKT_SIGNATURE;
2652                            signode = signode->next)
2653                         {
2654                           if (signode->pkt->pkt.signature->
2655                               flags.chosen_selfsig)
2656                             {
2657                               selfsig = signode->pkt->pkt.signature;
2658                               break;
2659                             }
2660                         }
2661
2662                       show_prefs (uid, selfsig, with_prefs == 2);
2663                     }
2664                   else
2665                     tty_printf (_("There are no preferences on a"
2666                                   " PGP 2.x-style user ID.\n"));
2667                 }
2668             }
2669         }
2670     }
2671 }
2672
2673
2674 /*
2675  * Display the key a the user ids, if only_marked is true, do only
2676  * so for user ids with mark A flag set and dont display the index number
2677  */
2678 static void
2679 show_key_with_all_names (KBNODE keyblock, int only_marked, int with_revoker,
2680                          int with_fpr, int with_subkeys, int with_prefs)
2681 {
2682   KBNODE node;
2683   int i;
2684   int do_warn = 0;
2685   PKT_public_key *primary = NULL;
2686
2687   if (opt.with_colons)
2688     {
2689       show_key_with_all_names_colon (keyblock);
2690       return;
2691     }
2692
2693   /* the keys */
2694   for (node = keyblock; node; node = node->next)
2695     {
2696       if (node->pkt->pkttype == PKT_PUBLIC_KEY
2697           || (with_subkeys && node->pkt->pkttype == PKT_PUBLIC_SUBKEY
2698               && !is_deleted_kbnode (node)))
2699         {
2700           PKT_public_key *pk = node->pkt->pkt.public_key;
2701           const char *otrust = "err", *trust = "err";
2702
2703           if (node->pkt->pkttype == PKT_PUBLIC_KEY)
2704             {
2705               /* do it here, so that debug messages don't clutter the
2706                * output */
2707               static int did_warn = 0;
2708
2709               trust = get_validity_string (pk, NULL);
2710               otrust = get_ownertrust_string (pk);
2711
2712               /* Show a warning once */
2713               if (!did_warn
2714                   && (get_validity (pk, NULL) & TRUST_FLAG_PENDING_CHECK))
2715                 {
2716                   did_warn = 1;
2717                   do_warn = 1;
2718                 }
2719
2720               primary = pk;
2721             }
2722
2723           if (pk->flags.revoked)
2724             {
2725               char *user = get_user_id_string_native (pk->revoked.keyid);
2726               tty_printf (_("The following key was revoked on"
2727                             " %s by %s key %s\n"),
2728                           revokestr_from_pk (pk),
2729                           gcry_pk_algo_name (pk->revoked.algo), user);
2730               xfree (user);
2731             }
2732
2733           if (with_revoker)
2734             {
2735               if (!pk->revkey && pk->numrevkeys)
2736                 BUG ();
2737               else
2738                 for (i = 0; i < pk->numrevkeys; i++)
2739                   {
2740                     u32 r_keyid[2];
2741                     char *user;
2742                     const char *algo;
2743
2744                     algo = gcry_pk_algo_name (pk->revkey[i].algid);
2745                     keyid_from_fingerprint (pk->revkey[i].fpr,
2746                                             MAX_FINGERPRINT_LEN, r_keyid);
2747
2748                     user = get_user_id_string_native (r_keyid);
2749                     tty_printf (_("This key may be revoked by %s key %s"),
2750                                 algo ? algo : "?", user);
2751
2752                     if (pk->revkey[i].class & 0x40)
2753                       {
2754                         tty_printf (" ");
2755                         tty_printf (_("(sensitive)"));
2756                       }
2757
2758                     tty_printf ("\n");
2759                     xfree (user);
2760                   }
2761             }
2762
2763           keyid_from_pk (pk, NULL);
2764           tty_printf ("%s%c %4u%c/%s  ",
2765                       node->pkt->pkttype == PKT_PUBLIC_KEY ? "pub" :
2766                       node->pkt->pkttype == PKT_PUBLIC_SUBKEY ? "sub" :
2767                       node->pkt->pkttype == PKT_SECRET_KEY ? "sec" : "ssb",
2768                       (node->flag & NODFLG_SELKEY) ? '*' : ' ',
2769                       nbits_from_pk (pk),
2770                       pubkey_letter (pk->pubkey_algo), keystr (pk->keyid));
2771
2772           tty_printf (_("created: %s"), datestr_from_pk (pk));
2773           tty_printf ("  ");
2774           if (pk->flags.revoked)
2775             tty_printf (_("revoked: %s"), revokestr_from_pk (pk));
2776           else if (pk->has_expired)
2777             tty_printf (_("expired: %s"), expirestr_from_pk (pk));
2778           else
2779             tty_printf (_("expires: %s"), expirestr_from_pk (pk));
2780           tty_printf ("  ");
2781           tty_printf (_("usage: %s"), usagestr_from_pk (pk));
2782           tty_printf ("\n");
2783
2784           if (pk->seckey_info
2785               && pk->seckey_info->is_protected
2786               && pk->seckey_info->s2k.mode == 1002)
2787             {
2788               tty_printf ("                     ");
2789               tty_printf (_("card-no: "));
2790               if (pk->seckey_info->ivlen == 16
2791                   && !memcmp (pk->seckey_info->iv,
2792                               "\xD2\x76\x00\x01\x24\x01", 6))
2793                 {
2794                   /* This is an OpenPGP card. */
2795                   for (i = 8; i < 14; i++)
2796                     {
2797                       if (i == 10)
2798                         tty_printf (" ");
2799                       tty_printf ("%02X", pk->seckey_info->iv[i]);
2800                     }
2801                 }
2802               else
2803                 {
2804                   /* Unknown card: Print all. */
2805                   for (i = 0; i < pk->seckey_info->ivlen; i++)
2806                     tty_printf ("%02X", pk->seckey_info->iv[i]);
2807                 }
2808               tty_printf ("\n");
2809             }
2810
2811           if (node->pkt->pkttype == PKT_PUBLIC_KEY
2812               || node->pkt->pkttype == PKT_SECRET_KEY)
2813             {
2814               if (opt.trust_model != TM_ALWAYS)
2815                 {
2816                   tty_printf ("%*s", (int) keystrlen () + 13, "");
2817                   /* Ownertrust is only meaningful for the PGP or
2818                      classic trust models */
2819                   if (opt.trust_model == TM_PGP
2820                       || opt.trust_model == TM_CLASSIC)
2821                     {
2822                       int width = 14 - strlen (otrust);
2823                       if (width <= 0)
2824                         width = 1;
2825                       tty_printf (_("trust: %s"), otrust);
2826                       tty_printf ("%*s", width, "");
2827                     }
2828
2829                   tty_printf (_("validity: %s"), trust);
2830                   tty_printf ("\n");
2831                 }
2832               if (node->pkt->pkttype == PKT_PUBLIC_KEY
2833                   && (get_ownertrust (pk) & TRUST_FLAG_DISABLED))
2834                 {
2835                   tty_printf ("*** ");
2836                   tty_printf (_("This key has been disabled"));
2837                   tty_printf ("\n");
2838                 }
2839             }
2840
2841           if ((node->pkt->pkttype == PKT_PUBLIC_KEY
2842                || node->pkt->pkttype == PKT_SECRET_KEY) && with_fpr)
2843             {
2844               print_fingerprint (pk, 2);
2845               tty_printf ("\n");
2846             }
2847         }
2848     }
2849
2850   show_names (keyblock, primary, only_marked ? NODFLG_MARK_A : 0, with_prefs);
2851
2852   if (do_warn)
2853     tty_printf (_("Please note that the shown key validity"
2854                   " is not necessarily correct\n"
2855                   "unless you restart the program.\n"));
2856 }
2857
2858
2859 /* Display basic key information.  This function is suitable to show
2860    information on the key without any dependencies on the trustdb or
2861    any other internal GnuPG stuff.  KEYBLOCK may either be a public or
2862    a secret key.*/
2863 void
2864 show_basic_key_info (KBNODE keyblock)
2865 {
2866   KBNODE node;
2867   int i;
2868
2869   /* The primary key */
2870   for (node = keyblock; node; node = node->next)
2871     {
2872       if (node->pkt->pkttype == PKT_PUBLIC_KEY
2873           || node->pkt->pkttype == PKT_SECRET_KEY)
2874         {
2875           PKT_public_key *pk = node->pkt->pkt.public_key;
2876
2877           /* Note, we use the same format string as in other show
2878              functions to make the translation job easier. */
2879           tty_printf ("%s  %4u%c/%s  ",
2880                       node->pkt->pkttype == PKT_PUBLIC_KEY ? "pub" :
2881                       node->pkt->pkttype == PKT_PUBLIC_SUBKEY ? "sub" :
2882                       node->pkt->pkttype == PKT_SECRET_KEY ? "sec" :"ssb",
2883                       nbits_from_pk (pk),
2884                       pubkey_letter (pk->pubkey_algo), keystr_from_pk (pk));
2885           tty_printf (_("created: %s"), datestr_from_pk (pk));
2886           tty_printf ("  ");
2887           tty_printf (_("expires: %s"), expirestr_from_pk (pk));
2888           tty_printf ("\n");
2889           print_fingerprint (pk, 3);
2890           tty_printf ("\n");
2891         }
2892     }
2893
2894   /* The user IDs. */
2895   for (i = 0, node = keyblock; node; node = node->next)
2896     {
2897       if (node->pkt->pkttype == PKT_USER_ID)
2898         {
2899           PKT_user_id *uid = node->pkt->pkt.user_id;
2900           ++i;
2901
2902           tty_printf ("     ");
2903           if (uid->is_revoked)
2904             tty_printf ("[%s] ", _("revoked"));
2905           else if (uid->is_expired)
2906             tty_printf ("[%s] ", _("expired"));
2907           tty_print_utf8_string (uid->name, uid->len);
2908           tty_printf ("\n");
2909         }
2910     }
2911 }
2912
2913 static void
2914 show_key_and_fingerprint (KBNODE keyblock)
2915 {
2916   KBNODE node;
2917   PKT_public_key *pk = NULL;
2918
2919   for (node = keyblock; node; node = node->next)
2920     {
2921       if (node->pkt->pkttype == PKT_PUBLIC_KEY)
2922         {
2923           pk = node->pkt->pkt.public_key;
2924           tty_printf ("pub   %4u%c/%s %s ",
2925                       nbits_from_pk (pk),
2926                       pubkey_letter (pk->pubkey_algo),
2927                       keystr_from_pk (pk), datestr_from_pk (pk));
2928         }
2929       else if (node->pkt->pkttype == PKT_USER_ID)
2930         {
2931           PKT_user_id *uid = node->pkt->pkt.user_id;
2932           tty_print_utf8_string (uid->name, uid->len);
2933           break;
2934         }
2935     }
2936   tty_printf ("\n");
2937   if (pk)
2938     print_fingerprint (pk, 2);
2939 }
2940
2941
2942 /* Show a warning if no uids on the key have the primary uid flag
2943    set. */
2944 static void
2945 no_primary_warning (KBNODE keyblock)
2946 {
2947   KBNODE node;
2948   int have_primary = 0, uid_count = 0;
2949
2950   /* TODO: if we ever start behaving differently with a primary or
2951      non-primary attribute ID, we will need to check for attributes
2952      here as well. */
2953
2954   for (node = keyblock; node; node = node->next)
2955     {
2956       if (node->pkt->pkttype == PKT_USER_ID
2957           && node->pkt->pkt.user_id->attrib_data == NULL)
2958         {
2959           uid_count++;
2960
2961           if (node->pkt->pkt.user_id->is_primary == 2)
2962             {
2963               have_primary = 1;
2964               break;
2965             }
2966         }
2967     }
2968
2969   if (uid_count > 1 && !have_primary)
2970     log_info (_
2971               ("WARNING: no user ID has been marked as primary.  This command"
2972                " may\n              cause a different user ID to become"
2973                " the assumed primary.\n"));
2974 }
2975
2976
2977 /*
2978  * Ask for a new user id, add the self-signature and update the keyblock.
2979  * Return true if there is a new user id
2980  */
2981 static int
2982 menu_adduid (KBNODE pub_keyblock, int photo, const char *photo_name)
2983 {
2984   PKT_user_id *uid;
2985   PKT_public_key *pk = NULL;
2986   PKT_signature *sig = NULL;
2987   PACKET *pkt;
2988   KBNODE node;
2989   KBNODE pub_where = NULL;
2990   gpg_error_t err;
2991
2992   for (node = pub_keyblock; node; pub_where = node, node = node->next)
2993     {
2994       if (node->pkt->pkttype == PKT_PUBLIC_KEY)
2995         pk = node->pkt->pkt.public_key;
2996       else if (node->pkt->pkttype == PKT_PUBLIC_SUBKEY)
2997         break;
2998     }
2999   if (!node) /* No subkey.  */
3000     pub_where = NULL;
3001   assert (pk);
3002
3003   if (photo)
3004     {
3005       int hasattrib = 0;
3006
3007       for (node = pub_keyblock; node; node = node->next)
3008         if (node->pkt->pkttype == PKT_USER_ID &&
3009             node->pkt->pkt.user_id->attrib_data != NULL)
3010           {
3011             hasattrib = 1;
3012             break;
3013           }
3014
3015       /* It is legal but bad for compatibility to add a photo ID to a
3016          v3 key as it means that PGP2 will not be able to use that key
3017          anymore.  Also, PGP may not expect a photo on a v3 key.
3018          Don't bother to ask this if the key already has a photo - any
3019          damage has already been done at that point. -dms */
3020       if (pk->version == 3 && !hasattrib)
3021         {
3022           if (opt.expert)
3023             {
3024               tty_printf (_("WARNING: This is a PGP2-style key.  "
3025                             "Adding a photo ID may cause some versions\n"
3026                             "         of PGP to reject this key.\n"));
3027
3028               if (!cpr_get_answer_is_yes ("keyedit.v3_photo.okay",
3029                                           _("Are you sure you still want "
3030                                             "to add it? (y/N) ")))
3031                 return 0;
3032             }
3033           else
3034             {
3035               tty_printf (_("You may not add a photo ID to "
3036                             "a PGP2-style key.\n"));
3037               return 0;
3038             }
3039         }
3040
3041       uid = generate_photo_id (pk, photo_name);
3042     }
3043   else
3044     uid = generate_user_id (pub_keyblock);
3045   if (!uid)
3046     return 0;
3047
3048   err = make_keysig_packet (&sig, pk, uid, NULL, pk, 0x13, 0, 0, 0, 0,
3049                             keygen_add_std_prefs, pk, NULL);
3050   if (err)
3051     {
3052       log_error ("signing failed: %s\n", g10_errstr (err));
3053       free_user_id (uid);
3054       return 0;
3055     }
3056
3057   /* Insert/append to public keyblock */
3058   pkt = xmalloc_clear (sizeof *pkt);
3059   pkt->pkttype = PKT_USER_ID;
3060   pkt->pkt.user_id = uid;
3061   node = new_kbnode (pkt);
3062   if (pub_where)
3063     insert_kbnode (pub_where, node, 0);
3064   else
3065     add_kbnode (pub_keyblock, node);
3066   pkt = xmalloc_clear (sizeof *pkt);
3067   pkt->pkttype = PKT_SIGNATURE;
3068   pkt->pkt.signature = copy_signature (NULL, sig);
3069   if (pub_where)
3070     insert_kbnode (node, new_kbnode (pkt), 0);
3071   else
3072     add_kbnode (pub_keyblock, new_kbnode (pkt));
3073   return 1;
3074 }
3075
3076
3077 /*
3078  * Remove all selected userids from the keyring
3079  */
3080 static void
3081 menu_deluid (KBNODE pub_keyblock)
3082 {
3083   KBNODE node;
3084   int selected = 0;
3085
3086   for (node = pub_keyblock; node; node = node->next)
3087     {
3088       if (node->pkt->pkttype == PKT_USER_ID)
3089         {
3090           selected = node->flag & NODFLG_SELUID;
3091           if (selected)
3092             {
3093               /* Only cause a trust update if we delete a
3094                  non-revoked user id */
3095               if (!node->pkt->pkt.user_id->is_revoked)
3096                 update_trust = 1;
3097               delete_kbnode (node);
3098             }
3099         }
3100       else if (selected && node->pkt->pkttype == PKT_SIGNATURE)
3101         delete_kbnode (node);
3102       else if (node->pkt->pkttype == PKT_PUBLIC_SUBKEY)
3103         selected = 0;
3104     }
3105   commit_kbnode (&pub_keyblock);
3106 }
3107
3108
3109 static int
3110 menu_delsig (KBNODE pub_keyblock)
3111 {
3112   KBNODE node;
3113   PKT_user_id *uid = NULL;
3114   int changed = 0;
3115
3116   for (node = pub_keyblock; node; node = node->next)
3117     {
3118       if (node->pkt->pkttype == PKT_USER_ID)
3119         {
3120           uid = (node->flag & NODFLG_SELUID) ? node->pkt->pkt.user_id : NULL;
3121         }
3122       else if (uid && node->pkt->pkttype == PKT_SIGNATURE)
3123         {
3124           int okay, valid, selfsig, inv_sig, no_key, other_err;
3125
3126           tty_printf ("uid  ");
3127           tty_print_utf8_string (uid->name, uid->len);
3128           tty_printf ("\n");
3129
3130           okay = inv_sig = no_key = other_err = 0;
3131           if (opt.with_colons)
3132             valid = print_and_check_one_sig_colon (pub_keyblock, node,
3133                                                    &inv_sig, &no_key,
3134                                                    &other_err, &selfsig, 1);
3135           else
3136             valid = print_and_check_one_sig (pub_keyblock, node,
3137                                              &inv_sig, &no_key, &other_err,
3138                                              &selfsig, 1);
3139
3140           if (valid)
3141             {
3142               okay = cpr_get_answer_yes_no_quit
3143                 ("keyedit.delsig.valid",
3144                  _("Delete this good signature? (y/N/q)"));
3145
3146               /* Only update trust if we delete a good signature.
3147                  The other two cases do not affect trust. */
3148               if (okay)
3149                 update_trust = 1;
3150             }
3151           else if (inv_sig || other_err)
3152             okay = cpr_get_answer_yes_no_quit
3153               ("keyedit.delsig.invalid",
3154                _("Delete this invalid signature? (y/N/q)"));
3155           else if (no_key)
3156             okay = cpr_get_answer_yes_no_quit
3157               ("keyedit.delsig.unknown",
3158                _("Delete this unknown signature? (y/N/q)"));
3159
3160           if (okay == -1)
3161             break;
3162           if (okay && selfsig
3163               && !cpr_get_answer_is_yes
3164               ("keyedit.delsig.selfsig",
3165                _("Really delete this self-signature? (y/N)")))
3166             okay = 0;
3167           if (okay)
3168             {
3169               delete_kbnode (node);
3170               changed++;
3171             }
3172
3173         }
3174       else if (node->pkt->pkttype == PKT_PUBLIC_SUBKEY)
3175         uid = NULL;
3176     }
3177
3178   if (changed)
3179     {
3180       commit_kbnode (&pub_keyblock);
3181       tty_printf (changed == 1 ? _("Deleted %d signature.\n")
3182                   : _("Deleted %d signatures.\n"), changed);
3183     }
3184   else
3185     tty_printf (_("Nothing deleted.\n"));
3186
3187   return changed;
3188 }
3189
3190
3191 static int
3192 menu_clean (KBNODE keyblock, int self_only)
3193 {
3194   KBNODE uidnode;
3195   int modified = 0, select_all = !count_selected_uids (keyblock);
3196
3197   for (uidnode = keyblock->next;
3198        uidnode && uidnode->pkt->pkttype != PKT_PUBLIC_SUBKEY;
3199        uidnode = uidnode->next)
3200     {
3201       if (uidnode->pkt->pkttype == PKT_USER_ID
3202           && (uidnode->flag & NODFLG_SELUID || select_all))
3203         {
3204           int uids = 0, sigs = 0;
3205           char *user = utf8_to_native (uidnode->pkt->pkt.user_id->name,
3206                                        uidnode->pkt->pkt.user_id->len,
3207                                        0);
3208
3209           clean_one_uid (keyblock, uidnode, opt.verbose, self_only, &uids,
3210                          &sigs);
3211           if (uids)
3212             {
3213               const char *reason;
3214
3215               if (uidnode->pkt->pkt.user_id->is_revoked)
3216                 reason = _("revoked");
3217               else if (uidnode->pkt->pkt.user_id->is_expired)
3218                 reason = _("expired");
3219               else
3220                 reason = _("invalid");
3221
3222               tty_printf (_("User ID \"%s\" compacted: %s\n"), user, reason);
3223
3224               modified = 1;
3225             }
3226           else if (sigs)
3227             {
3228               tty_printf (sigs == 1 ?
3229                           _("User ID \"%s\": %d signature removed\n") :
3230                           _("User ID \"%s\": %d signatures removed\n"),
3231                           user, sigs);
3232
3233               modified = 1;
3234             }
3235           else
3236             {
3237               tty_printf (self_only == 1 ?
3238                           _("User ID \"%s\": already minimized\n") :
3239                           _("User ID \"%s\": already clean\n"), user);
3240             }
3241
3242           xfree (user);
3243         }
3244     }
3245
3246   return modified;
3247 }
3248
3249
3250 /*
3251  * Remove some of the secondary keys
3252  */
3253 static void
3254 menu_delkey (KBNODE pub_keyblock)
3255 {
3256   KBNODE node;
3257   int selected = 0;
3258
3259   for (node = pub_keyblock; node; node = node->next)
3260     {
3261       if (node->pkt->pkttype == PKT_PUBLIC_SUBKEY)
3262         {
3263           selected = node->flag & NODFLG_SELKEY;
3264           if (selected)
3265             delete_kbnode (node);
3266         }
3267       else if (selected && node->pkt->pkttype == PKT_SIGNATURE)
3268         delete_kbnode (node);
3269       else
3270         selected = 0;
3271     }
3272   commit_kbnode (&pub_keyblock);
3273
3274   /* No need to set update_trust here since signing keys are no
3275      longer used to certify other keys, so there is no change in
3276      trust when revoking/removing them.   */
3277 }
3278
3279
3280 /*
3281  * Ask for a new revoker, create the self-signature and put it into
3282  * the keyblock.  Returns true if there is a new revoker.
3283  */
3284 static int
3285 menu_addrevoker (ctrl_t ctrl, kbnode_t pub_keyblock, int sensitive)
3286 {
3287   PKT_public_key *pk = NULL;
3288   PKT_public_key *revoker_pk = NULL;
3289   PKT_signature *sig = NULL;
3290   PACKET *pkt;
3291   struct revocation_key revkey;
3292   size_t fprlen;
3293   int rc;
3294
3295   assert (pub_keyblock->pkt->pkttype == PKT_PUBLIC_KEY);
3296
3297   pk = pub_keyblock->pkt->pkt.public_key;
3298
3299   if (pk->numrevkeys == 0 && pk->version == 3)
3300     {
3301       /* It is legal but bad for compatibility to add a revoker to a
3302          v3 key as it means that PGP2 will not be able to use that key
3303          anymore.  Also, PGP may not expect a revoker on a v3 key.
3304          Don't bother to ask this if the key already has a revoker -
3305          any damage has already been done at that point. -dms */
3306       if (opt.expert)
3307         {
3308           tty_printf (_("WARNING: This is a PGP 2.x-style key.  "
3309                         "Adding a designated revoker may cause\n"
3310                         "         some versions of PGP to reject this key.\n"));
3311
3312           if (!cpr_get_answer_is_yes ("keyedit.v3_revoker.okay",
3313                                       _("Are you sure you still want "
3314                                         "to add it? (y/N) ")))
3315             return 0;
3316         }
3317       else
3318         {
3319           tty_printf (_("You may not add a designated revoker to "
3320                         "a PGP 2.x-style key.\n"));
3321           return 0;
3322         }
3323     }
3324
3325   for (;;)
3326     {
3327       char *answer;
3328
3329       free_public_key (revoker_pk);
3330       revoker_pk = xmalloc_clear (sizeof (*revoker_pk));
3331
3332       tty_printf ("\n");
3333
3334       answer = cpr_get_utf8
3335         ("keyedit.add_revoker",
3336          _("Enter the user ID of the designated revoker: "));
3337       if (answer[0] == '\0' || answer[0] == CONTROL_D)
3338         {
3339           xfree (answer);
3340           goto fail;
3341         }
3342
3343       /* Note that I'm requesting CERT here, which usually implies
3344          primary keys only, but some casual testing shows that PGP and
3345          GnuPG both can handle a designated revocation from a subkey. */
3346       revoker_pk->req_usage = PUBKEY_USAGE_CERT;
3347       rc = get_pubkey_byname (ctrl, NULL, revoker_pk, answer, NULL, NULL, 1, 1);
3348       if (rc)
3349         {