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