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