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