gpg: Fix detection of the AEAD feature flag.
[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, NULL);
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           /* Note that when using --dry-run we don't change the
1138            * passphrase but merely verify the current passphrase.  */
1139           desc = gpg_format_keydesc (ctrl, pk, FORMAT_KEYDESC_NORMAL, 1);
1140           err = agent_passwd (ctrl, hexgrip, desc, !!opt.dry_run,
1141                               &cache_nonce, &passwd_nonce);
1142           xfree (desc);
1143
1144           if (err)
1145             log_log ((gpg_err_code (err) == GPG_ERR_CANCELED
1146                       || gpg_err_code (err) == GPG_ERR_FULLY_CANCELED)
1147                      ? GPGRT_LOGLVL_INFO : GPGRT_LOGLVL_ERROR,
1148                      _("key %s: error changing passphrase: %s\n"),
1149                        keystr_with_sub (keyid, subid),
1150                        gpg_strerror (err));
1151           if (gpg_err_code (err) == GPG_ERR_FULLY_CANCELED)
1152             break;
1153         }
1154     }
1155
1156  leave:
1157   xfree (hexgrip);
1158   xfree (cache_nonce);
1159   xfree (passwd_nonce);
1160   return err;
1161 }
1162
1163
1164 \f
1165 /* Fix various problems in the keyblock.  Returns true if the keyblock
1166    was changed.  Note that a pointer to the keyblock must be given and
1167    the function may change it (i.e. replacing the first node).  */
1168 static int
1169 fix_keyblock (ctrl_t ctrl, kbnode_t *keyblockp)
1170 {
1171   int changed = 0;
1172
1173   if (collapse_uids (keyblockp))
1174     changed++;
1175   if (key_check_all_keysigs (ctrl, 1, *keyblockp, 0, 1))
1176     changed++;
1177   reorder_keyblock (*keyblockp);
1178   /* If we modified the keyblock, make sure the flags are right. */
1179   if (changed)
1180     merge_keys_and_selfsig (ctrl, *keyblockp);
1181
1182   return changed;
1183 }
1184
1185
1186 static int
1187 parse_sign_type (const char *str, int *localsig, int *nonrevokesig,
1188                  int *trustsig)
1189 {
1190   const char *p = str;
1191
1192   while (*p)
1193     {
1194       if (ascii_strncasecmp (p, "l", 1) == 0)
1195         {
1196           *localsig = 1;
1197           p++;
1198         }
1199       else if (ascii_strncasecmp (p, "nr", 2) == 0)
1200         {
1201           *nonrevokesig = 1;
1202           p += 2;
1203         }
1204       else if (ascii_strncasecmp (p, "t", 1) == 0)
1205         {
1206           *trustsig = 1;
1207           p++;
1208         }
1209       else
1210         return 0;
1211     }
1212
1213   return 1;
1214 }
1215
1216
1217 \f
1218 /*
1219  * Menu driven key editor.  If seckey_check is true, then a secret key
1220  * that matches username will be looked for.  If it is false, not all
1221  * commands will be available.
1222  *
1223  * Note: to keep track of certain selections we use node->mark MARKBIT_xxxx.
1224  */
1225
1226 /* Need an SK for this command */
1227 #define KEYEDIT_NEED_SK 1
1228 /* Need an SUB KEY for this command */
1229 #define KEYEDIT_NEED_SUBSK 2
1230 /* Match the tail of the string */
1231 #define KEYEDIT_TAIL_MATCH 8
1232
1233 enum cmdids
1234 {
1235   cmdNONE = 0,
1236   cmdQUIT, cmdHELP, cmdFPR, cmdLIST, cmdSELUID, cmdCHECK, cmdSIGN,
1237   cmdREVSIG, cmdREVKEY, cmdREVUID, cmdDELSIG, cmdPRIMARY, cmdDEBUG,
1238   cmdSAVE, cmdADDUID, cmdADDPHOTO, cmdDELUID, cmdADDKEY, cmdDELKEY,
1239   cmdADDREVOKER, cmdTOGGLE, cmdSELKEY, cmdPASSWD, cmdTRUST, cmdPREF,
1240   cmdEXPIRE, cmdCHANGEUSAGE, cmdBACKSIGN,
1241 #ifndef NO_TRUST_MODELS
1242   cmdENABLEKEY, cmdDISABLEKEY,
1243 #endif /*!NO_TRUST_MODELS*/
1244   cmdSHOWPREF,
1245   cmdSETPREF, cmdPREFKS, cmdNOTATION, cmdINVCMD, cmdSHOWPHOTO, cmdUPDTRUST,
1246   cmdCHKTRUST, cmdADDCARDKEY, cmdKEYTOCARD, cmdBKUPTOCARD,
1247   cmdCLEAN, cmdMINIMIZE, cmdGRIP, cmdNOP
1248 };
1249
1250 static struct
1251 {
1252   const char *name;
1253   enum cmdids id;
1254   int flags;
1255   const char *desc;
1256 } cmds[] =
1257 {
1258   { "quit", cmdQUIT, 0, N_("quit this menu")},
1259   { "q", cmdQUIT, 0, NULL},
1260   { "save", cmdSAVE, 0, N_("save and quit")},
1261   { "help", cmdHELP, 0, N_("show this help")},
1262   { "?", cmdHELP, 0, NULL},
1263   { "fpr", cmdFPR, 0, N_("show key fingerprint")},
1264   { "grip", cmdGRIP, 0, N_("show the keygrip")},
1265   { "list", cmdLIST, 0, N_("list key and user IDs")},
1266   { "l", cmdLIST, 0, NULL},
1267   { "uid", cmdSELUID, 0, N_("select user ID N")},
1268   { "key", cmdSELKEY, 0, N_("select subkey N")},
1269   { "check", cmdCHECK, 0, N_("check signatures")},
1270   { "c", cmdCHECK, 0, NULL},
1271   { "change-usage", cmdCHANGEUSAGE, KEYEDIT_NEED_SK, NULL},
1272   { "cross-certify", cmdBACKSIGN, KEYEDIT_NEED_SK, NULL},
1273   { "backsign", cmdBACKSIGN,  KEYEDIT_NEED_SK, NULL},
1274   { "sign", cmdSIGN,  KEYEDIT_TAIL_MATCH,
1275     N_("sign selected user IDs [* see below for related commands]")},
1276   { "s", cmdSIGN, 0, NULL},
1277     /* "lsign" and friends will never match since "sign" comes first
1278        and it is a tail match.  They are just here so they show up in
1279        the help menu. */
1280   { "lsign", cmdNOP, 0, N_("sign selected user IDs locally")},
1281   { "tsign", cmdNOP, 0, N_("sign selected user IDs with a trust signature")},
1282   { "nrsign", cmdNOP, 0,
1283     N_("sign selected user IDs with a non-revocable signature")},
1284   { "debug", cmdDEBUG, 0, NULL},
1285   { "adduid", cmdADDUID,  KEYEDIT_NEED_SK, N_("add a user ID")},
1286   { "addphoto", cmdADDPHOTO,  KEYEDIT_NEED_SK,
1287     N_("add a photo ID")},
1288   { "deluid", cmdDELUID, 0, N_("delete selected user IDs")},
1289     /* delphoto is really deluid in disguise */
1290   { "delphoto", cmdDELUID, 0, NULL},
1291   { "addkey", cmdADDKEY,  KEYEDIT_NEED_SK, N_("add a subkey")},
1292 #ifdef ENABLE_CARD_SUPPORT
1293   { "addcardkey", cmdADDCARDKEY,  KEYEDIT_NEED_SK,
1294     N_("add a key to a smartcard")},
1295   { "keytocard", cmdKEYTOCARD, KEYEDIT_NEED_SK | KEYEDIT_NEED_SUBSK,
1296     N_("move a key to a smartcard")},
1297   { "bkuptocard", cmdBKUPTOCARD, KEYEDIT_NEED_SK | KEYEDIT_NEED_SUBSK,
1298     N_("move a backup key to a smartcard")},
1299 #endif /*ENABLE_CARD_SUPPORT */
1300   { "delkey", cmdDELKEY, 0, N_("delete selected subkeys")},
1301   { "addrevoker", cmdADDREVOKER,  KEYEDIT_NEED_SK,
1302     N_("add a revocation key")},
1303   { "delsig", cmdDELSIG, 0,
1304     N_("delete signatures from the selected user IDs")},
1305   { "expire", cmdEXPIRE,  KEYEDIT_NEED_SK | KEYEDIT_NEED_SUBSK,
1306     N_("change the expiration date for the key or selected subkeys")},
1307   { "primary", cmdPRIMARY,  KEYEDIT_NEED_SK,
1308     N_("flag the selected user ID as primary")},
1309   { "toggle", cmdTOGGLE, KEYEDIT_NEED_SK, NULL},  /* Dummy command.  */
1310   { "t", cmdTOGGLE, KEYEDIT_NEED_SK, NULL},
1311   { "pref", cmdPREF, 0, N_("list preferences (expert)")},
1312   { "showpref", cmdSHOWPREF, 0, N_("list preferences (verbose)")},
1313   { "setpref", cmdSETPREF,  KEYEDIT_NEED_SK,
1314     N_("set preference list for the selected user IDs")},
1315   { "updpref", cmdSETPREF,  KEYEDIT_NEED_SK, NULL},
1316   { "keyserver", cmdPREFKS,  KEYEDIT_NEED_SK,
1317     N_("set the preferred keyserver URL for the selected user IDs")},
1318   { "notation", cmdNOTATION,  KEYEDIT_NEED_SK,
1319     N_("set a notation for the selected user IDs")},
1320   { "passwd", cmdPASSWD,  KEYEDIT_NEED_SK | KEYEDIT_NEED_SUBSK,
1321     N_("change the passphrase")},
1322   { "password", cmdPASSWD,  KEYEDIT_NEED_SK | KEYEDIT_NEED_SUBSK, NULL},
1323 #ifndef NO_TRUST_MODELS
1324   { "trust", cmdTRUST, 0, N_("change the ownertrust")},
1325 #endif /*!NO_TRUST_MODELS*/
1326   { "revsig", cmdREVSIG, 0,
1327     N_("revoke signatures on the selected user IDs")},
1328   { "revuid", cmdREVUID,  KEYEDIT_NEED_SK,
1329     N_("revoke selected user IDs")},
1330   { "revphoto", cmdREVUID,  KEYEDIT_NEED_SK, NULL},
1331   { "revkey", cmdREVKEY,  KEYEDIT_NEED_SK,
1332     N_("revoke key or selected subkeys")},
1333 #ifndef NO_TRUST_MODELS
1334   { "enable", cmdENABLEKEY, 0, N_("enable key")},
1335   { "disable", cmdDISABLEKEY, 0, N_("disable key")},
1336 #endif /*!NO_TRUST_MODELS*/
1337   { "showphoto", cmdSHOWPHOTO, 0, N_("show selected photo IDs")},
1338   { "clean", cmdCLEAN, 0,
1339     N_("compact unusable user IDs and remove unusable signatures from key")},
1340   { "minimize", cmdMINIMIZE, 0,
1341     N_("compact unusable user IDs and remove all signatures from key")},
1342
1343   { NULL, cmdNONE, 0, NULL}
1344 };
1345
1346
1347 \f
1348 #ifdef HAVE_LIBREADLINE
1349
1350 /*
1351    These two functions are used by readline for command completion.
1352  */
1353
1354 static char *
1355 command_generator (const char *text, int state)
1356 {
1357   static int list_index, len;
1358   const char *name;
1359
1360   /* If this is a new word to complete, initialize now.  This includes
1361      saving the length of TEXT for efficiency, and initializing the
1362      index variable to 0. */
1363   if (!state)
1364     {
1365       list_index = 0;
1366       len = strlen (text);
1367     }
1368
1369   /* Return the next partial match */
1370   while ((name = cmds[list_index].name))
1371     {
1372       /* Only complete commands that have help text */
1373       if (cmds[list_index++].desc && strncmp (name, text, len) == 0)
1374         return strdup (name);
1375     }
1376
1377   return NULL;
1378 }
1379
1380 static char **
1381 keyedit_completion (const char *text, int start, int end)
1382 {
1383   /* If we are at the start of a line, we try and command-complete.
1384      If not, just do nothing for now. */
1385
1386   (void) end;
1387
1388   if (start == 0)
1389     return rl_completion_matches (text, command_generator);
1390
1391   rl_attempted_completion_over = 1;
1392
1393   return NULL;
1394 }
1395 #endif /* HAVE_LIBREADLINE */
1396
1397
1398 \f
1399 /* Main function of the menu driven key editor.  */
1400 void
1401 keyedit_menu (ctrl_t ctrl, const char *username, strlist_t locusr,
1402               strlist_t commands, int quiet, int seckey_check)
1403 {
1404   enum cmdids cmd = 0;
1405   gpg_error_t err = 0;
1406   KBNODE keyblock = NULL;
1407   KEYDB_HANDLE kdbhd = NULL;
1408   int have_seckey = 0;
1409   int have_anyseckey = 0;
1410   char *answer = NULL;
1411   int redisplay = 1;
1412   int modified = 0;
1413   int sec_shadowing = 0;
1414   int run_subkey_warnings = 0;
1415   int have_commands = !!commands;
1416
1417   if (opt.command_fd != -1)
1418     ;
1419   else if (opt.batch && !have_commands)
1420     {
1421       log_error (_("can't do this in batch mode\n"));
1422       goto leave;
1423     }
1424
1425 #ifdef HAVE_W32_SYSTEM
1426   /* Due to Windows peculiarities we need to make sure that the
1427      trustdb stale check is done before we open another file
1428      (i.e. by searching for a key).  In theory we could make sure
1429      that the files are closed after use but the open/close caches
1430      inhibits that and flushing the cache right before the stale
1431      check is not easy to implement.  Thus we take the easy way out
1432      and run the stale check as early as possible.  Note, that for
1433      non- W32 platforms it is run indirectly trough a call to
1434      get_validity ().  */
1435   check_trustdb_stale (ctrl);
1436 #endif
1437
1438   /* Get the public key */
1439   err = get_pubkey_byname (ctrl, NULL, NULL, username, &keyblock, &kdbhd, 1, 1);
1440   if (err)
1441     {
1442       log_error (_("key \"%s\" not found: %s\n"), username, gpg_strerror (err));
1443       goto leave;
1444     }
1445
1446   if (fix_keyblock (ctrl, &keyblock))
1447     modified++;
1448
1449   /* See whether we have a matching secret key.  */
1450   if (seckey_check)
1451     {
1452       have_anyseckey = !agent_probe_any_secret_key (ctrl, keyblock);
1453       if (have_anyseckey
1454           && !agent_probe_secret_key (ctrl, keyblock->pkt->pkt.public_key))
1455         {
1456           /* The primary key is also available.   */
1457           have_seckey = 1;
1458         }
1459
1460       if (have_seckey && !quiet)
1461         tty_printf (_("Secret key is available.\n"));
1462       else if (have_anyseckey && !quiet)
1463         tty_printf (_("Secret subkeys are available.\n"));
1464     }
1465
1466   /* Main command loop.  */
1467   for (;;)
1468     {
1469       int i, arg_number, photo;
1470       const char *arg_string = "";
1471       char *p;
1472       PKT_public_key *pk = keyblock->pkt->pkt.public_key;
1473
1474       tty_printf ("\n");
1475
1476       if (redisplay && !quiet)
1477         {
1478           /* Show using flags: with_revoker, with_subkeys.  */
1479           show_key_with_all_names (ctrl, NULL, keyblock, 0, 1, 0, 1, 0, 0);
1480           tty_printf ("\n");
1481           redisplay = 0;
1482         }
1483
1484       if (run_subkey_warnings)
1485         {
1486           run_subkey_warnings = 0;
1487           if (!count_selected_keys (keyblock))
1488             subkey_expire_warning (keyblock);
1489         }
1490
1491       do
1492         {
1493           xfree (answer);
1494           if (have_commands)
1495             {
1496               if (commands)
1497                 {
1498                   answer = xstrdup (commands->d);
1499                   commands = commands->next;
1500                 }
1501               else if (opt.batch)
1502                 {
1503                   answer = xstrdup ("quit");
1504                 }
1505               else
1506                 have_commands = 0;
1507             }
1508           if (!have_commands)
1509             {
1510 #ifdef HAVE_LIBREADLINE
1511               tty_enable_completion (keyedit_completion);
1512 #endif
1513               answer = cpr_get_no_help ("keyedit.prompt", GPG_NAME "> ");
1514               cpr_kill_prompt ();
1515               tty_disable_completion ();
1516             }
1517           trim_spaces (answer);
1518         }
1519       while (*answer == '#');
1520
1521       arg_number = 0; /* Here is the init which egcc complains about.  */
1522       photo = 0;      /* Same here. */
1523       if (!*answer)
1524         cmd = cmdLIST;
1525       else if (*answer == CONTROL_D)
1526         cmd = cmdQUIT;
1527       else if (digitp (answer))
1528         {
1529           cmd = cmdSELUID;
1530           arg_number = atoi (answer);
1531         }
1532       else
1533         {
1534           if ((p = strchr (answer, ' ')))
1535             {
1536               *p++ = 0;
1537               trim_spaces (answer);
1538               trim_spaces (p);
1539               arg_number = atoi (p);
1540               arg_string = p;
1541             }
1542
1543           for (i = 0; cmds[i].name; i++)
1544             {
1545               if (cmds[i].flags & KEYEDIT_TAIL_MATCH)
1546                 {
1547                   size_t l = strlen (cmds[i].name);
1548                   size_t a = strlen (answer);
1549                   if (a >= l)
1550                     {
1551                       if (!ascii_strcasecmp (&answer[a - l], cmds[i].name))
1552                         {
1553                           answer[a - l] = '\0';
1554                           break;
1555                         }
1556                     }
1557                 }
1558               else if (!ascii_strcasecmp (answer, cmds[i].name))
1559                 break;
1560             }
1561           if ((cmds[i].flags & (KEYEDIT_NEED_SK|KEYEDIT_NEED_SUBSK))
1562               && !(((cmds[i].flags & KEYEDIT_NEED_SK) && have_seckey)
1563                    || ((cmds[i].flags & KEYEDIT_NEED_SUBSK) && have_anyseckey)))
1564             {
1565               tty_printf (_("Need the secret key to do this.\n"));
1566               cmd = cmdNOP;
1567             }
1568           else
1569             cmd = cmds[i].id;
1570         }
1571
1572       /* Dispatch the command.  */
1573       switch (cmd)
1574         {
1575         case cmdHELP:
1576           for (i = 0; cmds[i].name; i++)
1577             {
1578               if ((cmds[i].flags & (KEYEDIT_NEED_SK|KEYEDIT_NEED_SUBSK))
1579                   && !(((cmds[i].flags & KEYEDIT_NEED_SK) && have_seckey)
1580                        ||((cmds[i].flags&KEYEDIT_NEED_SUBSK)&&have_anyseckey)))
1581                 ; /* Skip those item if we do not have the secret key.  */
1582               else if (cmds[i].desc)
1583                 tty_printf ("%-11s %s\n", cmds[i].name, _(cmds[i].desc));
1584             }
1585
1586           tty_printf ("\n");
1587           tty_printf
1588             (_("* The 'sign' command may be prefixed with an 'l' for local "
1589                "signatures (lsign),\n"
1590                "  a 't' for trust signatures (tsign), an 'nr' for "
1591                "non-revocable signatures\n"
1592                "  (nrsign), or any combination thereof (ltsign, "
1593                "tnrsign, etc.).\n"));
1594           break;
1595
1596         case cmdLIST:
1597           redisplay = 1;
1598           break;
1599
1600         case cmdFPR:
1601           show_key_and_fingerprint
1602             (ctrl,
1603              keyblock, (*arg_string == '*'
1604                         && (!arg_string[1] || spacep (arg_string + 1))));
1605           break;
1606
1607         case cmdGRIP:
1608           show_key_and_grip (keyblock);
1609           break;
1610
1611         case cmdSELUID:
1612           if (strlen (arg_string) == NAMEHASH_LEN * 2)
1613             redisplay = menu_select_uid_namehash (keyblock, arg_string);
1614           else
1615             {
1616               if (*arg_string == '*'
1617                   && (!arg_string[1] || spacep (arg_string + 1)))
1618                 arg_number = -1;        /* Select all. */
1619               redisplay = menu_select_uid (keyblock, arg_number);
1620             }
1621           break;
1622
1623         case cmdSELKEY:
1624           {
1625             if (*arg_string == '*'
1626                 && (!arg_string[1] || spacep (arg_string + 1)))
1627               arg_number = -1;  /* Select all. */
1628             if (menu_select_key (keyblock, arg_number, p))
1629               redisplay = 1;
1630           }
1631           break;
1632
1633         case cmdCHECK:
1634           if (key_check_all_keysigs (ctrl, -1, keyblock,
1635                                      count_selected_uids (keyblock),
1636                                      !strcmp (arg_string, "selfsig")))
1637             modified = 1;
1638           break;
1639
1640         case cmdSIGN:
1641           {
1642             int localsig = 0, nonrevokesig = 0, trustsig = 0, interactive = 0;
1643
1644             if (pk->flags.revoked)
1645               {
1646                 tty_printf (_("Key is revoked."));
1647
1648                 if (opt.expert)
1649                   {
1650                     tty_printf ("  ");
1651                     if (!cpr_get_answer_is_yes
1652                         ("keyedit.sign_revoked.okay",
1653                          _("Are you sure you still want to sign it? (y/N) ")))
1654                       break;
1655                   }
1656                 else
1657                   {
1658                     tty_printf (_("  Unable to sign.\n"));
1659                     break;
1660                   }
1661               }
1662
1663             if (count_uids (keyblock) > 1 && !count_selected_uids (keyblock))
1664               {
1665                 int result;
1666                 if (opt.only_sign_text_ids)
1667                   result = cpr_get_answer_is_yes
1668                     ("keyedit.sign_all.okay",
1669                      _("Really sign all text user IDs? (y/N) "));
1670                 else
1671                   result = cpr_get_answer_is_yes
1672                     ("keyedit.sign_all.okay",
1673                      _("Really sign all user IDs? (y/N) "));
1674
1675                 if (! result)
1676                   {
1677                     if (opt.interactive)
1678                       interactive = 1;
1679                     else
1680                       {
1681                         tty_printf (_("Hint: Select the user IDs to sign\n"));
1682                         have_commands = 0;
1683                         break;
1684                       }
1685
1686                   }
1687               }
1688             /* What sort of signing are we doing? */
1689             if (!parse_sign_type
1690                 (answer, &localsig, &nonrevokesig, &trustsig))
1691               {
1692                 tty_printf (_("Unknown signature type '%s'\n"), answer);
1693                 break;
1694               }
1695
1696             sign_uids (ctrl, NULL, keyblock, locusr, &modified,
1697                        localsig, nonrevokesig, trustsig, interactive, 0);
1698           }
1699           break;
1700
1701         case cmdDEBUG:
1702           dump_kbnode (keyblock);
1703           break;
1704
1705         case cmdTOGGLE:
1706           /* The toggle command is a leftover from old gpg versions
1707              where we worked with a secret and a public keyring.  It
1708              is not necessary anymore but we keep this command for the
1709              sake of scripts using it.  */
1710           redisplay = 1;
1711           break;
1712
1713         case cmdADDPHOTO:
1714           if (RFC2440)
1715             {
1716               tty_printf (_("This command is not allowed while in %s mode.\n"),
1717                           gnupg_compliance_option_string (opt.compliance));
1718               break;
1719             }
1720           photo = 1;
1721           /* fall through */
1722         case cmdADDUID:
1723           if (menu_adduid (ctrl, keyblock, photo, arg_string, NULL))
1724             {
1725               update_trust = 1;
1726               redisplay = 1;
1727               modified = 1;
1728               merge_keys_and_selfsig (ctrl, keyblock);
1729             }
1730           break;
1731
1732         case cmdDELUID:
1733           {
1734             int n1;
1735
1736             if (!(n1 = count_selected_uids (keyblock)))
1737               {
1738                 tty_printf (_("You must select at least one user ID.\n"));
1739                 if (!opt.expert)
1740                   tty_printf (_("(Use the '%s' command.)\n"), "uid");
1741               }
1742             else if (real_uids_left (keyblock) < 1)
1743               tty_printf (_("You can't delete the last user ID!\n"));
1744             else if (cpr_get_answer_is_yes
1745                      ("keyedit.remove.uid.okay",
1746                       n1 > 1 ? _("Really remove all selected user IDs? (y/N) ")
1747                       :        _("Really remove this user ID? (y/N) ")))
1748               {
1749                 menu_deluid (keyblock);
1750                 redisplay = 1;
1751                 modified = 1;
1752               }
1753           }
1754           break;
1755
1756         case cmdDELSIG:
1757           {
1758             int n1;
1759
1760             if (!(n1 = count_selected_uids (keyblock)))
1761               {
1762                 tty_printf (_("You must select at least one user ID.\n"));
1763                 if (!opt.expert)
1764                   tty_printf (_("(Use the '%s' command.)\n"), "uid");
1765               }
1766             else if (menu_delsig (ctrl, keyblock))
1767               {
1768                 /* No redisplay here, because it may scroll away some
1769                  * of the status output of this command.  */
1770                 modified = 1;
1771               }
1772           }
1773           break;
1774
1775         case cmdADDKEY:
1776           if (!generate_subkeypair (ctrl, keyblock, NULL, NULL, NULL))
1777             {
1778               redisplay = 1;
1779               modified = 1;
1780               merge_keys_and_selfsig (ctrl, keyblock);
1781             }
1782           break;
1783
1784 #ifdef ENABLE_CARD_SUPPORT
1785         case cmdADDCARDKEY:
1786           if (!card_generate_subkey (ctrl, keyblock))
1787             {
1788               redisplay = 1;
1789               modified = 1;
1790               merge_keys_and_selfsig (ctrl, keyblock);
1791             }
1792           break;
1793
1794         case cmdKEYTOCARD:
1795           {
1796             KBNODE node = NULL;
1797             switch (count_selected_keys (keyblock))
1798               {
1799               case 0:
1800                 if (cpr_get_answer_is_yes
1801                     ("keyedit.keytocard.use_primary",
1802                      /* TRANSLATORS: Please take care: This is about
1803                         moving the key and not about removing it.  */
1804                      _("Really move the primary key? (y/N) ")))
1805                   node = keyblock;
1806                 break;
1807               case 1:
1808                 for (node = keyblock; node; node = node->next)
1809                   {
1810                     if (node->pkt->pkttype == PKT_PUBLIC_SUBKEY
1811                         && node->flag & NODFLG_SELKEY)
1812                       break;
1813                   }
1814                 break;
1815               default:
1816                 tty_printf (_("You must select exactly one key.\n"));
1817                 break;
1818               }
1819             if (node)
1820               {
1821                 PKT_public_key *xxpk = node->pkt->pkt.public_key;
1822                 if (card_store_subkey (node, xxpk ? xxpk->pubkey_usage : 0))
1823                   {
1824                     redisplay = 1;
1825                     sec_shadowing = 1;
1826                   }
1827               }
1828           }
1829           break;
1830
1831         case cmdBKUPTOCARD:
1832           {
1833             /* Ask for a filename, check whether this is really a
1834                backup key as generated by the card generation, parse
1835                that key and store it on card. */
1836             KBNODE node;
1837             char *fname;
1838             PACKET *pkt;
1839             IOBUF a;
1840             struct parse_packet_ctx_s parsectx;
1841
1842             if (!*arg_string)
1843               {
1844                 tty_printf (_("Command expects a filename argument\n"));
1845                 break;
1846               }
1847
1848             if (*arg_string == DIRSEP_C)
1849               fname = xstrdup (arg_string);
1850             else if (*arg_string == '~')
1851               fname = make_filename (arg_string, NULL);
1852             else
1853               fname = make_filename (gnupg_homedir (), arg_string, NULL);
1854
1855             /* Open that file.  */
1856             a = iobuf_open (fname);
1857             if (a && is_secured_file (iobuf_get_fd (a)))
1858               {
1859                 iobuf_close (a);
1860                 a = NULL;
1861                 gpg_err_set_errno (EPERM);
1862               }
1863             if (!a)
1864               {
1865                 tty_printf (_("Can't open '%s': %s\n"),
1866                             fname, strerror (errno));
1867                 xfree (fname);
1868                 break;
1869               }
1870
1871             /* Parse and check that file.  */
1872             pkt = xmalloc (sizeof *pkt);
1873             init_packet (pkt);
1874             init_parse_packet (&parsectx, a);
1875             err = parse_packet (&parsectx, pkt);
1876             deinit_parse_packet (&parsectx);
1877             iobuf_close (a);
1878             iobuf_ioctl (NULL, IOBUF_IOCTL_INVALIDATE_CACHE, 0, (char *) fname);
1879             if (!err && pkt->pkttype != PKT_SECRET_KEY
1880                 && pkt->pkttype != PKT_SECRET_SUBKEY)
1881               err = GPG_ERR_NO_SECKEY;
1882             if (err)
1883               {
1884                 tty_printf (_("Error reading backup key from '%s': %s\n"),
1885                             fname, gpg_strerror (err));
1886                 xfree (fname);
1887                 free_packet (pkt, NULL);
1888                 xfree (pkt);
1889                 break;
1890               }
1891
1892             xfree (fname);
1893             node = new_kbnode (pkt);
1894
1895             /* Transfer it to gpg-agent which handles secret keys.  */
1896             err = transfer_secret_keys (ctrl, NULL, node, 1, 1);
1897
1898             /* Treat the pkt as a public key.  */
1899             pkt->pkttype = PKT_PUBLIC_KEY;
1900
1901             /* Ask gpg-agent to store the secret key to card.  */
1902             if (card_store_subkey (node, 0))
1903               {
1904                 redisplay = 1;
1905                 sec_shadowing = 1;
1906               }
1907             release_kbnode (node);
1908           }
1909           break;
1910
1911 #endif /* ENABLE_CARD_SUPPORT */
1912
1913         case cmdDELKEY:
1914           {
1915             int n1;
1916
1917             if (!(n1 = count_selected_keys (keyblock)))
1918               {
1919                 tty_printf (_("You must select at least one key.\n"));
1920                 if (!opt.expert)
1921                   tty_printf (_("(Use the '%s' command.)\n"), "key");
1922               }
1923             else if (!cpr_get_answer_is_yes
1924                      ("keyedit.remove.subkey.okay",
1925                       n1 > 1 ? _("Do you really want to delete the "
1926                                  "selected keys? (y/N) ")
1927                       :  _("Do you really want to delete this key? (y/N) ")))
1928               ;
1929             else
1930               {
1931                 menu_delkey (keyblock);
1932                 redisplay = 1;
1933                 modified = 1;
1934               }
1935           }
1936           break;
1937
1938         case cmdADDREVOKER:
1939           {
1940             int sensitive = 0;
1941
1942             if (ascii_strcasecmp (arg_string, "sensitive") == 0)
1943               sensitive = 1;
1944             if (menu_addrevoker (ctrl, keyblock, sensitive))
1945               {
1946                 redisplay = 1;
1947                 modified = 1;
1948                 merge_keys_and_selfsig (ctrl, keyblock);
1949               }
1950           }
1951           break;
1952
1953         case cmdREVUID:
1954           {
1955             int n1;
1956
1957             if (!(n1 = count_selected_uids (keyblock)))
1958               {
1959                 tty_printf (_("You must select at least one user ID.\n"));
1960                 if (!opt.expert)
1961                   tty_printf (_("(Use the '%s' command.)\n"), "uid");
1962               }
1963             else if (cpr_get_answer_is_yes
1964                      ("keyedit.revoke.uid.okay",
1965                       n1 > 1 ? _("Really revoke all selected user IDs? (y/N) ")
1966                       :        _("Really revoke this user ID? (y/N) ")))
1967               {
1968                 if (menu_revuid (ctrl, keyblock))
1969                   {
1970                     modified = 1;
1971                     redisplay = 1;
1972                   }
1973               }
1974           }
1975           break;
1976
1977         case cmdREVKEY:
1978           {
1979             int n1;
1980
1981             if (!(n1 = count_selected_keys (keyblock)))
1982               {
1983                 if (cpr_get_answer_is_yes ("keyedit.revoke.subkey.okay",
1984                                            _("Do you really want to revoke"
1985                                              " the entire key? (y/N) ")))
1986                   {
1987                     if (menu_revkey (ctrl, keyblock))
1988                       modified = 1;
1989
1990                     redisplay = 1;
1991                   }
1992               }
1993             else if (cpr_get_answer_is_yes ("keyedit.revoke.subkey.okay",
1994                                             n1 > 1 ?
1995                                             _("Do you really want to revoke"
1996                                               " the selected subkeys? (y/N) ")
1997                                             : _("Do you really want to revoke"
1998                                                 " this subkey? (y/N) ")))
1999               {
2000                 if (menu_revsubkey (ctrl, keyblock))
2001                   modified = 1;
2002
2003                 redisplay = 1;
2004               }
2005
2006             if (modified)
2007               merge_keys_and_selfsig (ctrl, keyblock);
2008           }
2009           break;
2010
2011         case cmdEXPIRE:
2012           if (gpg_err_code (menu_expire (ctrl, keyblock, 0, 0)) == GPG_ERR_TRUE)
2013             {
2014               merge_keys_and_selfsig (ctrl, keyblock);
2015               run_subkey_warnings = 1;
2016               modified = 1;
2017               redisplay = 1;
2018             }
2019           break;
2020
2021         case cmdCHANGEUSAGE:
2022           if (menu_changeusage (ctrl, keyblock))
2023             {
2024               merge_keys_and_selfsig (ctrl, keyblock);
2025               modified = 1;
2026               redisplay = 1;
2027             }
2028           break;
2029
2030         case cmdBACKSIGN:
2031           if (menu_backsign (ctrl, keyblock))
2032             {
2033               modified = 1;
2034               redisplay = 1;
2035             }
2036           break;
2037
2038         case cmdPRIMARY:
2039           if (menu_set_primary_uid (ctrl, keyblock))
2040             {
2041               merge_keys_and_selfsig (ctrl, keyblock);
2042               modified = 1;
2043               redisplay = 1;
2044             }
2045           break;
2046
2047         case cmdPASSWD:
2048           change_passphrase (ctrl, keyblock);
2049           break;
2050
2051 #ifndef NO_TRUST_MODELS
2052         case cmdTRUST:
2053           if (opt.trust_model == TM_EXTERNAL)
2054             {
2055               tty_printf (_("Owner trust may not be set while "
2056                             "using a user provided trust database\n"));
2057               break;
2058             }
2059
2060           show_key_with_all_names (ctrl, NULL, keyblock, 0, 0, 0, 1, 0, 0);
2061           tty_printf ("\n");
2062           if (edit_ownertrust (ctrl, find_kbnode (keyblock,
2063                                             PKT_PUBLIC_KEY)->pkt->pkt.
2064                                public_key, 1))
2065             {
2066               redisplay = 1;
2067               /* No real need to set update_trust here as
2068                  edit_ownertrust() calls revalidation_mark()
2069                  anyway. */
2070               update_trust = 1;
2071             }
2072           break;
2073 #endif /*!NO_TRUST_MODELS*/
2074
2075         case cmdPREF:
2076           {
2077             int count = count_selected_uids (keyblock);
2078             log_assert (keyblock->pkt->pkttype == PKT_PUBLIC_KEY);
2079             show_names (ctrl, NULL, keyblock, keyblock->pkt->pkt.public_key,
2080                         count ? NODFLG_SELUID : 0, 1);
2081           }
2082           break;
2083
2084         case cmdSHOWPREF:
2085           {
2086             int count = count_selected_uids (keyblock);
2087             log_assert (keyblock->pkt->pkttype == PKT_PUBLIC_KEY);
2088             show_names (ctrl, NULL, keyblock, keyblock->pkt->pkt.public_key,
2089                         count ? NODFLG_SELUID : 0, 2);
2090           }
2091           break;
2092
2093         case cmdSETPREF:
2094           {
2095             PKT_user_id *tempuid;
2096
2097             keygen_set_std_prefs (!*arg_string ? "default" : arg_string, 0);
2098
2099             tempuid = keygen_get_std_prefs ();
2100             tty_printf (_("Set preference list to:\n"));
2101             show_prefs (tempuid, NULL, 1);
2102             free_user_id (tempuid);
2103
2104             if (cpr_get_answer_is_yes
2105                 ("keyedit.setpref.okay",
2106                  count_selected_uids (keyblock) ?
2107                  _("Really update the preferences"
2108                    " for the selected user IDs? (y/N) ")
2109                  : _("Really update the preferences? (y/N) ")))
2110               {
2111                 if (menu_set_preferences (ctrl, keyblock))
2112                   {
2113                     merge_keys_and_selfsig (ctrl, keyblock);
2114                     modified = 1;
2115                     redisplay = 1;
2116                   }
2117               }
2118           }
2119           break;
2120
2121         case cmdPREFKS:
2122           if (menu_set_keyserver_url (ctrl, *arg_string ? arg_string : NULL,
2123                                       keyblock))
2124             {
2125               merge_keys_and_selfsig (ctrl, keyblock);
2126               modified = 1;
2127               redisplay = 1;
2128             }
2129           break;
2130
2131         case cmdNOTATION:
2132           if (menu_set_notation (ctrl, *arg_string ? arg_string : NULL,
2133                                  keyblock))
2134             {
2135               merge_keys_and_selfsig (ctrl, keyblock);
2136               modified = 1;
2137               redisplay = 1;
2138             }
2139           break;
2140
2141         case cmdNOP:
2142           break;
2143
2144         case cmdREVSIG:
2145           if (menu_revsig (ctrl, keyblock))
2146             {
2147               redisplay = 1;
2148               modified = 1;
2149             }
2150           break;
2151
2152 #ifndef NO_TRUST_MODELS
2153         case cmdENABLEKEY:
2154         case cmdDISABLEKEY:
2155           if (enable_disable_key (ctrl, keyblock, cmd == cmdDISABLEKEY))
2156             {
2157               redisplay = 1;
2158               modified = 1;
2159             }
2160           break;
2161 #endif /*!NO_TRUST_MODELS*/
2162
2163         case cmdSHOWPHOTO:
2164           menu_showphoto (ctrl, keyblock);
2165           break;
2166
2167         case cmdCLEAN:
2168           if (menu_clean (ctrl, keyblock, 0))
2169             redisplay = modified = 1;
2170           break;
2171
2172         case cmdMINIMIZE:
2173           if (menu_clean (ctrl, keyblock, 1))
2174             redisplay = modified = 1;
2175           break;
2176
2177         case cmdQUIT:
2178           if (have_commands)
2179             goto leave;
2180           if (!modified && !sec_shadowing)
2181             goto leave;
2182           if (!cpr_get_answer_is_yes ("keyedit.save.okay",
2183                                       _("Save changes? (y/N) ")))
2184             {
2185               if (cpr_enabled ()
2186                   || cpr_get_answer_is_yes ("keyedit.cancel.okay",
2187                                             _("Quit without saving? (y/N) ")))
2188                 goto leave;
2189               break;
2190             }
2191           /* fall through */
2192         case cmdSAVE:
2193           if (modified)
2194             {
2195               err = keydb_update_keyblock (ctrl, kdbhd, keyblock);
2196               if (err)
2197                 {
2198                   log_error (_("update failed: %s\n"), gpg_strerror (err));
2199                   break;
2200                 }
2201             }
2202
2203           if (sec_shadowing)
2204             {
2205               err = agent_scd_learn (NULL, 1);
2206               if (err)
2207                 {
2208                   log_error (_("update failed: %s\n"), gpg_strerror (err));
2209                   break;
2210                 }
2211             }
2212
2213           if (!modified && !sec_shadowing)
2214             tty_printf (_("Key not changed so no update needed.\n"));
2215
2216           if (update_trust)
2217             {
2218               revalidation_mark (ctrl);
2219               update_trust = 0;
2220             }
2221           goto leave;
2222
2223         case cmdINVCMD:
2224         default:
2225           tty_printf ("\n");
2226           tty_printf (_("Invalid command  (try \"help\")\n"));
2227           break;
2228         }
2229     } /* End of the main command loop.  */
2230
2231  leave:
2232   release_kbnode (keyblock);
2233   keydb_release (kdbhd);
2234   xfree (answer);
2235 }
2236
2237
2238 /* Change the passphrase of the secret key identified by USERNAME.  */
2239 void
2240 keyedit_passwd (ctrl_t ctrl, const char *username)
2241 {
2242   gpg_error_t err;
2243   PKT_public_key *pk;
2244   kbnode_t keyblock = NULL;
2245
2246   pk = xtrycalloc (1, sizeof *pk);
2247   if (!pk)
2248     {
2249       err = gpg_error_from_syserror ();
2250       goto leave;
2251     }
2252   err = getkey_byname (ctrl, NULL, pk, username, 1, &keyblock);
2253   if (err)
2254     goto leave;
2255
2256   err = change_passphrase (ctrl, keyblock);
2257
2258 leave:
2259   release_kbnode (keyblock);
2260   free_public_key (pk);
2261   if (err)
2262     {
2263       log_info ("error changing the passphrase for '%s': %s\n",
2264                 username, gpg_strerror (err));
2265       write_status_error ("keyedit.passwd", err);
2266     }
2267   else
2268     write_status_text (STATUS_SUCCESS, "keyedit.passwd");
2269 }
2270
2271
2272 /* Helper for quick commands to find the keyblock for USERNAME.
2273  * Returns on success the key database handle at R_KDBHD and the
2274  * keyblock at R_KEYBLOCK.  */
2275 static gpg_error_t
2276 quick_find_keyblock (ctrl_t ctrl, const char *username,
2277                      KEYDB_HANDLE *r_kdbhd, kbnode_t *r_keyblock)
2278 {
2279   gpg_error_t err;
2280   KEYDB_HANDLE kdbhd = NULL;
2281   kbnode_t keyblock = NULL;
2282   KEYDB_SEARCH_DESC desc;
2283   kbnode_t node;
2284
2285   *r_kdbhd = NULL;
2286   *r_keyblock = NULL;
2287
2288   /* Search the key; we don't want the whole getkey stuff here.  */
2289   kdbhd = keydb_new ();
2290   if (!kdbhd)
2291     {
2292       /* Note that keydb_new has already used log_error.  */
2293       err = gpg_error_from_syserror ();
2294       goto leave;
2295     }
2296
2297   err = classify_user_id (username, &desc, 1);
2298   if (!err)
2299     err = keydb_search (kdbhd, &desc, 1, NULL);
2300   if (!err)
2301     {
2302       err = keydb_get_keyblock (kdbhd, &keyblock);
2303       if (err)
2304         {
2305           log_error (_("error reading keyblock: %s\n"), gpg_strerror (err));
2306           goto leave;
2307         }
2308       /* Now with the keyblock retrieved, search again to detect an
2309          ambiguous specification.  We need to save the found state so
2310          that we can do an update later.  */
2311       keydb_push_found_state (kdbhd);
2312       err = keydb_search (kdbhd, &desc, 1, NULL);
2313       if (!err)
2314         err = gpg_error (GPG_ERR_AMBIGUOUS_NAME);
2315       else if (gpg_err_code (err) == GPG_ERR_NOT_FOUND)
2316         err = 0;
2317       keydb_pop_found_state (kdbhd);
2318
2319       if (!err)
2320         {
2321           /* We require the secret primary key to set the primary UID.  */
2322           node = find_kbnode (keyblock, PKT_PUBLIC_KEY);
2323           log_assert (node);
2324           err = agent_probe_secret_key (ctrl, node->pkt->pkt.public_key);
2325         }
2326     }
2327   else if (gpg_err_code (err) == GPG_ERR_NOT_FOUND)
2328     err = gpg_error (GPG_ERR_NO_PUBKEY);
2329
2330   if (err)
2331     {
2332       log_error (_("key \"%s\" not found: %s\n"),
2333                  username, gpg_strerror (err));
2334       goto leave;
2335     }
2336
2337   fix_keyblock (ctrl, &keyblock);
2338   merge_keys_and_selfsig (ctrl, keyblock);
2339
2340   *r_keyblock = keyblock;
2341   keyblock = NULL;
2342   *r_kdbhd = kdbhd;
2343   kdbhd = NULL;
2344
2345  leave:
2346   release_kbnode (keyblock);
2347   keydb_release (kdbhd);
2348   return err;
2349 }
2350
2351
2352 /* Unattended adding of a new keyid.  USERNAME specifies the
2353    key. NEWUID is the new user id to add to the key.  */
2354 void
2355 keyedit_quick_adduid (ctrl_t ctrl, const char *username, const char *newuid)
2356 {
2357   gpg_error_t err;
2358   KEYDB_HANDLE kdbhd = NULL;
2359   kbnode_t keyblock = NULL;
2360   char *uidstring = NULL;
2361
2362   uidstring = xstrdup (newuid);
2363   trim_spaces (uidstring);
2364   if (!*uidstring)
2365     {
2366       log_error ("%s\n", gpg_strerror (GPG_ERR_INV_USER_ID));
2367       goto leave;
2368     }
2369
2370 #ifdef HAVE_W32_SYSTEM
2371   /* See keyedit_menu for why we need this.  */
2372   check_trustdb_stale (ctrl);
2373 #endif
2374
2375   /* Search the key; we don't want the whole getkey stuff here.  */
2376   err = quick_find_keyblock (ctrl, username, &kdbhd, &keyblock);
2377   if (err)
2378     goto leave;
2379
2380   if (menu_adduid (ctrl, keyblock, 0, NULL, uidstring))
2381     {
2382       err = keydb_update_keyblock (ctrl, kdbhd, keyblock);
2383       if (err)
2384         {
2385           log_error (_("update failed: %s\n"), gpg_strerror (err));
2386           goto leave;
2387         }
2388
2389       if (update_trust)
2390         revalidation_mark (ctrl);
2391     }
2392
2393  leave:
2394   xfree (uidstring);
2395   release_kbnode (keyblock);
2396   keydb_release (kdbhd);
2397 }
2398
2399
2400 /* Unattended revocation of a keyid.  USERNAME specifies the
2401    key. UIDTOREV is the user id revoke from the key.  */
2402 void
2403 keyedit_quick_revuid (ctrl_t ctrl, const char *username, const char *uidtorev)
2404 {
2405   gpg_error_t err;
2406   KEYDB_HANDLE kdbhd = NULL;
2407   kbnode_t keyblock = NULL;
2408   kbnode_t node;
2409   int modified = 0;
2410   size_t revlen;
2411   size_t valid_uids;
2412
2413 #ifdef HAVE_W32_SYSTEM
2414   /* See keyedit_menu for why we need this.  */
2415   check_trustdb_stale (ctrl);
2416 #endif
2417
2418   /* Search the key; we don't want the whole getkey stuff here.  */
2419   err = quick_find_keyblock (ctrl, username, &kdbhd, &keyblock);
2420   if (err)
2421     goto leave;
2422
2423   /* Too make sure that we do not revoke the last valid UID, we first
2424      count how many valid UIDs there are.  */
2425   valid_uids = 0;
2426   for (node = keyblock; node; node = node->next)
2427     valid_uids += (node->pkt->pkttype == PKT_USER_ID
2428                    && !node->pkt->pkt.user_id->flags.revoked
2429                    && !node->pkt->pkt.user_id->flags.expired);
2430
2431   /* Find the right UID. */
2432   revlen = strlen (uidtorev);
2433   for (node = keyblock; node; node = node->next)
2434     {
2435       if (node->pkt->pkttype == PKT_USER_ID
2436           && revlen == node->pkt->pkt.user_id->len
2437           && !memcmp (node->pkt->pkt.user_id->name, uidtorev, revlen))
2438         {
2439           struct revocation_reason_info *reason;
2440
2441           /* Make sure that we do not revoke the last valid UID.  */
2442           if (valid_uids == 1
2443               && ! node->pkt->pkt.user_id->flags.revoked
2444               && ! node->pkt->pkt.user_id->flags.expired)
2445             {
2446               log_error (_("cannot revoke the last valid user ID.\n"));
2447               err = gpg_error (GPG_ERR_INV_USER_ID);
2448               goto leave;
2449             }
2450
2451           reason = get_default_uid_revocation_reason ();
2452           err = core_revuid (ctrl, keyblock, node, reason, &modified);
2453           release_revocation_reason_info (reason);
2454           if (err)
2455             goto leave;
2456           err = keydb_update_keyblock (ctrl, kdbhd, keyblock);
2457           if (err)
2458             {
2459               log_error (_("update failed: %s\n"), gpg_strerror (err));
2460               goto leave;
2461             }
2462
2463           revalidation_mark (ctrl);
2464           goto leave;
2465         }
2466     }
2467   err = gpg_error (GPG_ERR_NO_USER_ID);
2468
2469
2470  leave:
2471   if (err)
2472     {
2473       log_error (_("revoking the user ID failed: %s\n"), gpg_strerror (err));
2474       write_status_error ("keyedit.revoke.uid", err);
2475     }
2476   release_kbnode (keyblock);
2477   keydb_release (kdbhd);
2478 }
2479
2480
2481 /* Unattended setting of the primary uid.  USERNAME specifies the key.
2482    PRIMARYUID is the user id which shall be primary.  */
2483 void
2484 keyedit_quick_set_primary (ctrl_t ctrl, const char *username,
2485                            const char *primaryuid)
2486 {
2487   gpg_error_t err;
2488   KEYDB_HANDLE kdbhd = NULL;
2489   kbnode_t keyblock = NULL;
2490   kbnode_t node;
2491   size_t primaryuidlen;
2492   int any;
2493
2494 #ifdef HAVE_W32_SYSTEM
2495   /* See keyedit_menu for why we need this.  */
2496   check_trustdb_stale (ctrl);
2497 #endif
2498
2499   err = quick_find_keyblock (ctrl, username, &kdbhd, &keyblock);
2500   if (err)
2501     goto leave;
2502
2503   /* Find and mark the UID - we mark only the first valid one. */
2504   primaryuidlen = strlen (primaryuid);
2505   any = 0;
2506   for (node = keyblock; node; node = node->next)
2507     {
2508       if (node->pkt->pkttype == PKT_USER_ID
2509           && !any
2510           && !node->pkt->pkt.user_id->flags.revoked
2511           && !node->pkt->pkt.user_id->flags.expired
2512           && primaryuidlen == node->pkt->pkt.user_id->len
2513           && !memcmp (node->pkt->pkt.user_id->name, primaryuid, primaryuidlen))
2514         {
2515           node->flag |= NODFLG_SELUID;
2516           any = 1;
2517         }
2518       else
2519         node->flag &= ~NODFLG_SELUID;
2520     }
2521
2522   if (!any)
2523     err = gpg_error (GPG_ERR_NO_USER_ID);
2524   else if (menu_set_primary_uid (ctrl, keyblock))
2525     {
2526       merge_keys_and_selfsig (ctrl, keyblock);
2527       err = keydb_update_keyblock (ctrl, kdbhd, keyblock);
2528       if (err)
2529         {
2530           log_error (_("update failed: %s\n"), gpg_strerror (err));
2531           goto leave;
2532         }
2533       revalidation_mark (ctrl);
2534     }
2535   else
2536     err = gpg_error (GPG_ERR_GENERAL);
2537
2538   if (err)
2539     log_error (_("setting the primary user ID failed: %s\n"),
2540                gpg_strerror (err));
2541
2542  leave:
2543   release_kbnode (keyblock);
2544   keydb_release (kdbhd);
2545 }
2546
2547
2548 /* Find a keyblock by fingerprint because only this uniquely
2549  * identifies a key and may thus be used to select a key for
2550  * unattended subkey creation os key signing.  */
2551 static gpg_error_t
2552 find_by_primary_fpr (ctrl_t ctrl, const char *fpr,
2553                      kbnode_t *r_keyblock, KEYDB_HANDLE *r_kdbhd)
2554 {
2555   gpg_error_t err;
2556   kbnode_t keyblock = NULL;
2557   KEYDB_HANDLE kdbhd = NULL;
2558   KEYDB_SEARCH_DESC desc;
2559   byte fprbin[MAX_FINGERPRINT_LEN];
2560   size_t fprlen;
2561
2562   *r_keyblock = NULL;
2563   *r_kdbhd = NULL;
2564
2565   if (classify_user_id (fpr, &desc, 1)
2566       || !(desc.mode == KEYDB_SEARCH_MODE_FPR
2567            || desc.mode == KEYDB_SEARCH_MODE_FPR16
2568            || desc.mode == KEYDB_SEARCH_MODE_FPR20))
2569     {
2570       log_error (_("\"%s\" is not a fingerprint\n"), fpr);
2571       err = gpg_error (GPG_ERR_INV_NAME);
2572       goto leave;
2573     }
2574   err = get_pubkey_byname (ctrl, NULL, NULL, fpr, &keyblock, &kdbhd, 1, 1);
2575   if (err)
2576     {
2577       log_error (_("key \"%s\" not found: %s\n"), fpr, gpg_strerror (err));
2578       goto leave;
2579     }
2580
2581   /* Check that the primary fingerprint has been given. */
2582   fingerprint_from_pk (keyblock->pkt->pkt.public_key, fprbin, &fprlen);
2583   if (fprlen == 16 && desc.mode == KEYDB_SEARCH_MODE_FPR16
2584       && !memcmp (fprbin, desc.u.fpr, 16))
2585     ;
2586   else if (fprlen == 16 && desc.mode == KEYDB_SEARCH_MODE_FPR
2587            && !memcmp (fprbin, desc.u.fpr, 16)
2588            && !desc.u.fpr[16]
2589            && !desc.u.fpr[17]
2590            && !desc.u.fpr[18]
2591            && !desc.u.fpr[19])
2592     ;
2593   else if (fprlen == 20 && (desc.mode == KEYDB_SEARCH_MODE_FPR20
2594                             || desc.mode == KEYDB_SEARCH_MODE_FPR)
2595            && !memcmp (fprbin, desc.u.fpr, 20))
2596     ;
2597   else
2598     {
2599       log_error (_("\"%s\" is not the primary fingerprint\n"), fpr);
2600       err = gpg_error (GPG_ERR_INV_NAME);
2601       goto leave;
2602     }
2603
2604   *r_keyblock = keyblock;
2605   keyblock = NULL;
2606   *r_kdbhd = kdbhd;
2607   kdbhd = NULL;
2608   err = 0;
2609
2610  leave:
2611   release_kbnode (keyblock);
2612   keydb_release (kdbhd);
2613   return err;
2614 }
2615
2616
2617 /* Unattended key signing function.  If the key specifified by FPR is
2618    available and FPR is the primary fingerprint all user ids of the
2619    key are signed using the default signing key.  If UIDS is an empty
2620    list all usable UIDs are signed, if it is not empty, only those
2621    user ids matching one of the entries of the list are signed.  With
2622    LOCAL being true the signatures are marked as non-exportable.  */
2623 void
2624 keyedit_quick_sign (ctrl_t ctrl, const char *fpr, strlist_t uids,
2625                     strlist_t locusr, int local)
2626 {
2627   gpg_error_t err;
2628   kbnode_t keyblock = NULL;
2629   KEYDB_HANDLE kdbhd = NULL;
2630   int modified = 0;
2631   PKT_public_key *pk;
2632   kbnode_t node;
2633   strlist_t sl;
2634   int any;
2635
2636 #ifdef HAVE_W32_SYSTEM
2637   /* See keyedit_menu for why we need this.  */
2638   check_trustdb_stale (ctrl);
2639 #endif
2640
2641   /* We require a fingerprint because only this uniquely identifies a
2642      key and may thus be used to select a key for unattended key
2643      signing.  */
2644   if (find_by_primary_fpr (ctrl, fpr, &keyblock, &kdbhd))
2645     goto leave;
2646
2647   if (fix_keyblock (ctrl, &keyblock))
2648     modified++;
2649
2650   /* Give some info in verbose.  */
2651   if (opt.verbose)
2652     {
2653       show_key_with_all_names (ctrl, es_stdout, keyblock, 0,
2654                                1/*with_revoker*/, 1/*with_fingerprint*/,
2655                                0, 0, 1);
2656       es_fflush (es_stdout);
2657     }
2658
2659   pk = keyblock->pkt->pkt.public_key;
2660   if (pk->flags.revoked)
2661     {
2662       if (!opt.verbose)
2663         show_key_with_all_names (ctrl, es_stdout, keyblock, 0, 0, 0, 0, 0, 1);
2664       log_error ("%s%s", _("Key is revoked."), _("  Unable to sign.\n"));
2665       goto leave;
2666     }
2667
2668   /* Set the flags according to the UIDS list.  Fixme: We may want to
2669      use classify_user_id along with dedicated compare functions so
2670      that we match the same way as in the key lookup. */
2671   any = 0;
2672   menu_select_uid (keyblock, 0);   /* Better clear the flags first. */
2673   for (sl=uids; sl; sl = sl->next)
2674     {
2675       const char *name = sl->d;
2676       int count = 0;
2677
2678       sl->flags &= ~(1|2);  /* Clear flags used for error reporting.  */
2679
2680       for (node = keyblock; node; node = node->next)
2681         {
2682           if (node->pkt->pkttype == PKT_USER_ID)
2683             {
2684               PKT_user_id *uid = node->pkt->pkt.user_id;
2685
2686               if (uid->attrib_data)
2687                 ;
2688               else if (*name == '='
2689                        && strlen (name+1) == uid->len
2690                        && !memcmp (uid->name, name + 1, uid->len))
2691                 { /* Exact match - we don't do a check for ambiguity
2692                    * in this case.  */
2693                   node->flag |= NODFLG_SELUID;
2694                   if (any != -1)
2695                     {
2696                       sl->flags |= 1;  /* Report as found.  */
2697                       any = 1;
2698                     }
2699                 }
2700               else if (ascii_memistr (uid->name, uid->len,
2701                                       *name == '*'? name+1:name))
2702                 {
2703                   node->flag |= NODFLG_SELUID;
2704                   if (any != -1)
2705                     {
2706                       sl->flags |= 1;  /* Report as found.  */
2707                       any = 1;
2708                     }
2709                   count++;
2710                 }
2711             }
2712         }
2713
2714       if (count > 1)
2715         {
2716           any = -1;        /* Force failure at end.  */
2717           sl->flags |= 2;  /* Report as ambiguous.  */
2718         }
2719     }
2720
2721   /* Check whether all given user ids were found.  */
2722   for (sl=uids; sl; sl = sl->next)
2723     if (!(sl->flags & 1))
2724       any = -1;  /* That user id was not found.  */
2725
2726   /* Print an error if there was a problem with the user ids.  */
2727   if (uids && any < 1)
2728     {
2729       if (!opt.verbose)
2730         show_key_with_all_names (ctrl, es_stdout, keyblock, 0, 0, 0, 0, 0, 1);
2731       es_fflush (es_stdout);
2732       for (sl=uids; sl; sl = sl->next)
2733         {
2734           if ((sl->flags & 2))
2735             log_info (_("Invalid user ID '%s': %s\n"),
2736                       sl->d, gpg_strerror (GPG_ERR_AMBIGUOUS_NAME));
2737           else if (!(sl->flags & 1))
2738             log_info (_("Invalid user ID '%s': %s\n"),
2739                       sl->d, gpg_strerror (GPG_ERR_NOT_FOUND));
2740         }
2741       log_error ("%s  %s", _("No matching user IDs."), _("Nothing to sign.\n"));
2742       goto leave;
2743     }
2744
2745   /* Sign. */
2746   sign_uids (ctrl, es_stdout, keyblock, locusr, &modified, local, 0, 0, 0, 1);
2747   es_fflush (es_stdout);
2748
2749   if (modified)
2750     {
2751       err = keydb_update_keyblock (ctrl, kdbhd, keyblock);
2752       if (err)
2753         {
2754           log_error (_("update failed: %s\n"), gpg_strerror (err));
2755           goto leave;
2756         }
2757     }
2758   else
2759     log_info (_("Key not changed so no update needed.\n"));
2760
2761   if (update_trust)
2762     revalidation_mark (ctrl);
2763
2764
2765  leave:
2766   release_kbnode (keyblock);
2767   keydb_release (kdbhd);
2768 }
2769
2770
2771 /* Unattended subkey creation function.
2772  *
2773  */
2774 void
2775 keyedit_quick_addkey (ctrl_t ctrl, const char *fpr, const char *algostr,
2776                       const char *usagestr, const char *expirestr)
2777 {
2778   gpg_error_t err;
2779   kbnode_t keyblock;
2780   KEYDB_HANDLE kdbhd;
2781   int modified = 0;
2782   PKT_public_key *pk;
2783
2784 #ifdef HAVE_W32_SYSTEM
2785   /* See keyedit_menu for why we need this.  */
2786   check_trustdb_stale (ctrl);
2787 #endif
2788
2789   /* We require a fingerprint because only this uniquely identifies a
2790    * key and may thus be used to select a key for unattended subkey
2791    * creation.  */
2792   if (find_by_primary_fpr (ctrl, fpr, &keyblock, &kdbhd))
2793     goto leave;
2794
2795   if (fix_keyblock (ctrl, &keyblock))
2796     modified++;
2797
2798   pk = keyblock->pkt->pkt.public_key;
2799   if (pk->flags.revoked)
2800     {
2801       if (!opt.verbose)
2802         show_key_with_all_names (ctrl, es_stdout, keyblock, 0, 0, 0, 0, 0, 1);
2803       log_error ("%s%s", _("Key is revoked."), "\n");
2804       goto leave;
2805     }
2806
2807   /* Create the subkey.  Note that the called function already prints
2808    * an error message. */
2809   if (!generate_subkeypair (ctrl, keyblock, algostr, usagestr, expirestr))
2810     modified = 1;
2811   es_fflush (es_stdout);
2812
2813   /* Store.  */
2814   if (modified)
2815     {
2816       err = keydb_update_keyblock (ctrl, kdbhd, keyblock);
2817       if (err)
2818         {
2819           log_error (_("update failed: %s\n"), gpg_strerror (err));
2820           goto leave;
2821         }
2822     }
2823   else
2824     log_info (_("Key not changed so no update needed.\n"));
2825
2826  leave:
2827   release_kbnode (keyblock);
2828   keydb_release (kdbhd);
2829 }
2830
2831
2832 /* Unattended expiration setting function for the main key.  If
2833  * SUBKEYFPRS is not NULL and SUBKEYSFPRS[0] is neither NULL, it is
2834  * expected to be an array of fingerprints for subkeys to change. It
2835  * may also be an array which just one item "*" to indicate that all
2836  * keys shall be set to that expiration date.
2837  */
2838 void
2839 keyedit_quick_set_expire (ctrl_t ctrl, const char *fpr, const char *expirestr,
2840                           char **subkeyfprs)
2841 {
2842   gpg_error_t err;
2843   kbnode_t keyblock, node;
2844   KEYDB_HANDLE kdbhd;
2845   int modified = 0;
2846   PKT_public_key *pk;
2847   u32 expire;
2848   int primary_only = 0;
2849   int idx;
2850
2851 #ifdef HAVE_W32_SYSTEM
2852   /* See keyedit_menu for why we need this.  */
2853   check_trustdb_stale (ctrl);
2854 #endif
2855
2856   /* We require a fingerprint because only this uniquely identifies a
2857    * key and may thus be used to select a key for unattended
2858    * expiration setting.  */
2859   err = find_by_primary_fpr (ctrl, fpr, &keyblock, &kdbhd);
2860   if (err)
2861     goto leave;
2862
2863   if (fix_keyblock (ctrl, &keyblock))
2864     modified++;
2865
2866   pk = keyblock->pkt->pkt.public_key;
2867   if (pk->flags.revoked)
2868     {
2869       if (!opt.verbose)
2870         show_key_with_all_names (ctrl, es_stdout, keyblock, 0, 0, 0, 0, 0, 1);
2871       log_error ("%s%s", _("Key is revoked."), "\n");
2872       err = gpg_error (GPG_ERR_CERT_REVOKED);
2873       goto leave;
2874     }
2875
2876   expire = parse_expire_string (expirestr);
2877   if (expire == (u32)-1 )
2878     {
2879       log_error (_("'%s' is not a valid expiration time\n"), expirestr);
2880       err = gpg_error (GPG_ERR_INV_VALUE);
2881       goto leave;
2882     }
2883   if (expire)
2884     expire += make_timestamp ();
2885
2886   /* Check whether a subkey's expiration time shall be changed or the
2887    * expiration time of all keys.  */
2888   if (!subkeyfprs || !subkeyfprs[0])
2889     primary_only = 1;
2890   else if ( !strcmp (subkeyfprs[0], "*") && !subkeyfprs[1])
2891     {
2892       /* Change all subkeys keys which have not been revoked and are
2893        * not yet expired.  */
2894       merge_keys_and_selfsig (ctrl, keyblock);
2895       for (node = keyblock; node; node = node->next)
2896         {
2897           if (node->pkt->pkttype == PKT_PUBLIC_SUBKEY
2898               && (pk = node->pkt->pkt.public_key)
2899               && !pk->flags.revoked
2900               && !pk->has_expired)
2901             node->flag |= NODFLG_SELKEY;
2902         }
2903     }
2904   else
2905     {
2906       /* Change specified subkeys.  */
2907       KEYDB_SEARCH_DESC desc;
2908       byte fprbin[MAX_FINGERPRINT_LEN];
2909       size_t fprlen;
2910
2911       err = 0;
2912       merge_keys_and_selfsig (ctrl, keyblock);
2913       for (idx=0; subkeyfprs[idx]; idx++)
2914         {
2915           int any = 0;
2916
2917           /* Parse the fingerprint.  */
2918           if (classify_user_id (subkeyfprs[idx], &desc, 1)
2919               || !(desc.mode == KEYDB_SEARCH_MODE_FPR
2920                    || desc.mode == KEYDB_SEARCH_MODE_FPR20))
2921             {
2922               log_error (_("\"%s\" is not a proper fingerprint\n"),
2923                          subkeyfprs[idx] );
2924               if (!err)
2925                 err = gpg_error (GPG_ERR_INV_NAME);
2926               continue;
2927             }
2928
2929           /* Set the flag for the matching non revoked subkey.  */
2930           for (node = keyblock; node; node = node->next)
2931             {
2932               if (node->pkt->pkttype == PKT_PUBLIC_SUBKEY
2933                   && (pk = node->pkt->pkt.public_key)
2934                   && !pk->flags.revoked )
2935                 {
2936                   fingerprint_from_pk (pk, fprbin, &fprlen);
2937                   if (fprlen == 20 && !memcmp (fprbin, desc.u.fpr, 20))
2938                     {
2939                       node->flag |= NODFLG_SELKEY;
2940                       any = 1;
2941                     }
2942                 }
2943             }
2944           if (!any)
2945             {
2946               log_error (_("subkey \"%s\" not found\n"), subkeyfprs[idx]);
2947               if (!err)
2948                 err = gpg_error (GPG_ERR_NOT_FOUND);
2949             }
2950         }
2951
2952       if (err)
2953         goto leave;
2954     }
2955
2956   /* Set the new expiration date.  */
2957   err = menu_expire (ctrl, keyblock, primary_only? 1 : 2, expire);
2958   if (gpg_err_code (err) == GPG_ERR_TRUE)
2959     modified = 1;
2960   else if (err)
2961     goto leave;
2962   es_fflush (es_stdout);
2963
2964   /* Store.  */
2965   if (modified)
2966     {
2967       err = keydb_update_keyblock (ctrl, kdbhd, keyblock);
2968       if (err)
2969         {
2970           log_error (_("update failed: %s\n"), gpg_strerror (err));
2971           goto leave;
2972         }
2973       if (update_trust)
2974         revalidation_mark (ctrl);
2975     }
2976   else
2977     log_info (_("Key not changed so no update needed.\n"));
2978
2979  leave:
2980   release_kbnode (keyblock);
2981   keydb_release (kdbhd);
2982   if (err)
2983     write_status_error ("set_expire", err);
2984 }
2985
2986
2987 \f
2988 static void
2989 tty_print_notations (int indent, PKT_signature * sig)
2990 {
2991   int first = 1;
2992   struct notation *notation, *nd;
2993
2994   if (indent < 0)
2995     {
2996       first = 0;
2997       indent = -indent;
2998     }
2999
3000   notation = sig_to_notation (sig);
3001
3002   for (nd = notation; nd; nd = nd->next)
3003     {
3004       if (!first)
3005         tty_printf ("%*s", indent, "");
3006       else
3007         first = 0;
3008
3009       tty_print_utf8_string (nd->name, strlen (nd->name));
3010       tty_printf ("=");
3011       tty_print_utf8_string (nd->value, strlen (nd->value));
3012       tty_printf ("\n");
3013     }
3014
3015   free_notation (notation);
3016 }
3017
3018
3019 /*
3020  * Show preferences of a public keyblock.
3021  */
3022 static void
3023 show_prefs (PKT_user_id * uid, PKT_signature * selfsig, int verbose)
3024 {
3025   const prefitem_t fake = { 0, 0 };
3026   const prefitem_t *prefs;
3027   int i;
3028
3029   if (!uid)
3030     return;
3031
3032   if (uid->prefs)
3033     prefs = uid->prefs;
3034   else if (verbose)
3035     prefs = &fake;
3036   else
3037     return;
3038
3039   if (verbose)
3040     {
3041       int any, des_seen = 0, sha1_seen = 0, uncomp_seen = 0;
3042
3043       tty_printf ("     ");
3044       tty_printf (_("Cipher: "));
3045       for (i = any = 0; prefs[i].type; i++)
3046         {
3047           if (prefs[i].type == PREFTYPE_SYM)
3048             {
3049               if (any)
3050                 tty_printf (", ");
3051               any = 1;
3052               /* We don't want to display strings for experimental algos */
3053               if (!openpgp_cipher_test_algo (prefs[i].value)
3054                   && prefs[i].value < 100)
3055                 tty_printf ("%s", openpgp_cipher_algo_name (prefs[i].value));
3056               else
3057                 tty_printf ("[%d]", prefs[i].value);
3058               if (prefs[i].value == CIPHER_ALGO_3DES)
3059                 des_seen = 1;
3060             }
3061         }
3062       if (!des_seen)
3063         {
3064           if (any)
3065             tty_printf (", ");
3066           tty_printf ("%s", openpgp_cipher_algo_name (CIPHER_ALGO_3DES));
3067         }
3068       tty_printf ("\n     ");
3069       tty_printf (_("AEAD: "));
3070       for (i = any = 0; prefs[i].type; i++)
3071         {
3072           if (prefs[i].type == PREFTYPE_AEAD)
3073             {
3074               if (any)
3075                 tty_printf (", ");
3076               any = 1;
3077               /* We don't want to display strings for experimental algos */
3078               if (!openpgp_aead_test_algo (prefs[i].value)
3079                   && prefs[i].value < 100)
3080                 tty_printf ("%s", openpgp_aead_algo_name (prefs[i].value));
3081               else
3082                 tty_printf ("[%d]", prefs[i].value);
3083             }
3084         }
3085       tty_printf ("\n     ");
3086       tty_printf (_("Digest: "));
3087       for (i = any = 0; prefs[i].type; i++)
3088         {
3089           if (prefs[i].type == PREFTYPE_HASH)
3090             {
3091               if (any)
3092                 tty_printf (", ");
3093               any = 1;
3094               /* We don't want to display strings for experimental algos */
3095               if (!gcry_md_test_algo (prefs[i].value) && prefs[i].value < 100)
3096                 tty_printf ("%s", gcry_md_algo_name (prefs[i].value));
3097               else
3098                 tty_printf ("[%d]", prefs[i].value);
3099               if (prefs[i].value == DIGEST_ALGO_SHA1)
3100                 sha1_seen = 1;
3101             }
3102         }
3103       if (!sha1_seen)
3104         {
3105           if (any)
3106             tty_printf (", ");
3107           tty_printf ("%s", gcry_md_algo_name (DIGEST_ALGO_SHA1));
3108         }
3109       tty_printf ("\n     ");
3110       tty_printf (_("Compression: "));
3111       for (i = any = 0; prefs[i].type; i++)
3112         {
3113           if (prefs[i].type == PREFTYPE_ZIP)
3114             {
3115               const char *s = compress_algo_to_string (prefs[i].value);
3116
3117               if (any)
3118                 tty_printf (", ");
3119               any = 1;
3120               /* We don't want to display strings for experimental algos */
3121               if (s && prefs[i].value < 100)
3122                 tty_printf ("%s", s);
3123               else
3124                 tty_printf ("[%d]", prefs[i].value);
3125               if (prefs[i].value == COMPRESS_ALGO_NONE)
3126                 uncomp_seen = 1;
3127             }
3128         }
3129       if (!uncomp_seen)
3130         {
3131           if (any)
3132             tty_printf (", ");
3133           else
3134             {
3135               tty_printf ("%s", compress_algo_to_string (COMPRESS_ALGO_ZIP));
3136               tty_printf (", ");
3137             }
3138           tty_printf ("%s", compress_algo_to_string (COMPRESS_ALGO_NONE));
3139         }
3140       if (uid->flags.mdc || uid->flags.aead || !uid->flags.ks_modify)
3141         {
3142           tty_printf ("\n     ");
3143           tty_printf (_("Features: "));
3144           any = 0;
3145           if (uid->flags.mdc)
3146             {
3147               tty_printf ("MDC");
3148               any = 1;
3149             }
3150           if (!uid->flags.aead)
3151             {
3152               if (any)
3153                 tty_printf (", ");
3154               tty_printf ("AEAD");
3155             }
3156           if (!uid->flags.ks_modify)
3157             {
3158               if (any)
3159                 tty_printf (", ");
3160               tty_printf (_("Keyserver no-modify"));
3161             }
3162         }
3163       tty_printf ("\n");
3164
3165       if (selfsig)
3166         {
3167           const byte *pref_ks;
3168           size_t pref_ks_len;
3169
3170           pref_ks = parse_sig_subpkt (selfsig->hashed,
3171                                       SIGSUBPKT_PREF_KS, &pref_ks_len);
3172           if (pref_ks && pref_ks_len)
3173             {
3174               tty_printf ("     ");
3175               tty_printf (_("Preferred keyserver: "));
3176               tty_print_utf8_string (pref_ks, pref_ks_len);
3177               tty_printf ("\n");
3178             }
3179
3180           if (selfsig->flags.notation)
3181             {
3182               tty_printf ("     ");
3183               tty_printf (_("Notations: "));
3184               tty_print_notations (5 + strlen (_("Notations: ")), selfsig);
3185             }
3186         }
3187     }
3188   else
3189     {
3190       tty_printf ("    ");
3191       for (i = 0; prefs[i].type; i++)
3192         {
3193           tty_printf (" %c%d", prefs[i].type == PREFTYPE_SYM ? 'S' :
3194                       prefs[i].type == PREFTYPE_AEAD ? 'A' :
3195                       prefs[i].type == PREFTYPE_HASH ? 'H' :
3196                       prefs[i].type == PREFTYPE_ZIP ? 'Z' : '?',
3197                       prefs[i].value);
3198         }
3199       if (uid->flags.mdc)
3200         tty_printf (" [mdc]");
3201       if (uid->flags.aead)
3202         tty_printf (" [aead]");
3203       if (!uid->flags.ks_modify)
3204         tty_printf (" [no-ks-modify]");
3205       tty_printf ("\n");
3206     }
3207 }
3208
3209
3210 /* This is the version of show_key_with_all_names used when
3211    opt.with_colons is used.  It prints all available data in a easy to
3212    parse format and does not translate utf8 */
3213 static void
3214 show_key_with_all_names_colon (ctrl_t ctrl, estream_t fp, kbnode_t keyblock)
3215 {
3216   KBNODE node;
3217   int i, j, ulti_hack = 0;
3218   byte pk_version = 0;
3219   PKT_public_key *primary = NULL;
3220   int have_seckey;
3221
3222   if (!fp)
3223     fp = es_stdout;
3224
3225   /* the keys */
3226   for (node = keyblock; node; node = node->next)
3227     {
3228       if (node->pkt->pkttype == PKT_PUBLIC_KEY
3229           || (node->pkt->pkttype == PKT_PUBLIC_SUBKEY))
3230         {
3231           PKT_public_key *pk = node->pkt->pkt.public_key;
3232           u32 keyid[2];
3233
3234           if (node->pkt->pkttype == PKT_PUBLIC_KEY)
3235             {
3236               pk_version = pk->version;
3237               primary = pk;
3238             }
3239
3240           keyid_from_pk (pk, keyid);
3241           have_seckey = !agent_probe_secret_key (ctrl, pk);
3242
3243           if (node->pkt->pkttype == PKT_PUBLIC_KEY)
3244             es_fputs (have_seckey? "sec:" : "pub:", fp);
3245           else
3246             es_fputs (have_seckey? "ssb:" : "sub:", fp);
3247
3248           if (!pk->flags.valid)
3249             es_putc ('i', fp);
3250           else if (pk->flags.revoked)
3251             es_putc ('r', fp);
3252           else if (pk->has_expired)
3253             es_putc ('e', fp);
3254           else if (!(opt.fast_list_mode || opt.no_expensive_trust_checks))
3255             {
3256               int trust = get_validity_info (ctrl, keyblock, pk, NULL);
3257               if (trust == 'u')
3258                 ulti_hack = 1;
3259               es_putc (trust, fp);
3260             }
3261
3262           es_fprintf (fp, ":%u:%d:%08lX%08lX:%lu:%lu::",
3263                       nbits_from_pk (pk),
3264                       pk->pubkey_algo,
3265                       (ulong) keyid[0], (ulong) keyid[1],
3266                       (ulong) pk->timestamp, (ulong) pk->expiredate);
3267           if (node->pkt->pkttype == PKT_PUBLIC_KEY
3268               && !(opt.fast_list_mode || opt.no_expensive_trust_checks))
3269             es_putc (get_ownertrust_info (ctrl, pk, 0), fp);
3270           es_putc (':', fp);
3271           es_putc (':', fp);
3272           es_putc (':', fp);
3273           /* Print capabilities.  */
3274           if ((pk->pubkey_usage & PUBKEY_USAGE_ENC))
3275             es_putc ('e', fp);
3276           if ((pk->pubkey_usage & PUBKEY_USAGE_SIG))
3277             es_putc ('s', fp);
3278           if ((pk->pubkey_usage & PUBKEY_USAGE_CERT))
3279             es_putc ('c', fp);
3280           if ((pk->pubkey_usage & PUBKEY_USAGE_AUTH))
3281             es_putc ('a', fp);
3282           es_putc ('\n', fp);
3283
3284           print_fingerprint (ctrl, fp, pk, 0);
3285           print_revokers (fp, pk);
3286         }
3287     }
3288
3289   /* the user ids */
3290   i = 0;
3291   for (node = keyblock; node; node = node->next)
3292     {
3293       if (node->pkt->pkttype == PKT_USER_ID)
3294         {
3295           PKT_user_id *uid = node->pkt->pkt.user_id;
3296
3297           ++i;
3298
3299           if (uid->attrib_data)
3300             es_fputs ("uat:", fp);
3301           else
3302             es_fputs ("uid:", fp);
3303
3304           if (uid->flags.revoked)
3305             es_fputs ("r::::::::", fp);
3306           else if (uid->flags.expired)
3307             es_fputs ("e::::::::", fp);
3308           else if (opt.fast_list_mode || opt.no_expensive_trust_checks)
3309             es_fputs ("::::::::", fp);
3310           else
3311             {
3312               int uid_validity;
3313
3314               if (primary && !ulti_hack)
3315                 uid_validity = get_validity_info (ctrl, keyblock, primary, uid);
3316               else
3317                 uid_validity = 'u';
3318               es_fprintf (fp, "%c::::::::", uid_validity);
3319             }
3320
3321           if (uid->attrib_data)
3322             es_fprintf (fp, "%u %lu", uid->numattribs, uid->attrib_len);
3323           else
3324             es_write_sanitized (fp, uid->name, uid->len, ":", NULL);
3325
3326           es_putc (':', fp);
3327           /* signature class */
3328           es_putc (':', fp);
3329           /* capabilities */
3330           es_putc (':', fp);
3331           /* preferences */
3332           if (pk_version > 3 || uid->selfsigversion > 3)
3333             {
3334               const prefitem_t *prefs = uid->prefs;
3335
3336               for (j = 0; prefs && prefs[j].type; j++)
3337                 {
3338                   if (j)
3339                     es_putc (' ', fp);
3340                   es_fprintf (fp,
3341                               "%c%d", prefs[j].type == PREFTYPE_SYM ? 'S' :
3342                               prefs[j].type == PREFTYPE_HASH ? 'H' :
3343                               prefs[j].type == PREFTYPE_ZIP ? 'Z' : '?',
3344                               prefs[j].value);
3345                 }
3346               if (uid->flags.mdc)
3347                 es_fputs (",mdc", fp);
3348               if (uid->flags.aead)
3349                 es_fputs (",aead", fp);
3350               if (!uid->flags.ks_modify)
3351                 es_fputs (",no-ks-modify", fp);
3352             }
3353           es_putc (':', fp);
3354           /* flags */
3355           es_fprintf (fp, "%d,", i);
3356           if (uid->flags.primary)
3357             es_putc ('p', fp);
3358           if (uid->flags.revoked)
3359             es_putc ('r', fp);
3360           if (uid->flags.expired)
3361             es_putc ('e', fp);
3362           if ((node->flag & NODFLG_SELUID))
3363             es_putc ('s', fp);
3364           if ((node->flag & NODFLG_MARK_A))
3365             es_putc ('m', fp);
3366           es_putc (':', fp);
3367           if (opt.trust_model == TM_TOFU || opt.trust_model == TM_TOFU_PGP)
3368             {
3369 #ifdef USE_TOFU
3370               enum tofu_policy policy;
3371               if (! tofu_get_policy (ctrl, primary, uid, &policy)
3372                   && policy != TOFU_POLICY_NONE)
3373                 es_fprintf (fp, "%s", tofu_policy_str (policy));
3374 #endif /*USE_TOFU*/
3375             }
3376           es_putc (':', fp);
3377           es_putc ('\n', fp);
3378         }
3379     }
3380 }
3381
3382
3383 static void
3384 show_names (ctrl_t ctrl, estream_t fp,
3385             kbnode_t keyblock, PKT_public_key * pk, unsigned int flag,
3386             int with_prefs)