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