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