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