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