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