gpg-connect-agent: Make it easier to connect to the dirmngr.
[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     {
1510       log_error (_("key \"%s\" not found: %s\n"), username, gpg_strerror (err));
1511       goto leave;
1512     }
1513   if (fix_keyblock (keyblock))
1514     modified++;
1515   if (collapse_uids (&keyblock))
1516     modified++;
1517   reorder_keyblock (keyblock);
1518   /* We modified the keyblock, so let's make sure the flags are
1519      right. */
1520   if (modified)
1521     merge_keys_and_selfsig (keyblock);
1522
1523   /* See whether we have a matching secret key.  */
1524   if (seckey_check)
1525     {
1526       have_seckey = !agent_probe_any_secret_key (ctrl, keyblock);
1527       if (have_seckey && !quiet)
1528         tty_printf (_("Secret key is available.\n"));
1529     }
1530
1531   toggle = 0;
1532
1533   /* Main command loop.  */
1534   for (;;)
1535     {
1536       int i, arg_number, photo;
1537       const char *arg_string = "";
1538       char *p;
1539       PKT_public_key *pk = keyblock->pkt->pkt.public_key;
1540
1541       tty_printf ("\n");
1542
1543       if (redisplay && !quiet)
1544         {
1545           show_key_with_all_names (keyblock, 0, 1, 0, 1, 0);
1546           tty_printf ("\n");
1547           redisplay = 0;
1548         }
1549       do
1550         {
1551           xfree (answer);
1552           if (have_commands)
1553             {
1554               if (commands)
1555                 {
1556                   answer = xstrdup (commands->d);
1557                   commands = commands->next;
1558                 }
1559               else if (opt.batch)
1560                 {
1561                   answer = xstrdup ("quit");
1562                 }
1563               else
1564                 have_commands = 0;
1565             }
1566           if (!have_commands)
1567             {
1568 #ifdef HAVE_LIBREADLINE
1569               tty_enable_completion (keyedit_completion);
1570 #endif
1571               answer = cpr_get_no_help ("keyedit.prompt", "gpg> ");
1572               cpr_kill_prompt ();
1573               tty_disable_completion ();
1574             }
1575           trim_spaces (answer);
1576         }
1577       while (*answer == '#');
1578
1579       arg_number = 0; /* Here is the init which egcc complains about.  */
1580       photo = 0;      /* Same here. */
1581       if (!*answer)
1582         cmd = cmdLIST;
1583       else if (*answer == CONTROL_D)
1584         cmd = cmdQUIT;
1585       else if (digitp (answer))
1586         {
1587           cmd = cmdSELUID;
1588           arg_number = atoi (answer);
1589         }
1590       else
1591         {
1592           if ((p = strchr (answer, ' ')))
1593             {
1594               *p++ = 0;
1595               trim_spaces (answer);
1596               trim_spaces (p);
1597               arg_number = atoi (p);
1598               arg_string = p;
1599             }
1600
1601           for (i = 0; cmds[i].name; i++)
1602             {
1603               if (cmds[i].flags & KEYEDIT_TAIL_MATCH)
1604                 {
1605                   size_t l = strlen (cmds[i].name);
1606                   size_t a = strlen (answer);
1607                   if (a >= l)
1608                     {
1609                       if (!ascii_strcasecmp (&answer[a - l], cmds[i].name))
1610                         {
1611                           answer[a - l] = '\0';
1612                           break;
1613                         }
1614                     }
1615                 }
1616               else if (!ascii_strcasecmp (answer, cmds[i].name))
1617                 break;
1618             }
1619           if ((cmds[i].flags & KEYEDIT_NEED_SK) && !have_seckey)
1620             {
1621               tty_printf (_("Need the secret key to do this.\n"));
1622               cmd = cmdNOP;
1623             }
1624           else if (((cmds[i].flags & KEYEDIT_NOT_SK) && have_seckey && toggle)
1625                    || ((cmds[i].flags & KEYEDIT_ONLY_SK) && have_seckey
1626                        && !toggle))
1627             {
1628               tty_printf (_("Please use the command \"toggle\" first.\n"));
1629               cmd = cmdNOP;
1630             }
1631           else
1632             cmd = cmds[i].id;
1633         }
1634
1635       /* Dispatch the command.  */
1636       switch (cmd)
1637         {
1638         case cmdHELP:
1639           for (i = 0; cmds[i].name; i++)
1640             {
1641               if ((cmds[i].flags & KEYEDIT_NEED_SK) && !have_seckey)
1642                 ; /* Skip those item if we do not have the secret key.  */
1643               else if (cmds[i].desc)
1644                 tty_printf ("%-11s %s\n", cmds[i].name, _(cmds[i].desc));
1645             }
1646
1647           tty_printf ("\n");
1648           tty_printf
1649             (_("* The 'sign' command may be prefixed with an 'l' for local "
1650                "signatures (lsign),\n"
1651                "  a 't' for trust signatures (tsign), an 'nr' for "
1652                "non-revocable signatures\n"
1653                "  (nrsign), or any combination thereof (ltsign, "
1654                "tnrsign, etc.).\n"));
1655           break;
1656
1657         case cmdLIST:
1658           redisplay = 1;
1659           break;
1660
1661         case cmdFPR:
1662           show_key_and_fingerprint (keyblock);
1663           break;
1664
1665         case cmdSELUID:
1666           if (strlen (arg_string) == NAMEHASH_LEN * 2)
1667             redisplay = menu_select_uid_namehash (keyblock, arg_string);
1668           else
1669             {
1670               if (*arg_string == '*'
1671                   && (!arg_string[1] || spacep (arg_string + 1)))
1672                 arg_number = -1;        /* Select all. */
1673               redisplay = menu_select_uid (keyblock, arg_number);
1674             }
1675           break;
1676
1677         case cmdSELKEY:
1678           {
1679             if (*arg_string == '*'
1680                 && (!arg_string[1] || spacep (arg_string + 1)))
1681               arg_number = -1;  /* Select all. */
1682             if (menu_select_key (keyblock, arg_number))
1683               redisplay = 1;
1684           }
1685           break;
1686
1687         case cmdCHECK:
1688           check_all_keysigs (keyblock, count_selected_uids (keyblock));
1689           break;
1690
1691         case cmdSIGN:
1692           {
1693             int localsig = 0, nonrevokesig = 0, trustsig = 0, interactive = 0;
1694
1695             if (pk->flags.revoked)
1696               {
1697                 tty_printf (_("Key is revoked."));
1698
1699                 if (opt.expert)
1700                   {
1701                     tty_printf ("  ");
1702                     if (!cpr_get_answer_is_yes
1703                         ("keyedit.sign_revoked.okay",
1704                          _("Are you sure you still want to sign it? (y/N) ")))
1705                       break;
1706                   }
1707                 else
1708                   {
1709                     tty_printf (_("  Unable to sign.\n"));
1710                     break;
1711                   }
1712               }
1713
1714             if (count_uids (keyblock) > 1 && !count_selected_uids (keyblock)
1715                 && !cpr_get_answer_is_yes ("keyedit.sign_all.okay",
1716                                            _("Really sign all user IDs?"
1717                                              " (y/N) ")))
1718               {
1719                 if (opt.interactive)
1720                   interactive = 1;
1721                 else
1722                   {
1723                     tty_printf (_("Hint: Select the user IDs to sign\n"));
1724                     have_commands = 0;
1725                     break;
1726                   }
1727
1728               }
1729             /* What sort of signing are we doing? */
1730             if (!parse_sign_type
1731                 (answer, &localsig, &nonrevokesig, &trustsig))
1732               {
1733                 tty_printf (_("Unknown signature type '%s'\n"), answer);
1734                 break;
1735               }
1736
1737             sign_uids (keyblock, locusr, &modified,
1738                        localsig, nonrevokesig, trustsig, interactive);
1739           }
1740           break;
1741
1742         case cmdDEBUG:
1743           dump_kbnode (keyblock);
1744           break;
1745
1746         case cmdTOGGLE:
1747           /* The toggle command is a leftover from old gpg versions
1748              where we worked with a secret and a public keyring.  It
1749              is not necessary anymore but we keep this command for the
1750              sake of scripts using it.  */
1751           toggle = !toggle;
1752           redisplay = 1;
1753           break;
1754
1755         case cmdADDPHOTO:
1756           if (RFC2440 || RFC1991 || PGP2)
1757             {
1758               tty_printf (_("This command is not allowed while in %s mode.\n"),
1759                           compliance_option_string ());
1760               break;
1761             }
1762           photo = 1;
1763           /* fall through */
1764         case cmdADDUID:
1765           if (menu_adduid (keyblock, photo, arg_string))
1766             {
1767               update_trust = 1;
1768               redisplay = 1;
1769               modified = 1;
1770               merge_keys_and_selfsig (keyblock);
1771             }
1772           break;
1773
1774         case cmdDELUID:
1775           {
1776             int n1;
1777
1778             if (!(n1 = count_selected_uids (keyblock)))
1779               tty_printf (_("You must select at least one user ID.\n"));
1780             else if (real_uids_left (keyblock) < 1)
1781               tty_printf (_("You can't delete the last user ID!\n"));
1782             else if (cpr_get_answer_is_yes
1783                      ("keyedit.remove.uid.okay",
1784                       n1 > 1 ? _("Really remove all selected user IDs? (y/N) ")
1785                       :        _("Really remove this user ID? (y/N) ")))
1786               {
1787                 menu_deluid (keyblock);
1788                 redisplay = 1;
1789                 modified = 1;
1790               }
1791           }
1792           break;
1793
1794         case cmdDELSIG:
1795           {
1796             int n1;
1797
1798             if (!(n1 = count_selected_uids (keyblock)))
1799               tty_printf (_("You must select at least one user ID.\n"));
1800             else if (menu_delsig (keyblock))
1801               {
1802                 /* No redisplay here, because it may scroll away some
1803                  * of the status output of this command.  */
1804                 modified = 1;
1805               }
1806           }
1807           break;
1808
1809         case cmdADDKEY:
1810           if (!generate_subkeypair (ctrl, keyblock))
1811             {
1812               redisplay = 1;
1813               modified = 1;
1814               merge_keys_and_selfsig (keyblock);
1815             }
1816           break;
1817
1818 #ifdef ENABLE_CARD_SUPPORT
1819         case cmdADDCARDKEY:
1820           if (!card_generate_subkey (keyblock))
1821             {
1822               redisplay = 1;
1823               modified = 1;
1824               merge_keys_and_selfsig (keyblock);
1825             }
1826           break;
1827
1828         case cmdKEYTOCARD:
1829           {
1830             KBNODE node = NULL;
1831             switch (count_selected_keys (keyblock))
1832               {
1833               case 0:
1834                 if (cpr_get_answer_is_yes
1835                     ("keyedit.keytocard.use_primary",
1836                      /* TRANSLATORS: Please take care: This is about
1837                         moving the key and not about removing it.  */
1838                      _("Really move the primary key? (y/N) ")))
1839                   node = keyblock;
1840                 break;
1841               case 1:
1842                 for (node = keyblock; node; node = node->next)
1843                   {
1844                     if (node->pkt->pkttype == PKT_PUBLIC_SUBKEY
1845                         && node->flag & NODFLG_SELKEY)
1846                       break;
1847                   }
1848                 break;
1849               default:
1850                 tty_printf (_("You must select exactly one key.\n"));
1851                 break;
1852               }
1853             if (node)
1854               {
1855                 PKT_public_key *xxpk = node->pkt->pkt.public_key;
1856                 if (card_store_subkey (node, xxpk ? xxpk->pubkey_usage : 0))
1857                   {
1858                     redisplay = 1;
1859                     /* Only the secret key has been modified; thus
1860                        there is no need to set the modified flag.  */
1861                   }
1862               }
1863           }
1864           break;
1865
1866         case cmdBKUPTOCARD:
1867         case cmdCHECKBKUPKEY:
1868           log_debug ("FIXME: This needs to be changed\n");
1869           {
1870             /* Ask for a filename, check whether this is really a
1871                backup key as generated by the card generation, parse
1872                that key and store it on card. */
1873             KBNODE node;
1874             const char *fname;
1875             PACKET *pkt;
1876             IOBUF a;
1877
1878             fname = arg_string;
1879             if (!*fname)
1880               {
1881                 tty_printf (_("Command expects a filename argument\n"));
1882                 break;
1883               }
1884
1885             /* Open that file.  */
1886             a = iobuf_open (fname);
1887             if (a && is_secured_file (iobuf_get_fd (a)))
1888               {
1889                 iobuf_close (a);
1890                 a = NULL;
1891                 gpg_err_set_errno (EPERM);
1892               }
1893             if (!a)
1894               {
1895                 tty_printf (_("Can't open '%s': %s\n"),
1896                             fname, strerror (errno));
1897                 break;
1898               }
1899
1900             /* Parse and check that file.  */
1901             pkt = xmalloc (sizeof *pkt);
1902             init_packet (pkt);
1903             err = parse_packet (a, pkt);
1904             iobuf_close (a);
1905             iobuf_ioctl (NULL, IOBUF_IOCTL_INVALIDATE_CACHE, 0, (char *) fname);
1906             if (!err && pkt->pkttype != PKT_SECRET_KEY
1907                 && pkt->pkttype != PKT_SECRET_SUBKEY)
1908               err = G10ERR_NO_SECKEY;
1909             if (err)
1910               {
1911                 tty_printf (_("Error reading backup key from '%s': %s\n"),
1912                             fname, g10_errstr (err));
1913                 free_packet (pkt);
1914                 xfree (pkt);
1915                 break;
1916               }
1917             node = new_kbnode (pkt);
1918
1919             if (cmd == cmdCHECKBKUPKEY)
1920               {
1921                 /* PKT_public_key *sk = node->pkt->pkt.secret_key; */
1922                 /* switch (is_secret_key_protected (sk)) */
1923                 /*   { */
1924                 /*   case 0:    /\* Not protected. *\/ */
1925                 /*     tty_printf (_("This key is not protected.\n")); */
1926                 /*     break; */
1927                 /*   case -1: */
1928                 /*     log_error (_("unknown key protection algorithm\n")); */
1929                 /*     break; */
1930                 /*   default: */
1931                 /*     if (sk->protect.s2k.mode == 1001) */
1932                 /*       tty_printf (_("Secret parts of key" */
1933                 /*                  " are not available.\n")); */
1934                 /*     if (sk->protect.s2k.mode == 1002) */
1935                 /*       tty_printf (_("Secret parts of key" */
1936                 /*                  " are stored on-card.\n")); */
1937                     /* else */
1938                     /*   check_secret_key (sk, 0); */
1939                   /* } */
1940               }
1941             else                /* Store it.  */
1942               {
1943                 if (card_store_subkey (node, 0))
1944                   {
1945                     redisplay = 1;
1946                     /* FIXME:sec_modified = 1;*/
1947                   }
1948               }
1949             release_kbnode (node);
1950           }
1951           break;
1952
1953 #endif /* ENABLE_CARD_SUPPORT */
1954
1955         case cmdDELKEY:
1956           {
1957             int n1;
1958
1959             if (!(n1 = count_selected_keys (keyblock)))
1960               tty_printf (_("You must select at least one key.\n"));
1961             else if (!cpr_get_answer_is_yes
1962                      ("keyedit.remove.subkey.okay",
1963                       n1 > 1 ? _("Do you really want to delete the "
1964                                  "selected keys? (y/N) ")
1965                       :  _("Do you really want to delete this key? (y/N) ")))
1966               ;
1967             else
1968               {
1969                 menu_delkey (keyblock);
1970                 redisplay = 1;
1971                 modified = 1;
1972               }
1973           }
1974           break;
1975
1976         case cmdADDREVOKER:
1977           {
1978             int sensitive = 0;
1979
1980             if (ascii_strcasecmp (arg_string, "sensitive") == 0)
1981               sensitive = 1;
1982             if (menu_addrevoker (ctrl, keyblock, sensitive))
1983               {
1984                 redisplay = 1;
1985                 modified = 1;
1986                 merge_keys_and_selfsig (keyblock);
1987               }
1988           }
1989           break;
1990
1991         case cmdREVUID:
1992           {
1993             int n1;
1994
1995             if (!(n1 = count_selected_uids (keyblock)))
1996               tty_printf (_("You must select at least one user ID.\n"));
1997             else if (cpr_get_answer_is_yes
1998                      ("keyedit.revoke.uid.okay",
1999                       n1 > 1 ? _("Really revoke all selected user IDs? (y/N) ")
2000                       :        _("Really revoke this user ID? (y/N) ")))
2001               {
2002                 if (menu_revuid (keyblock))
2003                   {
2004                     modified = 1;
2005                     redisplay = 1;
2006                   }
2007               }
2008           }
2009           break;
2010
2011         case cmdREVKEY:
2012           {
2013             int n1;
2014
2015             if (!(n1 = count_selected_keys (keyblock)))
2016               {
2017                 if (cpr_get_answer_is_yes ("keyedit.revoke.subkey.okay",
2018                                            _("Do you really want to revoke"
2019                                              " the entire key? (y/N) ")))
2020                   {
2021                     if (menu_revkey (keyblock))
2022                       modified = 1;
2023
2024                     redisplay = 1;
2025                   }
2026               }
2027             else if (cpr_get_answer_is_yes ("keyedit.revoke.subkey.okay",
2028                                             n1 > 1 ?
2029                                             _("Do you really want to revoke"
2030                                               " the selected subkeys? (y/N) ")
2031                                             : _("Do you really want to revoke"
2032                                                 " this subkey? (y/N) ")))
2033               {
2034                 if (menu_revsubkey (keyblock))
2035                   modified = 1;
2036
2037                 redisplay = 1;
2038               }
2039
2040             if (modified)
2041               merge_keys_and_selfsig (keyblock);
2042           }
2043           break;
2044
2045         case cmdEXPIRE:
2046           if (menu_expire (keyblock))
2047             {
2048               merge_keys_and_selfsig (keyblock);
2049               modified = 1;
2050               redisplay = 1;
2051             }
2052           break;
2053
2054         case cmdBACKSIGN:
2055           if (menu_backsign (keyblock))
2056             {
2057               modified = 1;
2058               redisplay = 1;
2059             }
2060           break;
2061
2062         case cmdPRIMARY:
2063           if (menu_set_primary_uid (keyblock))
2064             {
2065               merge_keys_and_selfsig (keyblock);
2066               modified = 1;
2067               redisplay = 1;
2068             }
2069           break;
2070
2071         case cmdPASSWD:
2072           change_passphrase (ctrl, keyblock);
2073           break;
2074
2075 #ifndef NO_TRUST_MODELS
2076         case cmdTRUST:
2077           if (opt.trust_model == TM_EXTERNAL)
2078             {
2079               tty_printf (_("Owner trust may not be set while "
2080                             "using a user provided trust database\n"));
2081               break;
2082             }
2083
2084           show_key_with_all_names (keyblock, 0, 0, 0, 1, 0);
2085           tty_printf ("\n");
2086           if (edit_ownertrust (find_kbnode (keyblock,
2087                                             PKT_PUBLIC_KEY)->pkt->pkt.
2088                                public_key, 1))
2089             {
2090               redisplay = 1;
2091               /* No real need to set update_trust here as
2092                  edit_ownertrust() calls revalidation_mark()
2093                  anyway. */
2094               update_trust = 1;
2095             }
2096           break;
2097 #endif /*!NO_TRUST_MODELS*/
2098
2099         case cmdPREF:
2100           {
2101             int count = count_selected_uids (keyblock);
2102             assert (keyblock->pkt->pkttype == PKT_PUBLIC_KEY);
2103             show_names (keyblock, keyblock->pkt->pkt.public_key,
2104                         count ? NODFLG_SELUID : 0, 1);
2105           }
2106           break;
2107
2108         case cmdSHOWPREF:
2109           {
2110             int count = count_selected_uids (keyblock);
2111             assert (keyblock->pkt->pkttype == PKT_PUBLIC_KEY);
2112             show_names (keyblock, keyblock->pkt->pkt.public_key,
2113                         count ? NODFLG_SELUID : 0, 2);
2114           }
2115           break;
2116
2117         case cmdSETPREF:
2118           {
2119             PKT_user_id *tempuid;
2120
2121             keygen_set_std_prefs (!*arg_string ? "default" : arg_string, 0);
2122
2123             tempuid = keygen_get_std_prefs ();
2124             tty_printf (_("Set preference list to:\n"));
2125             show_prefs (tempuid, NULL, 1);
2126             free_user_id (tempuid);
2127
2128             if (cpr_get_answer_is_yes
2129                 ("keyedit.setpref.okay",
2130                  count_selected_uids (keyblock) ?
2131                  _("Really update the preferences"
2132                    " for the selected user IDs? (y/N) ")
2133                  : _("Really update the preferences? (y/N) ")))
2134               {
2135                 if (menu_set_preferences (keyblock))
2136                   {
2137                     merge_keys_and_selfsig (keyblock);
2138                     modified = 1;
2139                     redisplay = 1;
2140                   }
2141               }
2142           }
2143           break;
2144
2145         case cmdPREFKS:
2146           if (menu_set_keyserver_url (*arg_string ? arg_string : NULL,
2147                                       keyblock))
2148             {
2149               merge_keys_and_selfsig (keyblock);
2150               modified = 1;
2151               redisplay = 1;
2152             }
2153           break;
2154
2155         case cmdNOTATION:
2156           if (menu_set_notation (*arg_string ? arg_string : NULL,
2157                                  keyblock))
2158             {
2159               merge_keys_and_selfsig (keyblock);
2160               modified = 1;
2161               redisplay = 1;
2162             }
2163           break;
2164
2165         case cmdNOP:
2166           break;
2167
2168         case cmdREVSIG:
2169           if (menu_revsig (keyblock))
2170             {
2171               redisplay = 1;
2172               modified = 1;
2173             }
2174           break;
2175
2176 #ifndef NO_TRUST_MODELS
2177         case cmdENABLEKEY:
2178         case cmdDISABLEKEY:
2179           if (enable_disable_key (keyblock, cmd == cmdDISABLEKEY))
2180             {
2181               redisplay = 1;
2182               modified = 1;
2183             }
2184           break;
2185 #endif /*!NO_TRUST_MODELS*/
2186
2187         case cmdSHOWPHOTO:
2188           menu_showphoto (keyblock);
2189           break;
2190
2191         case cmdCLEAN:
2192           if (menu_clean (keyblock, 0))
2193             redisplay = modified = 1;
2194           break;
2195
2196         case cmdMINIMIZE:
2197           if (menu_clean (keyblock, 1))
2198             redisplay = modified = 1;
2199           break;
2200
2201         case cmdQUIT:
2202           if (have_commands)
2203             goto leave;
2204           if (!modified)
2205             goto leave;
2206           if (!cpr_get_answer_is_yes ("keyedit.save.okay",
2207                                       _("Save changes? (y/N) ")))
2208             {
2209               if (cpr_enabled ()
2210                   || cpr_get_answer_is_yes ("keyedit.cancel.okay",
2211                                             _("Quit without saving? (y/N) ")))
2212                 goto leave;
2213               break;
2214             }
2215           /* fall thru */
2216         case cmdSAVE:
2217           if (modified)
2218             {
2219               err = keydb_update_keyblock (kdbhd, keyblock);
2220               if (err)
2221                 {
2222                   log_error (_("update failed: %s\n"), g10_errstr (err));
2223                   break;
2224                 }
2225             }
2226           else
2227             tty_printf (_("Key not changed so no update needed.\n"));
2228
2229           if (update_trust)
2230             {
2231               revalidation_mark ();
2232               update_trust = 0;
2233             }
2234           goto leave;
2235
2236         case cmdINVCMD:
2237         default:
2238           tty_printf ("\n");
2239           tty_printf (_("Invalid command  (try \"help\")\n"));
2240           break;
2241         }
2242     } /* End of the main command loop.  */
2243
2244  leave:
2245   release_kbnode (keyblock);
2246   keydb_release (kdbhd);
2247   xfree (answer);
2248 }
2249
2250
2251 /* Change the passphrase of the secret key identified by USERNAME.  */
2252 void
2253 keyedit_passwd (ctrl_t ctrl, const char *username)
2254 {
2255   gpg_error_t err;
2256   PKT_public_key *pk;
2257   kbnode_t keyblock = NULL;
2258
2259   pk = xtrycalloc (1, sizeof *pk);
2260   if (!pk)
2261     {
2262       err = gpg_error_from_syserror ();
2263       goto leave;
2264     }
2265   err = getkey_byname (NULL, pk, username, 1, &keyblock);
2266   if (err)
2267     goto leave;
2268
2269   err = change_passphrase (ctrl, keyblock);
2270
2271 leave:
2272   release_kbnode (keyblock);
2273   free_public_key (pk);
2274   if (err)
2275     {
2276       log_info ("error changing the passphrase for '%s': %s\n",
2277                 username, gpg_strerror (err));
2278       write_status_error ("keyedit.passwd", err);
2279     }
2280   else
2281     write_status_text (STATUS_SUCCESS, "keyedit.passwd");
2282 }
2283
2284
2285 static void
2286 tty_print_notations (int indent, PKT_signature * sig)
2287 {
2288   int first = 1;
2289   struct notation *notation, *nd;
2290
2291   if (indent < 0)
2292     {
2293       first = 0;
2294       indent = -indent;
2295     }
2296
2297   notation = sig_to_notation (sig);
2298
2299   for (nd = notation; nd; nd = nd->next)
2300     {
2301       if (!first)
2302         tty_printf ("%*s", indent, "");
2303       else
2304         first = 0;
2305
2306       tty_print_utf8_string (nd->name, strlen (nd->name));
2307       tty_printf ("=");
2308       tty_print_utf8_string (nd->value, strlen (nd->value));
2309       tty_printf ("\n");
2310     }
2311
2312   free_notation (notation);
2313 }
2314
2315
2316 /*
2317  * Show preferences of a public keyblock.
2318  */
2319 static void
2320 show_prefs (PKT_user_id * uid, PKT_signature * selfsig, int verbose)
2321 {
2322   const prefitem_t fake = { 0, 0 };
2323   const prefitem_t *prefs;
2324   int i;
2325
2326   if (!uid)
2327     return;
2328
2329   if (uid->prefs)
2330     prefs = uid->prefs;
2331   else if (verbose)
2332     prefs = &fake;
2333   else
2334     return;
2335
2336   if (verbose)
2337     {
2338       int any, des_seen = 0, sha1_seen = 0, uncomp_seen = 0;
2339
2340       tty_printf ("     ");
2341       tty_printf (_("Cipher: "));
2342       for (i = any = 0; prefs[i].type; i++)
2343         {
2344           if (prefs[i].type == PREFTYPE_SYM)
2345             {
2346               if (any)
2347                 tty_printf (", ");
2348               any = 1;
2349               /* We don't want to display strings for experimental algos */
2350               if (!openpgp_cipher_test_algo (prefs[i].value)
2351                   && prefs[i].value < 100)
2352                 tty_printf ("%s", openpgp_cipher_algo_name (prefs[i].value));
2353               else
2354                 tty_printf ("[%d]", prefs[i].value);
2355               if (prefs[i].value == CIPHER_ALGO_3DES)
2356                 des_seen = 1;
2357             }
2358         }
2359       if (!des_seen)
2360         {
2361           if (any)
2362             tty_printf (", ");
2363           tty_printf ("%s", openpgp_cipher_algo_name (CIPHER_ALGO_3DES));
2364         }
2365       tty_printf ("\n     ");
2366       tty_printf (_("Digest: "));
2367       for (i = any = 0; prefs[i].type; i++)
2368         {
2369           if (prefs[i].type == PREFTYPE_HASH)
2370             {
2371               if (any)
2372                 tty_printf (", ");
2373               any = 1;
2374               /* We don't want to display strings for experimental algos */
2375               if (!gcry_md_test_algo (prefs[i].value) && prefs[i].value < 100)
2376                 tty_printf ("%s", gcry_md_algo_name (prefs[i].value));
2377               else
2378                 tty_printf ("[%d]", prefs[i].value);
2379               if (prefs[i].value == DIGEST_ALGO_SHA1)
2380                 sha1_seen = 1;
2381             }
2382         }
2383       if (!sha1_seen)
2384         {
2385           if (any)
2386             tty_printf (", ");
2387           tty_printf ("%s", gcry_md_algo_name (DIGEST_ALGO_SHA1));
2388         }
2389       tty_printf ("\n     ");
2390       tty_printf (_("Compression: "));
2391       for (i = any = 0; prefs[i].type; i++)
2392         {
2393           if (prefs[i].type == PREFTYPE_ZIP)
2394             {
2395               const char *s = compress_algo_to_string (prefs[i].value);
2396
2397               if (any)
2398                 tty_printf (", ");
2399               any = 1;
2400               /* We don't want to display strings for experimental algos */
2401               if (s && prefs[i].value < 100)
2402                 tty_printf ("%s", s);
2403               else
2404                 tty_printf ("[%d]", prefs[i].value);
2405               if (prefs[i].value == COMPRESS_ALGO_NONE)
2406                 uncomp_seen = 1;
2407             }
2408         }
2409       if (!uncomp_seen)
2410         {
2411           if (any)
2412             tty_printf (", ");
2413           else
2414             {
2415               tty_printf ("%s", compress_algo_to_string (COMPRESS_ALGO_ZIP));
2416               tty_printf (", ");
2417             }
2418           tty_printf ("%s", compress_algo_to_string (COMPRESS_ALGO_NONE));
2419         }
2420       if (uid->flags.mdc || !uid->flags.ks_modify)
2421         {
2422           tty_printf ("\n     ");
2423           tty_printf (_("Features: "));
2424           any = 0;
2425           if (uid->flags.mdc)
2426             {
2427               tty_printf ("MDC");
2428               any = 1;
2429             }
2430           if (!uid->flags.ks_modify)
2431             {
2432               if (any)
2433                 tty_printf (", ");
2434               tty_printf (_("Keyserver no-modify"));
2435             }
2436         }
2437       tty_printf ("\n");
2438
2439       if (selfsig)
2440         {
2441           const byte *pref_ks;
2442           size_t pref_ks_len;
2443
2444           pref_ks = parse_sig_subpkt (selfsig->hashed,
2445                                       SIGSUBPKT_PREF_KS, &pref_ks_len);
2446           if (pref_ks && pref_ks_len)
2447             {
2448               tty_printf ("     ");
2449               tty_printf (_("Preferred keyserver: "));
2450               tty_print_utf8_string (pref_ks, pref_ks_len);
2451               tty_printf ("\n");
2452             }
2453
2454           if (selfsig->flags.notation)
2455             {
2456               tty_printf ("     ");
2457               tty_printf (_("Notations: "));
2458               tty_print_notations (5 + strlen (_("Notations: ")), selfsig);
2459             }
2460         }
2461     }
2462   else
2463     {
2464       tty_printf ("    ");
2465       for (i = 0; prefs[i].type; i++)
2466         {
2467           tty_printf (" %c%d", prefs[i].type == PREFTYPE_SYM ? 'S' :
2468                       prefs[i].type == PREFTYPE_HASH ? 'H' :
2469                       prefs[i].type == PREFTYPE_ZIP ? 'Z' : '?',
2470                       prefs[i].value);
2471         }
2472       if (uid->flags.mdc)
2473         tty_printf (" [mdc]");
2474       if (!uid->flags.ks_modify)
2475         tty_printf (" [no-ks-modify]");
2476       tty_printf ("\n");
2477     }
2478 }
2479
2480
2481 /* This is the version of show_key_with_all_names used when
2482    opt.with_colons is used.  It prints all available data in a easy to
2483    parse format and does not translate utf8 */
2484 static void
2485 show_key_with_all_names_colon (KBNODE keyblock)
2486 {
2487   KBNODE node;
2488   int i, j, ulti_hack = 0;
2489   byte pk_version = 0;
2490   PKT_public_key *primary = NULL;
2491
2492   /* the keys */
2493   for (node = keyblock; node; node = node->next)
2494     {
2495       if (node->pkt->pkttype == PKT_PUBLIC_KEY
2496           || (node->pkt->pkttype == PKT_PUBLIC_SUBKEY))
2497         {
2498           PKT_public_key *pk = node->pkt->pkt.public_key;
2499           u32 keyid[2];
2500
2501           if (node->pkt->pkttype == PKT_PUBLIC_KEY)
2502             {
2503               pk_version = pk->version;
2504               primary = pk;
2505             }
2506
2507           keyid_from_pk (pk, keyid);
2508
2509           fputs (node->pkt->pkttype == PKT_PUBLIC_KEY ? "pub:" : "sub:",
2510                  stdout);
2511           if (!pk->flags.valid)
2512             putchar ('i');
2513           else if (pk->flags.revoked)
2514             putchar ('r');
2515           else if (pk->has_expired)
2516             putchar ('e');
2517           else if (!(opt.fast_list_mode || opt.no_expensive_trust_checks))
2518             {
2519               int trust = get_validity_info (pk, NULL);
2520               if (trust == 'u')
2521                 ulti_hack = 1;
2522               putchar (trust);
2523             }
2524
2525           printf (":%u:%d:%08lX%08lX:%lu:%lu::",
2526                   nbits_from_pk (pk),
2527                   pk->pubkey_algo,
2528                   (ulong) keyid[0], (ulong) keyid[1],
2529                   (ulong) pk->timestamp, (ulong) pk->expiredate);
2530           if (node->pkt->pkttype == PKT_PUBLIC_KEY
2531               && !(opt.fast_list_mode || opt.no_expensive_trust_checks))
2532             putchar (get_ownertrust_info (pk));
2533           putchar (':');
2534           putchar (':');
2535           putchar (':');
2536           /* Print capabilities.  */
2537           if ((pk->pubkey_usage & PUBKEY_USAGE_ENC))
2538             putchar ('e');
2539           if ((pk->pubkey_usage & PUBKEY_USAGE_SIG))
2540             putchar ('s');
2541           if ((pk->pubkey_usage & PUBKEY_USAGE_CERT))
2542             putchar ('c');
2543           if ((pk->pubkey_usage & PUBKEY_USAGE_AUTH))
2544             putchar ('a');
2545           putchar ('\n');
2546
2547           print_fingerprint (pk, 0);
2548           print_revokers (pk);
2549         }
2550     }
2551
2552   /* the user ids */
2553   i = 0;
2554   for (node = keyblock; node; node = node->next)
2555     {
2556       if (node->pkt->pkttype == PKT_USER_ID)
2557         {
2558           PKT_user_id *uid = node->pkt->pkt.user_id;
2559
2560           ++i;
2561
2562           if (uid->attrib_data)
2563             printf ("uat:");
2564           else
2565             printf ("uid:");
2566
2567           if (uid->is_revoked)
2568             printf ("r::::::::");
2569           else if (uid->is_expired)
2570             printf ("e::::::::");
2571           else if (opt.fast_list_mode || opt.no_expensive_trust_checks)
2572             printf ("::::::::");
2573           else
2574             {
2575               int uid_validity;
2576
2577               if (primary && !ulti_hack)
2578                 uid_validity = get_validity_info (primary, uid);
2579               else
2580                 uid_validity = 'u';
2581               printf ("%c::::::::", uid_validity);
2582             }
2583
2584           if (uid->attrib_data)
2585             printf ("%u %lu", uid->numattribs, uid->attrib_len);
2586           else
2587             es_write_sanitized (es_stdout, uid->name, uid->len, ":", NULL);
2588
2589           putchar (':');
2590           /* signature class */
2591           putchar (':');
2592           /* capabilities */
2593           putchar (':');
2594           /* preferences */
2595           if (pk_version > 3 || uid->selfsigversion > 3)
2596             {
2597               const prefitem_t *prefs = uid->prefs;
2598
2599               for (j = 0; prefs && prefs[j].type; j++)
2600                 {
2601                   if (j)
2602                     putchar (' ');
2603                   printf ("%c%d", prefs[j].type == PREFTYPE_SYM ? 'S' :
2604                           prefs[j].type == PREFTYPE_HASH ? 'H' :
2605                           prefs[j].type == PREFTYPE_ZIP ? 'Z' : '?',
2606                           prefs[j].value);
2607                 }
2608               if (uid->flags.mdc)
2609                 printf (",mdc");
2610               if (!uid->flags.ks_modify)
2611                 printf (",no-ks-modify");
2612             }
2613           putchar (':');
2614           /* flags */
2615           printf ("%d,", i);
2616           if (uid->is_primary)
2617             putchar ('p');
2618           if (uid->is_revoked)
2619             putchar ('r');
2620           if (uid->is_expired)
2621             putchar ('e');
2622           if ((node->flag & NODFLG_SELUID))
2623             putchar ('s');
2624           if ((node->flag & NODFLG_MARK_A))
2625             putchar ('m');
2626           putchar (':');
2627           putchar ('\n');
2628         }
2629     }
2630 }
2631
2632 static void
2633 show_names (KBNODE keyblock, PKT_public_key * pk, unsigned int flag,
2634             int with_prefs)
2635 {
2636   KBNODE node;
2637   int i = 0;
2638
2639   for (node = keyblock; node; node = node->next)
2640     {
2641       if (node->pkt->pkttype == PKT_USER_ID && !is_deleted_kbnode (node))
2642         {
2643           PKT_user_id *uid = node->pkt->pkt.user_id;
2644           ++i;
2645           if (!flag || (flag && (node->flag & flag)))
2646             {
2647               if (!(flag & NODFLG_MARK_A) && pk)
2648                 tty_printf ("%s ", uid_trust_string_fixed (pk, uid));
2649
2650               if (flag & NODFLG_MARK_A)
2651                 tty_printf ("     ");
2652               else if (node->flag & NODFLG_SELUID)
2653                 tty_printf ("(%d)* ", i);
2654               else if (uid->is_primary)
2655                 tty_printf ("(%d). ", i);
2656               else
2657                 tty_printf ("(%d)  ", i);
2658               tty_print_utf8_string (uid->name, uid->len);
2659               tty_printf ("\n");
2660               if (with_prefs && pk)
2661                 {
2662                   if (pk->version > 3 || uid->selfsigversion > 3)
2663                     {
2664                       PKT_signature *selfsig = NULL;
2665                       KBNODE signode;
2666
2667                       for (signode = node->next;
2668                            signode && signode->pkt->pkttype == PKT_SIGNATURE;
2669                            signode = signode->next)
2670                         {
2671                           if (signode->pkt->pkt.signature->
2672                               flags.chosen_selfsig)
2673                             {
2674                               selfsig = signode->pkt->pkt.signature;
2675                               break;
2676                             }
2677                         }
2678
2679                       show_prefs (uid, selfsig, with_prefs == 2);
2680                     }
2681                   else
2682                     tty_printf (_("There are no preferences on a"
2683                                   " PGP 2.x-style user ID.\n"));
2684                 }
2685             }
2686         }
2687     }
2688 }
2689
2690
2691 /*
2692  * Display the key a the user ids, if only_marked is true, do only
2693  * so for user ids with mark A flag set and dont display the index number
2694  */
2695 static void
2696 show_key_with_all_names (KBNODE keyblock, int only_marked, int with_revoker,
2697                          int with_fpr, int with_subkeys, int with_prefs)
2698 {
2699   KBNODE node;
2700   int i;
2701   int do_warn = 0;
2702   PKT_public_key *primary = NULL;
2703   char pkstrbuf[PUBKEY_STRING_SIZE];
2704
2705   if (opt.with_colons)
2706     {
2707       show_key_with_all_names_colon (keyblock);
2708       return;
2709     }
2710
2711   /* the keys */
2712   for (node = keyblock; node; node = node->next)
2713     {
2714       if (node->pkt->pkttype == PKT_PUBLIC_KEY
2715           || (with_subkeys && node->pkt->pkttype == PKT_PUBLIC_SUBKEY
2716               && !is_deleted_kbnode (node)))
2717         {
2718           PKT_public_key *pk = node->pkt->pkt.public_key;
2719           const char *otrust = "err", *trust = "err";
2720
2721           if (node->pkt->pkttype == PKT_PUBLIC_KEY)
2722             {
2723               /* do it here, so that debug messages don't clutter the
2724                * output */
2725               static int did_warn = 0;
2726
2727               trust = get_validity_string (pk, NULL);
2728               otrust = get_ownertrust_string (pk);
2729
2730               /* Show a warning once */
2731               if (!did_warn
2732                   && (get_validity (pk, NULL) & TRUST_FLAG_PENDING_CHECK))
2733                 {
2734                   did_warn = 1;
2735                   do_warn = 1;
2736                 }
2737
2738               primary = pk;
2739             }
2740
2741           if (pk->flags.revoked)
2742             {
2743               char *user = get_user_id_string_native (pk->revoked.keyid);
2744               tty_printf (_("The following key was revoked on"
2745                             " %s by %s key %s\n"),
2746                           revokestr_from_pk (pk),
2747                           gcry_pk_algo_name (pk->revoked.algo), user);
2748               xfree (user);
2749             }
2750
2751           if (with_revoker)
2752             {
2753               if (!pk->revkey && pk->numrevkeys)
2754                 BUG ();
2755               else
2756                 for (i = 0; i < pk->numrevkeys; i++)
2757                   {
2758                     u32 r_keyid[2];
2759                     char *user;
2760                     const char *algo;
2761
2762                     algo = gcry_pk_algo_name (pk->revkey[i].algid);
2763                     keyid_from_fingerprint (pk->revkey[i].fpr,
2764                                             MAX_FINGERPRINT_LEN, r_keyid);
2765
2766                     user = get_user_id_string_native (r_keyid);
2767                     tty_printf (_("This key may be revoked by %s key %s"),
2768                                 algo ? algo : "?", user);
2769
2770                     if (pk->revkey[i].class & 0x40)
2771                       {
2772                         tty_printf (" ");
2773                         tty_printf (_("(sensitive)"));
2774                       }
2775
2776                     tty_printf ("\n");
2777                     xfree (user);
2778                   }
2779             }
2780
2781           keyid_from_pk (pk, NULL);
2782           tty_printf ("%s%c %s/%s",
2783                       node->pkt->pkttype == PKT_PUBLIC_KEY ? "pub" :
2784                       node->pkt->pkttype == PKT_PUBLIC_SUBKEY ? "sub" :
2785                       node->pkt->pkttype == PKT_SECRET_KEY ? "sec" : "ssb",
2786                       (node->flag & NODFLG_SELKEY) ? '*' : ' ',
2787                       pubkey_string (pk, pkstrbuf, sizeof pkstrbuf),
2788                       keystr (pk->keyid));
2789
2790           if (opt.legacy_list_mode)
2791             tty_printf ("  ");
2792           else
2793             tty_printf ("\n     ");
2794
2795           tty_printf (_("created: %s"), datestr_from_pk (pk));
2796           tty_printf ("  ");
2797           if (pk->flags.revoked)
2798             tty_printf (_("revoked: %s"), revokestr_from_pk (pk));
2799           else if (pk->has_expired)
2800             tty_printf (_("expired: %s"), expirestr_from_pk (pk));
2801           else
2802             tty_printf (_("expires: %s"), expirestr_from_pk (pk));
2803           tty_printf ("  ");
2804           tty_printf (_("usage: %s"), usagestr_from_pk (pk));
2805           tty_printf ("\n");
2806
2807           if (pk->seckey_info
2808               && pk->seckey_info->is_protected
2809               && pk->seckey_info->s2k.mode == 1002)
2810             {
2811               tty_printf ("%*s%s", opt.legacy_list_mode? 21:5, "",
2812                           _("card-no: "));
2813               if (pk->seckey_info->ivlen == 16
2814                   && !memcmp (pk->seckey_info->iv,
2815                               "\xD2\x76\x00\x01\x24\x01", 6))
2816                 {
2817                   /* This is an OpenPGP card. */
2818                   for (i = 8; i < 14; i++)
2819                     {
2820                       if (i == 10)
2821                         tty_printf (" ");
2822                       tty_printf ("%02X", pk->seckey_info->iv[i]);
2823                     }
2824                 }
2825               else
2826                 {
2827                   /* Unknown card: Print all. */
2828                   for (i = 0; i < pk->seckey_info->ivlen; i++)
2829                     tty_printf ("%02X", pk->seckey_info->iv[i]);
2830                 }
2831               tty_printf ("\n");
2832             }
2833
2834           if (node->pkt->pkttype == PKT_PUBLIC_KEY
2835               || node->pkt->pkttype == PKT_SECRET_KEY)
2836             {
2837               if (opt.trust_model != TM_ALWAYS)
2838                 {
2839                   tty_printf ("%*s",
2840                               opt.legacy_list_mode?
2841                               ((int) keystrlen () + 13):5, "");
2842                   /* Ownertrust is only meaningful for the PGP or
2843                      classic trust models */
2844                   if (opt.trust_model == TM_PGP
2845                       || opt.trust_model == TM_CLASSIC)
2846                     {
2847                       int width = 14 - strlen (otrust);
2848                       if (width <= 0)
2849                         width = 1;
2850                       tty_printf (_("trust: %s"), otrust);
2851                       tty_printf ("%*s", width, "");
2852                     }
2853
2854                   tty_printf (_("validity: %s"), trust);
2855                   tty_printf ("\n");
2856                 }
2857               if (node->pkt->pkttype == PKT_PUBLIC_KEY
2858                   && (get_ownertrust (pk) & TRUST_FLAG_DISABLED))
2859                 {
2860                   tty_printf ("*** ");
2861                   tty_printf (_("This key has been disabled"));
2862                   tty_printf ("\n");
2863                 }
2864             }
2865
2866           if ((node->pkt->pkttype == PKT_PUBLIC_KEY
2867                || node->pkt->pkttype == PKT_SECRET_KEY) && with_fpr)
2868             {
2869               print_fingerprint (pk, 2);
2870               tty_printf ("\n");
2871             }
2872         }
2873     }
2874
2875   show_names (keyblock, primary, only_marked ? NODFLG_MARK_A : 0, with_prefs);
2876
2877   if (do_warn)
2878     tty_printf (_("Please note that the shown key validity"
2879                   " is not necessarily correct\n"
2880                   "unless you restart the program.\n"));
2881 }
2882
2883
2884 /* Display basic key information.  This function is suitable to show
2885    information on the key without any dependencies on the trustdb or
2886    any other internal GnuPG stuff.  KEYBLOCK may either be a public or
2887    a secret key.*/
2888 void
2889 show_basic_key_info (KBNODE keyblock)
2890 {
2891   KBNODE node;
2892   int i;
2893   char pkstrbuf[PUBKEY_STRING_SIZE];
2894
2895   /* The primary key */
2896   for (node = keyblock; node; node = node->next)
2897     {
2898       if (node->pkt->pkttype == PKT_PUBLIC_KEY
2899           || node->pkt->pkttype == PKT_SECRET_KEY)
2900         {
2901           PKT_public_key *pk = node->pkt->pkt.public_key;
2902
2903           /* Note, we use the same format string as in other show
2904              functions to make the translation job easier. */
2905           tty_printf ("%s  %s/%s  ",
2906                       node->pkt->pkttype == PKT_PUBLIC_KEY ? "pub" :
2907                       node->pkt->pkttype == PKT_PUBLIC_SUBKEY ? "sub" :
2908                       node->pkt->pkttype == PKT_SECRET_KEY ? "sec" :"ssb",
2909                       pubkey_string (pk, pkstrbuf, sizeof pkstrbuf),
2910                       keystr_from_pk (pk));
2911           tty_printf (_("created: %s"), datestr_from_pk (pk));
2912           tty_printf ("  ");
2913           tty_printf (_("expires: %s"), expirestr_from_pk (pk));
2914           tty_printf ("\n");
2915           print_fingerprint (pk, 3);
2916           tty_printf ("\n");
2917         }
2918     }
2919
2920   /* The user IDs. */
2921   for (i = 0, node = keyblock; node; node = node->next)
2922     {
2923       if (node->pkt->pkttype == PKT_USER_ID)
2924         {
2925           PKT_user_id *uid = node->pkt->pkt.user_id;
2926           ++i;
2927
2928           tty_printf ("     ");
2929           if (uid->is_revoked)
2930             tty_printf ("[%s] ", _("revoked"));
2931           else if (uid->is_expired)
2932             tty_printf ("[%s] ", _("expired"));
2933           tty_print_utf8_string (uid->name, uid->len);
2934           tty_printf ("\n");
2935         }
2936     }
2937 }
2938
2939 static void
2940 show_key_and_fingerprint (KBNODE keyblock)
2941 {
2942   KBNODE node;
2943   PKT_public_key *pk = NULL;
2944   char pkstrbuf[PUBKEY_STRING_SIZE];
2945
2946   for (node = keyblock; node; node = node->next)
2947     {
2948       if (node->pkt->pkttype == PKT_PUBLIC_KEY)
2949         {
2950           pk = node->pkt->pkt.public_key;
2951           tty_printf ("pub   %s/%s %s ",
2952                       pubkey_string (pk, pkstrbuf, sizeof pkstrbuf),
2953                       keystr_from_pk(pk),
2954                       datestr_from_pk (pk));
2955         }
2956       else if (node->pkt->pkttype == PKT_USER_ID)
2957         {
2958           PKT_user_id *uid = node->pkt->pkt.user_id;
2959           tty_print_utf8_string (uid->name, uid->len);
2960           break;
2961         }
2962     }
2963   tty_printf ("\n");
2964   if (pk)
2965     print_fingerprint (pk, 2);
2966 }
2967
2968
2969 /* Show a warning if no uids on the key have the primary uid flag
2970    set. */
2971 static void
2972 no_primary_warning (KBNODE keyblock)
2973 {
2974   KBNODE node;
2975   int have_primary = 0, uid_count = 0;
2976
2977   /* TODO: if we ever start behaving differently with a primary or
2978      non-primary attribute ID, we will need to check for attributes
2979      here as well. */
2980
2981   for (node = keyblock; node; node = node->next)
2982     {
2983       if (node->pkt->pkttype == PKT_USER_ID
2984           && node->pkt->pkt.user_id->attrib_data == NULL)
2985         {
2986           uid_count++;
2987
2988           if (node->pkt->pkt.user_id->is_primary == 2)
2989             {
2990               have_primary = 1;
2991               break;
2992             }
2993         }
2994     }
2995
2996   if (uid_count > 1 && !have_primary)
2997     log_info (_
2998               ("WARNING: no user ID has been marked as primary.  This command"
2999                " may\n              cause a different user ID to become"
3000                " the assumed primary.\n"));
3001 }
3002
3003
3004 /*
3005  * Ask for a new user id, add the self-signature and update the keyblock.
3006  * Return true if there is a new user id
3007  */
3008 static int
3009 menu_adduid (KBNODE pub_keyblock, int photo, const char *photo_name)
3010 {
3011   PKT_user_id *uid;
3012   PKT_public_key *pk = NULL;
3013   PKT_signature *sig = NULL;
3014   PACKET *pkt;
3015   KBNODE node;
3016   KBNODE pub_where = NULL;
3017   gpg_error_t err;
3018
3019   for (node = pub_keyblock; node; pub_where = node, node = node->next)
3020     {
3021       if (node->pkt->pkttype == PKT_PUBLIC_KEY)
3022         pk = node->pkt->pkt.public_key;
3023       else if (node->pkt->pkttype == PKT_PUBLIC_SUBKEY)
3024         break;
3025     }
3026   if (!node) /* No subkey.  */
3027     pub_where = NULL;
3028   assert (pk);
3029
3030   if (photo)
3031     {
3032       int hasattrib = 0;
3033
3034       for (node = pub_keyblock; node; node = node->next)
3035         if (node->pkt->pkttype == PKT_USER_ID &&
3036             node->pkt->pkt.user_id->attrib_data != NULL)
3037           {
3038             hasattrib = 1;
3039             break;
3040           }
3041
3042       /* It is legal but bad for compatibility to add a photo ID to a
3043          v3 key as it means that PGP2 will not be able to use that key
3044          anymore.  Also, PGP may not expect a photo on a v3 key.
3045          Don't bother to ask this if the key already has a photo - any
3046          damage has already been done at that point. -dms */
3047       if (pk->version == 3 && !hasattrib)
3048         {
3049           if (opt.expert)
3050             {
3051               tty_printf (_("WARNING: This is a PGP2-style key.  "
3052                             "Adding a photo ID may cause some versions\n"
3053                             "         of PGP to reject this key.\n"));
3054
3055               if (!cpr_get_answer_is_yes ("keyedit.v3_photo.okay",
3056                                           _("Are you sure you still want "
3057                                             "to add it? (y/N) ")))
3058                 return 0;
3059             }
3060           else
3061             {
3062               tty_printf (_("You may not add a photo ID to "
3063                             "a PGP2-style key.\n"));
3064               return 0;
3065             }
3066         }
3067
3068       uid = generate_photo_id (pk, photo_name);
3069     }
3070   else
3071     uid = generate_user_id (pub_keyblock);
3072   if (!uid)
3073     return 0;
3074
3075   err = make_keysig_packet (&sig, pk, uid, NULL, pk, 0x13, 0, 0, 0, 0,
3076                             keygen_add_std_prefs, pk, NULL);
3077   if (err)
3078     {
3079       log_error ("signing failed: %s\n", g10_errstr (err));
3080       free_user_id (uid);
3081       return 0;
3082     }
3083
3084   /* Insert/append to public keyblock */
3085   pkt = xmalloc_clear (sizeof *pkt);
3086   pkt->pkttype = PKT_USER_ID;
3087   pkt->pkt.user_id = uid;
3088   node = new_kbnode (pkt);
3089   if (pub_where)
3090     insert_kbnode (pub_where, node, 0);
3091   else
3092     add_kbnode (pub_keyblock, node);
3093   pkt = xmalloc_clear (sizeof *pkt);
3094   pkt->pkttype = PKT_SIGNATURE;
3095   pkt->pkt.signature = copy_signature (NULL, sig);
3096   if (pub_where)
3097     insert_kbnode (node, new_kbnode (pkt), 0);
3098   else
3099     add_kbnode (pub_keyblock, new_kbnode (pkt));
3100   return 1;
3101 }
3102
3103
3104 /*
3105  * Remove all selected userids from the keyring
3106  */
3107 static void
3108 menu_deluid (KBNODE pub_keyblock)
3109 {
3110   KBNODE node;
3111   int selected = 0;
3112
3113   for (node = pub_keyblock; node; node = node->next)
3114     {
3115       if (node->pkt->pkttype == PKT_USER_ID)
3116         {
3117           selected = node->flag & NODFLG_SELUID;
3118           if (selected)
3119             {
3120               /* Only cause a trust update if we delete a
3121                  non-revoked user id */
3122               if (!node->pkt->pkt.user_id->is_revoked)
3123                 update_trust = 1;
3124               delete_kbnode (node);
3125             }
3126         }
3127       else if (selected && node->pkt->pkttype == PKT_SIGNATURE)
3128         delete_kbnode (node);
3129       else if (node->pkt->pkttype == PKT_PUBLIC_SUBKEY)
3130         selected = 0;
3131     }
3132   commit_kbnode (&pub_keyblock);
3133 }
3134
3135
3136 static int
3137 menu_delsig (KBNODE pub_keyblock)
3138 {
3139   KBNODE node;
3140   PKT_user_id *uid = NULL;
3141   int changed = 0;
3142
3143   for (node = pub_keyblock; node; node = node->next)
3144     {
3145       if (node->pkt->pkttype == PKT_USER_ID)
3146         {
3147           uid = (node->flag & NODFLG_SELUID) ? node->pkt->pkt.user_id : NULL;
3148         }
3149       else if (uid && node->pkt->pkttype == PKT_SIGNATURE)
3150         {
3151           int okay, valid, selfsig, inv_sig, no_key, other_err;
3152
3153           tty_printf ("uid  ");
3154           tty_print_utf8_string (uid->name, uid->len);
3155           tty_printf ("\n");
3156
3157           okay = inv_sig = no_key = other_err = 0;
3158           if (opt.with_colons)
3159             valid = print_and_check_one_sig_colon (pub_keyblock, node,
3160                                                    &inv_sig, &no_key,
3161                                                    &other_err, &selfsig, 1);
3162           else
3163             valid = print_and_check_one_sig (pub_keyblock, node,
3164                                              &inv_sig, &no_key, &other_err,
3165                                              &selfsig, 1);
3166
3167           if (valid)
3168             {
3169               okay = cpr_get_answer_yes_no_quit
3170                 ("keyedit.delsig.valid",
3171                  _("Delete this good signature? (y/N/q)"));
3172
3173               /* Only update trust if we delete a good signature.
3174                  The other two cases do not affect trust. */
3175               if (okay)
3176                 update_trust = 1;
3177             }
3178           else if (inv_sig || other_err)
3179             okay = cpr_get_answer_yes_no_quit
3180               ("keyedit.delsig.invalid",
3181                _("Delete this invalid signature? (y/N/q)"));
3182           else if (no_key)
3183             okay = cpr_get_answer_yes_no_quit
3184               ("keyedit.delsig.unknown",
3185                _("Delete this unknown signature? (y/N/q)"));
3186
3187           if (okay == -1)
3188             break;
3189           if (okay && selfsig
3190               && !cpr_get_answer_is_yes
3191               ("keyedit.delsig.selfsig",
3192                _("Really delete this self-signature? (y/N)")))
3193             okay = 0;
3194           if (okay)
3195             {
3196               delete_kbnode (node);
3197               changed++;
3198             }
3199
3200         }
3201       else if (node->pkt->pkttype == PKT_PUBLIC_SUBKEY)
3202         uid = NULL;
3203     }
3204
3205   if (changed)
3206     {
3207       commit_kbnode (&pub_keyblock);
3208       tty_printf (changed == 1 ? _("Deleted %d signature.\n")
3209                   : _("Deleted %d signatures.\n"), changed);
3210     }
3211   else
3212     tty_printf (_("Nothing deleted.\n"));
3213
3214   return changed;
3215 }
3216
3217
3218 static int
3219 menu_clean (KBNODE keyblock, int self_only)
3220 {
3221   KBNODE uidnode;
3222   int modified = 0, select_all = !count_selected_uids (keyblock);
3223
3224   for (uidnode = keyblock->next;
3225        uidnode && uidnode->pkt->pkttype != PKT_PUBLIC_SUBKEY;
3226        uidnode = uidnode->next)
3227     {
3228       if (uidnode->pkt->pkttype == PKT_USER_ID
3229           && (uidnode->flag & NODFLG_SELUID || select_all))
3230         {
3231           int uids = 0, sigs = 0;
3232           char *user = utf8_to_native (uidnode->pkt->pkt.user_id->name,
3233                                        uidnode->pkt->pkt.user_id->len,
3234                                        0);
3235
3236           clean_one_uid (keyblock, uidnode, opt.verbose, self_only, &uids,
3237                          &sigs);
3238           if (uids)
3239             {
3240               const char *reason;
3241
3242               if (uidnode->pkt->pkt.user_id->is_revoked)
3243                 reason = _("revoked");
3244               else if (uidnode->pkt->pkt.user_id->is_expired)
3245                 reason = _("expired");
3246               else
3247                 reason = _("invalid");
3248
3249               tty_printf (_("User ID \"%s\" compacted: %s\n"), user, reason);
3250
3251               modified = 1;
3252             }
3253           else if (sigs)
3254             {
3255               tty_printf (sigs == 1 ?
3256                           _("User ID \"%s\": %d signature removed\n") :
3257                           _("User ID \"%s\": %d signatures removed\n"),
3258                           user, sigs);
3259
3260               modified = 1;
3261             }
3262           else
3263             {
3264               tty_printf (self_only == 1 ?
3265                           _("User ID \"%s\": already minimized\n") :
3266                           _("User ID \"%s\": already clean\n"), user);
3267             }
3268
3269           xfree (user);
3270         }
3271     }
3272
3273   return modified;
3274 }
3275
3276
3277 /*
3278  * Remove some of the secondary keys
3279  */
3280 static void
3281 menu_delkey (KBNODE pub_keyblock)
3282 {
3283   KBNODE node;
3284   int selected = 0;
3285
3286   for (node = pub_keyblock; node; node = node->next)
3287     {
3288       if (node->pkt->pkttype == PKT_PUBLIC_SUBKEY)
3289         {
3290           selected = node->flag & NODFLG_SELKEY;
3291           if (selected)
3292             delete_kbnode (node);
3293         }
3294       else if (selected && node->pkt->pkttype == PKT_SIGNATURE)
3295         delete_kbnode (node);
3296       else
3297         selected = 0;
3298     }
3299   commit_kbnode (&pub_keyblock);
3300
3301   /* No need to set update_trust here since signing keys are no
3302      longer used to certify other keys, so there is no change in
3303      trust when revoking/removing them.   */
3304 }
3305
3306
3307 /*
3308  * Ask for a new revoker, create the self-signature and put it into
3309  * the keyblock.  Returns true if there is a new revoker.
3310  */
3311 static int
3312 menu_addrevoker (ctrl_t ctrl, kbnode_t pub_keyblock, int sensitive)
3313 {
3314   PKT_public_key *pk = NULL;
3315   PKT_public_key *revoker_pk = NULL;
3316   PKT_signature *sig = NULL;
3317   PACKET *pkt;
3318   struct revocation_key revkey;
3319   size_t fprlen;
3320   int rc;
3321
3322   assert (pub_keyblock->pkt->pkttype == PKT_PUBLIC_KEY);
3323
3324   pk = pub_keyblock->pkt->pkt.public_key;
3325
3326   if (pk->numrevkeys == 0 && pk->version == 3)
3327     {
3328       /* It is legal but bad for compatibility to add a revoker to a
3329          v3 key as it means that PGP2 will not be able to use that key
3330          anymore.  Also, PGP may not expect a revoker on a v3 key.
3331          Don't bother to ask this if the key already has a revoker -
3332          any damage has already been done at that point. -dms */
3333       if (opt.expert)
3334         {
3335           tty_printf (_("WARNING: This is a PGP 2.x-style key.  "
3336                         "Adding a designated revoker may cause\n"
3337                         "         some versions of PGP to reject this key.\n"));
3338
3339           if (!cpr_get_answer_is_yes ("keyedit.v3_revoker.okay",
3340                                       _("Are you sure you still want "
3341                                         "to add it? (y/N) ")))
3342             return 0;
3343         }
3344       else
3345         {
3346           tty_printf (_("You may not add a designated revoker to "
3347                         "a PGP 2.x-style key.\n"));
3348           return 0;
3349         }
3350     }