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