5fc92b2c71a361af8e9990408c53cb321f4025d4
[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, cmdCHECKBKUPKEY,
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   { "checkbkupkey", cmdCHECKBKUPKEY, KEYEDIT_NEED_SK | KEYEDIT_ONLY_SK, NULL},
1408 #endif /*ENABLE_CARD_SUPPORT */
1409   { "delkey", cmdDELKEY, KEYEDIT_NOT_SK, N_("delete selected subkeys")},
1410   { "addrevoker", cmdADDREVOKER, KEYEDIT_NOT_SK | KEYEDIT_NEED_SK,
1411     N_("add a revocation key")},
1412   { "delsig", cmdDELSIG, KEYEDIT_NOT_SK,
1413     N_("delete signatures from the selected user IDs")},
1414   { "expire", cmdEXPIRE, KEYEDIT_NOT_SK | KEYEDIT_NEED_SK,
1415     N_("change the expiration date for the key or selected subkeys")},
1416   { "primary", cmdPRIMARY, KEYEDIT_NOT_SK | KEYEDIT_NEED_SK,
1417     N_("flag the selected user ID as primary")},
1418   { "toggle", cmdTOGGLE, KEYEDIT_NEED_SK, NULL},  /* Dummy command.  */
1419   { "t", cmdTOGGLE, KEYEDIT_NEED_SK, NULL},
1420   { "pref", cmdPREF, KEYEDIT_NOT_SK, N_("list preferences (expert)")},
1421   { "showpref", cmdSHOWPREF, KEYEDIT_NOT_SK, N_("list preferences (verbose)")},
1422   { "setpref", cmdSETPREF, KEYEDIT_NOT_SK | KEYEDIT_NEED_SK,
1423     N_("set preference list for the selected user IDs")},
1424   { "updpref", cmdSETPREF, KEYEDIT_NOT_SK | KEYEDIT_NEED_SK, NULL},
1425   { "keyserver", cmdPREFKS, KEYEDIT_NOT_SK | KEYEDIT_NEED_SK,
1426     N_("set the preferred keyserver URL for the selected user IDs")},
1427   { "notation", cmdNOTATION, KEYEDIT_NOT_SK | KEYEDIT_NEED_SK,
1428     N_("set a notation for the selected user IDs")},
1429   { "passwd", cmdPASSWD, KEYEDIT_NOT_SK | KEYEDIT_NEED_SK,
1430     N_("change the passphrase")},
1431   { "password", cmdPASSWD, KEYEDIT_NOT_SK | KEYEDIT_NEED_SK, NULL},
1432 #ifndef NO_TRUST_MODELS
1433   { "trust", cmdTRUST, KEYEDIT_NOT_SK, N_("change the ownertrust")},
1434 #endif /*!NO_TRUST_MODELS*/
1435   { "revsig", cmdREVSIG, KEYEDIT_NOT_SK,
1436     N_("revoke signatures on the selected user IDs")},
1437   { "revuid", cmdREVUID, KEYEDIT_NOT_SK | KEYEDIT_NEED_SK,
1438     N_("revoke selected user IDs")},
1439   { "revphoto", cmdREVUID, KEYEDIT_NOT_SK | KEYEDIT_NEED_SK, NULL},
1440   { "revkey", cmdREVKEY, KEYEDIT_NOT_SK | KEYEDIT_NEED_SK,
1441     N_("revoke key or selected subkeys")},
1442 #ifndef NO_TRUST_MODELS
1443   { "enable", cmdENABLEKEY, KEYEDIT_NOT_SK, N_("enable key")},
1444   { "disable", cmdDISABLEKEY, KEYEDIT_NOT_SK, N_("disable key")},
1445 #endif /*!NO_TRUST_MODELS*/
1446   { "showphoto", cmdSHOWPHOTO, 0, N_("show selected photo IDs")},
1447   { "clean", cmdCLEAN, KEYEDIT_NOT_SK,
1448     N_("compact unusable user IDs and remove unusable signatures from key")},
1449   { "minimize", cmdMINIMIZE, KEYEDIT_NOT_SK,
1450     N_("compact unusable user IDs and remove all signatures from key")},
1451
1452   { NULL, cmdNONE, 0, NULL}
1453 };
1454
1455
1456 \f
1457 #ifdef HAVE_LIBREADLINE
1458
1459 /*
1460    These two functions are used by readline for command completion.
1461  */
1462
1463 static char *
1464 command_generator (const char *text, int state)
1465 {
1466   static int list_index, len;
1467   const char *name;
1468
1469   /* If this is a new word to complete, initialize now.  This includes
1470      saving the length of TEXT for efficiency, and initializing the
1471      index variable to 0. */
1472   if (!state)
1473     {
1474       list_index = 0;
1475       len = strlen (text);
1476     }
1477
1478   /* Return the next partial match */
1479   while ((name = cmds[list_index].name))
1480     {
1481       /* Only complete commands that have help text */
1482       if (cmds[list_index++].desc && strncmp (name, text, len) == 0)
1483         return strdup (name);
1484     }
1485
1486   return NULL;
1487 }
1488
1489 static char **
1490 keyedit_completion (const char *text, int start, int end)
1491 {
1492   /* If we are at the start of a line, we try and command-complete.
1493      If not, just do nothing for now. */
1494
1495   (void) end;
1496
1497   if (start == 0)
1498     return rl_completion_matches (text, command_generator);
1499
1500   rl_attempted_completion_over = 1;
1501
1502   return NULL;
1503 }
1504 #endif /* HAVE_LIBREADLINE */
1505
1506
1507 \f
1508 /* Main function of the menu driven key editor.  */
1509 void
1510 keyedit_menu (ctrl_t ctrl, const char *username, strlist_t locusr,
1511               strlist_t commands, int quiet, int seckey_check)
1512 {
1513   enum cmdids cmd = 0;
1514   gpg_error_t err = 0;
1515   KBNODE keyblock = NULL;
1516   KEYDB_HANDLE kdbhd = NULL;
1517   int have_seckey = 0;
1518   char *answer = NULL;
1519   int redisplay = 1;
1520   int modified = 0;
1521   int sec_shadowing = 0;
1522   int run_subkey_warnings = 0;
1523   int have_commands = !!commands;
1524
1525   if (opt.command_fd != -1)
1526     ;
1527   else if (opt.batch && !have_commands)
1528     {
1529       log_error (_("can't do this in batch mode\n"));
1530       goto leave;
1531     }
1532
1533 #ifdef HAVE_W32_SYSTEM
1534   /* Due to Windows peculiarities we need to make sure that the
1535      trustdb stale check is done before we open another file
1536      (i.e. by searching for a key).  In theory we could make sure
1537      that the files are closed after use but the open/close caches
1538      inhibits that and flushing the cache right before the stale
1539      check is not easy to implement.  Thus we take the easy way out
1540      and run the stale check as early as possible.  Note, that for
1541      non- W32 platforms it is run indirectly trough a call to
1542      get_validity ().  */
1543   check_trustdb_stale ();
1544 #endif
1545
1546   /* Get the public key */
1547   err = get_pubkey_byname (ctrl, NULL, NULL, username, &keyblock, &kdbhd, 1, 1);
1548   if (err)
1549     {
1550       log_error (_("key \"%s\" not found: %s\n"), username, gpg_strerror (err));
1551       goto leave;
1552     }
1553
1554   if (fix_keyblock (&keyblock))
1555     modified++;
1556
1557   /* See whether we have a matching secret key.  */
1558   if (seckey_check)
1559     {
1560       have_seckey = !agent_probe_any_secret_key (ctrl, keyblock);
1561       if (have_seckey && !quiet)
1562         tty_printf (_("Secret key is available.\n"));
1563     }
1564
1565   /* Main command loop.  */
1566   for (;;)
1567     {
1568       int i, arg_number, photo;
1569       const char *arg_string = "";
1570       char *p;
1571       PKT_public_key *pk = keyblock->pkt->pkt.public_key;
1572
1573       tty_printf ("\n");
1574
1575       if (redisplay && !quiet)
1576         {
1577           /* Show using flags: with_revoker, with_subkeys.  */
1578           show_key_with_all_names (ctrl, NULL, keyblock, 0, 1, 0, 1, 0, 0);
1579           tty_printf ("\n");
1580           redisplay = 0;
1581         }
1582
1583       if (run_subkey_warnings)
1584         {
1585           run_subkey_warnings = 0;
1586           if (!count_selected_keys (keyblock))
1587             subkey_expire_warning (keyblock);
1588         }
1589
1590       do
1591         {
1592           xfree (answer);
1593           if (have_commands)
1594             {
1595               if (commands)
1596                 {
1597                   answer = xstrdup (commands->d);
1598                   commands = commands->next;
1599                 }
1600               else if (opt.batch)
1601                 {
1602                   answer = xstrdup ("quit");
1603                 }
1604               else
1605                 have_commands = 0;
1606             }
1607           if (!have_commands)
1608             {
1609 #ifdef HAVE_LIBREADLINE
1610               tty_enable_completion (keyedit_completion);
1611 #endif
1612               answer = cpr_get_no_help ("keyedit.prompt", GPG_NAME "> ");
1613               cpr_kill_prompt ();
1614               tty_disable_completion ();
1615             }
1616           trim_spaces (answer);
1617         }
1618       while (*answer == '#');
1619
1620       arg_number = 0; /* Here is the init which egcc complains about.  */
1621       photo = 0;      /* Same here. */
1622       if (!*answer)
1623         cmd = cmdLIST;
1624       else if (*answer == CONTROL_D)
1625         cmd = cmdQUIT;
1626       else if (digitp (answer))
1627         {
1628           cmd = cmdSELUID;
1629           arg_number = atoi (answer);
1630         }
1631       else
1632         {
1633           if ((p = strchr (answer, ' ')))
1634             {
1635               *p++ = 0;
1636               trim_spaces (answer);
1637               trim_spaces (p);
1638               arg_number = atoi (p);
1639               arg_string = p;
1640             }
1641
1642           for (i = 0; cmds[i].name; i++)
1643             {
1644               if (cmds[i].flags & KEYEDIT_TAIL_MATCH)
1645                 {
1646                   size_t l = strlen (cmds[i].name);
1647                   size_t a = strlen (answer);
1648                   if (a >= l)
1649                     {
1650                       if (!ascii_strcasecmp (&answer[a - l], cmds[i].name))
1651                         {
1652                           answer[a - l] = '\0';
1653                           break;
1654                         }
1655                     }
1656                 }
1657               else if (!ascii_strcasecmp (answer, cmds[i].name))
1658                 break;
1659             }
1660           if ((cmds[i].flags & KEYEDIT_NEED_SK) && !have_seckey)
1661             {
1662               tty_printf (_("Need the secret key to do this.\n"));
1663               cmd = cmdNOP;
1664             }
1665           else
1666             cmd = cmds[i].id;
1667         }
1668
1669       /* Dispatch the command.  */
1670       switch (cmd)
1671         {
1672         case cmdHELP:
1673           for (i = 0; cmds[i].name; i++)
1674             {
1675               if ((cmds[i].flags & KEYEDIT_NEED_SK) && !have_seckey)
1676                 ; /* Skip those item if we do not have the secret key.  */
1677               else if (cmds[i].desc)
1678                 tty_printf ("%-11s %s\n", cmds[i].name, _(cmds[i].desc));
1679             }
1680
1681           tty_printf ("\n");
1682           tty_printf
1683             (_("* The 'sign' command may be prefixed with an 'l' for local "
1684                "signatures (lsign),\n"
1685                "  a 't' for trust signatures (tsign), an 'nr' for "
1686                "non-revocable signatures\n"
1687                "  (nrsign), or any combination thereof (ltsign, "
1688                "tnrsign, etc.).\n"));
1689           break;
1690
1691         case cmdLIST:
1692           redisplay = 1;
1693           break;
1694
1695         case cmdFPR:
1696           show_key_and_fingerprint
1697             (keyblock, (*arg_string == '*'
1698                         && (!arg_string[1] || spacep (arg_string + 1))));
1699           break;
1700
1701         case cmdGRIP:
1702           show_key_and_grip (keyblock);
1703           break;
1704
1705         case cmdSELUID:
1706           if (strlen (arg_string) == NAMEHASH_LEN * 2)
1707             redisplay = menu_select_uid_namehash (keyblock, arg_string);
1708           else
1709             {
1710               if (*arg_string == '*'
1711                   && (!arg_string[1] || spacep (arg_string + 1)))
1712                 arg_number = -1;        /* Select all. */
1713               redisplay = menu_select_uid (keyblock, arg_number);
1714             }
1715           break;
1716
1717         case cmdSELKEY:
1718           {
1719             if (*arg_string == '*'
1720                 && (!arg_string[1] || spacep (arg_string + 1)))
1721               arg_number = -1;  /* Select all. */
1722             if (menu_select_key (keyblock, arg_number, p))
1723               redisplay = 1;
1724           }
1725           break;
1726
1727         case cmdCHECK:
1728           check_all_keysigs (keyblock, count_selected_uids (keyblock),
1729                              !strcmp (arg_string, "selfsig"));
1730           break;
1731
1732         case cmdSIGN:
1733           {
1734             int localsig = 0, nonrevokesig = 0, trustsig = 0, interactive = 0;
1735
1736             if (pk->flags.revoked)
1737               {
1738                 tty_printf (_("Key is revoked."));
1739
1740                 if (opt.expert)
1741                   {
1742                     tty_printf ("  ");
1743                     if (!cpr_get_answer_is_yes
1744                         ("keyedit.sign_revoked.okay",
1745                          _("Are you sure you still want to sign it? (y/N) ")))
1746                       break;
1747                   }
1748                 else
1749                   {
1750                     tty_printf (_("  Unable to sign.\n"));
1751                     break;
1752                   }
1753               }
1754
1755             if (count_uids (keyblock) > 1 && !count_selected_uids (keyblock))
1756               {
1757                 int result;
1758                 if (opt.only_sign_text_ids)
1759                   result = cpr_get_answer_is_yes
1760                     ("keyedit.sign_all.okay",
1761                      _("Really sign all user IDs? (y/N) "));
1762                 else
1763                   result = cpr_get_answer_is_yes
1764                     ("keyedit.sign_all.okay",
1765                      _("Really sign all text user IDs? (y/N) "));
1766
1767                 if (! result)
1768                   {
1769                     if (opt.interactive)
1770                       interactive = 1;
1771                     else
1772                       {
1773                         tty_printf (_("Hint: Select the user IDs to sign\n"));
1774                         have_commands = 0;
1775                         break;
1776                       }
1777
1778                   }
1779               }
1780             /* What sort of signing are we doing? */
1781             if (!parse_sign_type
1782                 (answer, &localsig, &nonrevokesig, &trustsig))
1783               {
1784                 tty_printf (_("Unknown signature type '%s'\n"), answer);
1785                 break;
1786               }
1787
1788             sign_uids (ctrl, NULL, keyblock, locusr, &modified,
1789                        localsig, nonrevokesig, trustsig, interactive, 0);
1790           }
1791           break;
1792
1793         case cmdDEBUG:
1794           dump_kbnode (keyblock);
1795           break;
1796
1797         case cmdTOGGLE:
1798           /* The toggle command is a leftover from old gpg versions
1799              where we worked with a secret and a public keyring.  It
1800              is not necessary anymore but we keep this command for the
1801              sake of scripts using it.  */
1802           redisplay = 1;
1803           break;
1804
1805         case cmdADDPHOTO:
1806           if (RFC2440)
1807             {
1808               tty_printf (_("This command is not allowed while in %s mode.\n"),
1809                           compliance_option_string ());
1810               break;
1811             }
1812           photo = 1;
1813           /* fall through */
1814         case cmdADDUID:
1815           if (menu_adduid (keyblock, photo, arg_string, NULL))
1816             {
1817               update_trust = 1;
1818               redisplay = 1;
1819               modified = 1;
1820               merge_keys_and_selfsig (keyblock);
1821             }
1822           break;
1823
1824         case cmdDELUID:
1825           {
1826             int n1;
1827
1828             if (!(n1 = count_selected_uids (keyblock)))
1829               {
1830                 tty_printf (_("You must select at least one user ID.\n"));
1831                 if (!opt.expert)
1832                   tty_printf (_("(Use the '%s' command.)\n"), "uid");
1833               }
1834             else if (real_uids_left (keyblock) < 1)
1835               tty_printf (_("You can't delete the last user ID!\n"));
1836             else if (cpr_get_answer_is_yes
1837                      ("keyedit.remove.uid.okay",
1838                       n1 > 1 ? _("Really remove all selected user IDs? (y/N) ")
1839                       :        _("Really remove this user ID? (y/N) ")))
1840               {
1841                 menu_deluid (keyblock);
1842                 redisplay = 1;
1843                 modified = 1;
1844               }
1845           }
1846           break;
1847
1848         case cmdDELSIG:
1849           {
1850             int n1;
1851
1852             if (!(n1 = count_selected_uids (keyblock)))
1853               {
1854                 tty_printf (_("You must select at least one user ID.\n"));
1855                 if (!opt.expert)
1856                   tty_printf (_("(Use the '%s' command.)\n"), "uid");
1857               }
1858             else if (menu_delsig (keyblock))
1859               {
1860                 /* No redisplay here, because it may scroll away some
1861                  * of the status output of this command.  */
1862                 modified = 1;
1863               }
1864           }
1865           break;
1866
1867         case cmdADDKEY:
1868           if (!generate_subkeypair (ctrl, keyblock))
1869             {
1870               redisplay = 1;
1871               modified = 1;
1872               merge_keys_and_selfsig (keyblock);
1873             }
1874           break;
1875
1876 #ifdef ENABLE_CARD_SUPPORT
1877         case cmdADDCARDKEY:
1878           if (!card_generate_subkey (keyblock))
1879             {
1880               redisplay = 1;
1881               modified = 1;
1882               merge_keys_and_selfsig (keyblock);
1883             }
1884           break;
1885
1886         case cmdKEYTOCARD:
1887           {
1888             KBNODE node = NULL;
1889             switch (count_selected_keys (keyblock))
1890               {
1891               case 0:
1892                 if (cpr_get_answer_is_yes
1893                     ("keyedit.keytocard.use_primary",
1894                      /* TRANSLATORS: Please take care: This is about
1895                         moving the key and not about removing it.  */
1896                      _("Really move the primary key? (y/N) ")))
1897                   node = keyblock;
1898                 break;
1899               case 1:
1900                 for (node = keyblock; node; node = node->next)
1901                   {
1902                     if (node->pkt->pkttype == PKT_PUBLIC_SUBKEY
1903                         && node->flag & NODFLG_SELKEY)
1904                       break;
1905                   }
1906                 break;
1907               default:
1908                 tty_printf (_("You must select exactly one key.\n"));
1909                 break;
1910               }
1911             if (node)
1912               {
1913                 PKT_public_key *xxpk = node->pkt->pkt.public_key;
1914                 if (card_store_subkey (node, xxpk ? xxpk->pubkey_usage : 0))
1915                   {
1916                     redisplay = 1;
1917                     sec_shadowing = 1;
1918                   }
1919               }
1920           }
1921           break;
1922
1923         case cmdBKUPTOCARD:
1924         case cmdCHECKBKUPKEY:
1925           log_debug ("FIXME: This needs to be changed\n");
1926           {
1927             /* Ask for a filename, check whether this is really a
1928                backup key as generated by the card generation, parse
1929                that key and store it on card. */
1930             KBNODE node;
1931             const char *fname;
1932             PACKET *pkt;
1933             IOBUF a;
1934
1935             fname = arg_string;
1936             if (!*fname)
1937               {
1938                 tty_printf (_("Command expects a filename argument\n"));
1939                 break;
1940               }
1941
1942             /* Open that file.  */
1943             a = iobuf_open (fname);
1944             if (a && is_secured_file (iobuf_get_fd (a)))
1945               {
1946                 iobuf_close (a);
1947                 a = NULL;
1948                 gpg_err_set_errno (EPERM);
1949               }
1950             if (!a)
1951               {
1952                 tty_printf (_("Can't open '%s': %s\n"),
1953                             fname, strerror (errno));
1954                 break;
1955               }
1956
1957             /* Parse and check that file.  */
1958             pkt = xmalloc (sizeof *pkt);
1959             init_packet (pkt);
1960             err = parse_packet (a, pkt);
1961             iobuf_close (a);
1962             iobuf_ioctl (NULL, IOBUF_IOCTL_INVALIDATE_CACHE, 0, (char *) fname);
1963             if (!err && pkt->pkttype != PKT_SECRET_KEY
1964                 && pkt->pkttype != PKT_SECRET_SUBKEY)
1965               err = GPG_ERR_NO_SECKEY;
1966             if (err)
1967               {
1968                 tty_printf (_("Error reading backup key from '%s': %s\n"),
1969                             fname, gpg_strerror (err));
1970                 free_packet (pkt);
1971                 xfree (pkt);
1972                 break;
1973               }
1974             node = new_kbnode (pkt);
1975
1976             if (cmd == cmdCHECKBKUPKEY)
1977               {
1978                 /* PKT_public_key *sk = node->pkt->pkt.secret_key; */
1979                 /* switch (is_secret_key_protected (sk)) */
1980                 /*   { */
1981                 /*   case 0:    /\* Not protected. *\/ */
1982                 /*     tty_printf (_("This key is not protected.\n")); */
1983                 /*     break; */
1984                 /*   case -1: */
1985                 /*     log_error (_("unknown key protection algorithm\n")); */
1986                 /*     break; */
1987                 /*   default: */
1988                 /*     if (sk->protect.s2k.mode == 1001) */
1989                 /*       tty_printf (_("Secret parts of key" */
1990                 /*                  " are not available.\n")); */
1991                 /*     if (sk->protect.s2k.mode == 1002) */
1992                 /*       tty_printf (_("Secret parts of key" */
1993                 /*                  " are stored on-card.\n")); */
1994                     /* else */
1995                     /*   check_secret_key (sk, 0); */
1996                   /* } */
1997               }
1998             else                /* Store it.  */
1999               {
2000                 if (card_store_subkey (node, 0))
2001                   {
2002                     redisplay = 1;
2003                     sec_shadowing = 1;
2004                   }
2005               }
2006             release_kbnode (node);
2007           }
2008           break;
2009
2010 #endif /* ENABLE_CARD_SUPPORT */
2011
2012         case cmdDELKEY:
2013           {
2014             int n1;
2015
2016             if (!(n1 = count_selected_keys (keyblock)))
2017               {
2018                 tty_printf (_("You must select at least one key.\n"));
2019                 if (!opt.expert)
2020                   tty_printf (_("(Use the '%s' command.)\n"), "key");
2021               }
2022             else if (!cpr_get_answer_is_yes
2023                      ("keyedit.remove.subkey.okay",
2024                       n1 > 1 ? _("Do you really want to delete the "
2025                                  "selected keys? (y/N) ")
2026                       :  _("Do you really want to delete this key? (y/N) ")))
2027               ;
2028             else
2029               {
2030                 menu_delkey (keyblock);
2031                 redisplay = 1;
2032                 modified = 1;
2033               }
2034           }
2035           break;
2036
2037         case cmdADDREVOKER:
2038           {
2039             int sensitive = 0;
2040
2041             if (ascii_strcasecmp (arg_string, "sensitive") == 0)
2042               sensitive = 1;
2043             if (menu_addrevoker (ctrl, keyblock, sensitive))
2044               {
2045                 redisplay = 1;
2046                 modified = 1;
2047                 merge_keys_and_selfsig (keyblock);
2048               }
2049           }
2050           break;
2051
2052         case cmdREVUID:
2053           {
2054             int n1;
2055
2056             if (!(n1 = count_selected_uids (keyblock)))
2057               {
2058                 tty_printf (_("You must select at least one user ID.\n"));
2059                 if (!opt.expert)
2060                   tty_printf (_("(Use the '%s' command.)\n"), "uid");
2061               }
2062             else if (cpr_get_answer_is_yes
2063                      ("keyedit.revoke.uid.okay",
2064                       n1 > 1 ? _("Really revoke all selected user IDs? (y/N) ")
2065                       :        _("Really revoke this user ID? (y/N) ")))
2066               {
2067                 if (menu_revuid (keyblock))
2068                   {
2069                     modified = 1;
2070                     redisplay = 1;
2071                   }
2072               }
2073           }
2074           break;
2075
2076         case cmdREVKEY:
2077           {
2078             int n1;
2079
2080             if (!(n1 = count_selected_keys (keyblock)))
2081               {
2082                 if (cpr_get_answer_is_yes ("keyedit.revoke.subkey.okay",
2083                                            _("Do you really want to revoke"
2084                                              " the entire key? (y/N) ")))
2085                   {
2086                     if (menu_revkey (keyblock))
2087                       modified = 1;
2088
2089                     redisplay = 1;
2090                   }
2091               }
2092             else if (cpr_get_answer_is_yes ("keyedit.revoke.subkey.okay",
2093                                             n1 > 1 ?
2094                                             _("Do you really want to revoke"
2095                                               " the selected subkeys? (y/N) ")
2096                                             : _("Do you really want to revoke"
2097                                                 " this subkey? (y/N) ")))
2098               {
2099                 if (menu_revsubkey (keyblock))
2100                   modified = 1;
2101
2102                 redisplay = 1;
2103               }
2104
2105             if (modified)
2106               merge_keys_and_selfsig (keyblock);
2107           }
2108           break;
2109
2110         case cmdEXPIRE:
2111           if (menu_expire (keyblock))
2112             {
2113               merge_keys_and_selfsig (keyblock);
2114               run_subkey_warnings = 1;
2115               modified = 1;
2116               redisplay = 1;
2117             }
2118           break;
2119
2120         case cmdBACKSIGN:
2121           if (menu_backsign (keyblock))
2122             {
2123               modified = 1;
2124               redisplay = 1;
2125             }
2126           break;
2127
2128         case cmdPRIMARY:
2129           if (menu_set_primary_uid (keyblock))
2130             {
2131               merge_keys_and_selfsig (keyblock);
2132               modified = 1;
2133               redisplay = 1;
2134             }
2135           break;
2136
2137         case cmdPASSWD:
2138           change_passphrase (ctrl, keyblock);
2139           break;
2140
2141 #ifndef NO_TRUST_MODELS
2142         case cmdTRUST:
2143           if (opt.trust_model == TM_EXTERNAL)
2144             {
2145               tty_printf (_("Owner trust may not be set while "
2146                             "using a user provided trust database\n"));
2147               break;
2148             }
2149
2150           show_key_with_all_names (ctrl, NULL, keyblock, 0, 0, 0, 1, 0, 0);
2151           tty_printf ("\n");
2152           if (edit_ownertrust (find_kbnode (keyblock,
2153                                             PKT_PUBLIC_KEY)->pkt->pkt.
2154                                public_key, 1))
2155             {
2156               redisplay = 1;
2157               /* No real need to set update_trust here as
2158                  edit_ownertrust() calls revalidation_mark()
2159                  anyway. */
2160               update_trust = 1;
2161             }
2162           break;
2163 #endif /*!NO_TRUST_MODELS*/
2164
2165         case cmdPREF:
2166           {
2167             int count = count_selected_uids (keyblock);
2168             assert (keyblock->pkt->pkttype == PKT_PUBLIC_KEY);
2169             show_names (NULL, keyblock, keyblock->pkt->pkt.public_key,
2170                         count ? NODFLG_SELUID : 0, 1);
2171           }
2172           break;
2173
2174         case cmdSHOWPREF:
2175           {
2176             int count = count_selected_uids (keyblock);
2177             assert (keyblock->pkt->pkttype == PKT_PUBLIC_KEY);
2178             show_names (NULL, keyblock, keyblock->pkt->pkt.public_key,
2179                         count ? NODFLG_SELUID : 0, 2);
2180           }
2181           break;
2182
2183         case cmdSETPREF:
2184           {
2185             PKT_user_id *tempuid;
2186
2187             keygen_set_std_prefs (!*arg_string ? "default" : arg_string, 0);
2188
2189             tempuid = keygen_get_std_prefs ();
2190             tty_printf (_("Set preference list to:\n"));
2191             show_prefs (tempuid, NULL, 1);
2192             free_user_id (tempuid);
2193
2194             if (cpr_get_answer_is_yes
2195                 ("keyedit.setpref.okay",
2196                  count_selected_uids (keyblock) ?
2197                  _("Really update the preferences"
2198                    " for the selected user IDs? (y/N) ")
2199                  : _("Really update the preferences? (y/N) ")))
2200               {
2201                 if (menu_set_preferences (keyblock))
2202                   {
2203                     merge_keys_and_selfsig (keyblock);
2204                     modified = 1;
2205                     redisplay = 1;
2206                   }
2207               }
2208           }
2209           break;
2210
2211         case cmdPREFKS:
2212           if (menu_set_keyserver_url (*arg_string ? arg_string : NULL,
2213                                       keyblock))
2214             {
2215               merge_keys_and_selfsig (keyblock);
2216               modified = 1;
2217               redisplay = 1;
2218             }
2219           break;
2220
2221         case cmdNOTATION:
2222           if (menu_set_notation (*arg_string ? arg_string : NULL,
2223                                  keyblock))
2224             {
2225               merge_keys_and_selfsig (keyblock);
2226               modified = 1;
2227               redisplay = 1;
2228             }
2229           break;
2230
2231         case cmdNOP:
2232           break;
2233
2234         case cmdREVSIG:
2235           if (menu_revsig (keyblock))
2236             {
2237               redisplay = 1;
2238               modified = 1;
2239             }
2240           break;
2241
2242 #ifndef NO_TRUST_MODELS
2243         case cmdENABLEKEY:
2244         case cmdDISABLEKEY:
2245           if (enable_disable_key (keyblock, cmd == cmdDISABLEKEY))
2246             {
2247               redisplay = 1;
2248               modified = 1;
2249             }
2250           break;
2251 #endif /*!NO_TRUST_MODELS*/
2252
2253         case cmdSHOWPHOTO:
2254           menu_showphoto (keyblock);
2255           break;
2256
2257         case cmdCLEAN:
2258           if (menu_clean (keyblock, 0))
2259             redisplay = modified = 1;
2260           break;
2261
2262         case cmdMINIMIZE:
2263           if (menu_clean (keyblock, 1))
2264             redisplay = modified = 1;
2265           break;
2266
2267         case cmdQUIT:
2268           if (have_commands)
2269             goto leave;
2270           if (!modified && !sec_shadowing)
2271             goto leave;
2272           if (!cpr_get_answer_is_yes ("keyedit.save.okay",
2273                                       _("Save changes? (y/N) ")))
2274             {
2275               if (cpr_enabled ()
2276                   || cpr_get_answer_is_yes ("keyedit.cancel.okay",
2277                                             _("Quit without saving? (y/N) ")))
2278                 goto leave;
2279               break;
2280             }
2281           /* fall thru */
2282         case cmdSAVE:
2283           if (modified)
2284             {
2285               err = keydb_update_keyblock (kdbhd, keyblock);
2286               if (err)
2287                 {
2288                   log_error (_("update failed: %s\n"), gpg_strerror (err));
2289                   break;
2290                 }
2291             }
2292
2293           if (sec_shadowing)
2294             {
2295               err = agent_scd_learn (NULL, 1);
2296               if (err)
2297                 {
2298                   log_error (_("update failed: %s\n"), gpg_strerror (err));
2299                   break;
2300                 }
2301             }
2302
2303           if (!modified && !sec_shadowing)
2304             tty_printf (_("Key not changed so no update needed.\n"));
2305
2306           if (update_trust)
2307             {
2308               revalidation_mark ();
2309               update_trust = 0;
2310             }
2311           goto leave;
2312
2313         case cmdINVCMD:
2314         default:
2315           tty_printf ("\n");
2316           tty_printf (_("Invalid command  (try \"help\")\n"));
2317           break;
2318         }
2319     } /* End of the main command loop.  */
2320
2321  leave:
2322   release_kbnode (keyblock);
2323   keydb_release (kdbhd);
2324   xfree (answer);
2325 }
2326
2327
2328 /* Change the passphrase of the secret key identified by USERNAME.  */
2329 void
2330 keyedit_passwd (ctrl_t ctrl, const char *username)
2331 {
2332   gpg_error_t err;
2333   PKT_public_key *pk;
2334   kbnode_t keyblock = NULL;
2335
2336   pk = xtrycalloc (1, sizeof *pk);
2337   if (!pk)
2338     {
2339       err = gpg_error_from_syserror ();
2340       goto leave;
2341     }
2342   err = getkey_byname (ctrl, NULL, pk, username, 1, &keyblock);
2343   if (err)
2344     goto leave;
2345
2346   err = change_passphrase (ctrl, keyblock);
2347
2348 leave:
2349   release_kbnode (keyblock);
2350   free_public_key (pk);
2351   if (err)
2352     {
2353       log_info ("error changing the passphrase for '%s': %s\n",
2354                 username, gpg_strerror (err));
2355       write_status_error ("keyedit.passwd", err);
2356     }
2357   else
2358     write_status_text (STATUS_SUCCESS, "keyedit.passwd");
2359 }
2360
2361
2362 /* Unattended adding of a new keyid.  USERNAME specifies the
2363    key. NEWUID is the new user id to add to the key.  */
2364 void
2365 keyedit_quick_adduid (ctrl_t ctrl, const char *username, const char *newuid)
2366 {
2367   gpg_error_t err;
2368   KEYDB_HANDLE kdbhd = NULL;
2369   KEYDB_SEARCH_DESC desc;
2370   kbnode_t keyblock = NULL;
2371   kbnode_t node;
2372   char *uidstring = NULL;
2373
2374   uidstring = xstrdup (newuid);
2375   trim_spaces (uidstring);
2376   if (!*uidstring)
2377     {
2378       log_error ("%s\n", gpg_strerror (GPG_ERR_INV_USER_ID));
2379       goto leave;
2380     }
2381
2382 #ifdef HAVE_W32_SYSTEM
2383   /* See keyedit_menu for why we need this.  */
2384   check_trustdb_stale ();
2385 #endif
2386
2387   /* Search the key; we don't want the whole getkey stuff here.  */
2388   kdbhd = keydb_new ();
2389   err = classify_user_id (username, &desc, 1);
2390   if (!err)
2391     err = keydb_search (kdbhd, &desc, 1, NULL);
2392   if (!err)
2393     {
2394       err = keydb_get_keyblock (kdbhd, &keyblock);
2395       if (err)
2396         {
2397           log_error (_("error reading keyblock: %s\n"), gpg_strerror (err));
2398           goto leave;
2399         }
2400       /* Now with the keyblock retrieved, search again to detect an
2401          ambiguous specification.  We need to save the found state so
2402          that we can do an update later.  */
2403       keydb_push_found_state (kdbhd);
2404       err = keydb_search (kdbhd, &desc, 1, NULL);
2405       if (!err)
2406         err = gpg_error (GPG_ERR_AMBIGUOUS_NAME);
2407       else if (gpg_err_code (err) == GPG_ERR_NOT_FOUND)
2408         err = 0;
2409       keydb_pop_found_state (kdbhd);
2410
2411       if (!err)
2412         {
2413           /* We require the secret primary key to add a UID.  */
2414           node = find_kbnode (keyblock, PKT_PUBLIC_KEY);
2415           if (!node)
2416             BUG ();
2417           err = agent_probe_secret_key (ctrl, node->pkt->pkt.public_key);
2418         }
2419     }
2420   if (err)
2421     {
2422       log_error (_("secret key \"%s\" not found: %s\n"),
2423                  username, gpg_strerror (err));
2424       goto leave;
2425     }
2426
2427   fix_keyblock (&keyblock);
2428
2429   if (menu_adduid (keyblock, 0, NULL, uidstring))
2430     {
2431       err = keydb_update_keyblock (kdbhd, keyblock);
2432       if (err)
2433         {
2434           log_error (_("update failed: %s\n"), gpg_strerror (err));
2435           goto leave;
2436         }
2437
2438       if (update_trust)
2439         revalidation_mark ();
2440     }
2441
2442  leave:
2443   xfree (uidstring);
2444   release_kbnode (keyblock);
2445   keydb_release (kdbhd);
2446 }
2447
2448
2449 /* Unattended key signing function.  If the key specifified by FPR is
2450    availabale and FPR is the primary fingerprint all user ids of the
2451    user ids of the key are signed using the default signing key.  If
2452    UIDS is an empty list all usable UIDs are signed, if it is not
2453    empty, only those user ids matching one of the entries of the loist
2454    are signed.  With LOCAL being true kthe signatures are marked as
2455    non-exportable.  */
2456 void
2457 keyedit_quick_sign (ctrl_t ctrl, const char *fpr, strlist_t uids,
2458                     strlist_t locusr, int local)
2459 {
2460   gpg_error_t err;
2461   kbnode_t keyblock = NULL;
2462   KEYDB_HANDLE kdbhd = NULL;
2463   int modified = 0;
2464   KEYDB_SEARCH_DESC desc;
2465   PKT_public_key *pk;
2466   kbnode_t node;
2467   strlist_t sl;
2468   int any;
2469
2470 #ifdef HAVE_W32_SYSTEM
2471   /* See keyedit_menu for why we need this.  */
2472   check_trustdb_stale ();
2473 #endif
2474
2475   /* We require a fingerprint because only this uniquely identifies a
2476      key and may thus be used to select a key for unattended key
2477      signing.  */
2478   if (classify_user_id (fpr, &desc, 1)
2479       || !(desc.mode == KEYDB_SEARCH_MODE_FPR
2480            || desc.mode == KEYDB_SEARCH_MODE_FPR16
2481            || desc.mode == KEYDB_SEARCH_MODE_FPR20))
2482     {
2483       log_error (_("\"%s\" is not a fingerprint\n"), fpr);
2484       goto leave;
2485     }
2486   err = get_pubkey_byname (ctrl, NULL, NULL, fpr, &keyblock, &kdbhd, 1, 1);
2487   if (err)
2488     {
2489       log_error (_("key \"%s\" not found: %s\n"), fpr, gpg_strerror (err));
2490       goto leave;
2491     }
2492
2493   /* Check that the primary fingerprint has been given. */
2494   {
2495     byte fprbin[MAX_FINGERPRINT_LEN];
2496     size_t fprlen;
2497
2498     fingerprint_from_pk (keyblock->pkt->pkt.public_key, fprbin, &fprlen);
2499     if (fprlen == 16 && desc.mode == KEYDB_SEARCH_MODE_FPR16
2500         && !memcmp (fprbin, desc.u.fpr, 16))
2501       ;
2502     else if (fprlen == 16 && desc.mode == KEYDB_SEARCH_MODE_FPR
2503              && !memcmp (fprbin, desc.u.fpr, 16)
2504              && !desc.u.fpr[16]
2505              && !desc.u.fpr[17]
2506              && !desc.u.fpr[18]
2507              && !desc.u.fpr[19])
2508       ;
2509     else if (fprlen == 20 && (desc.mode == KEYDB_SEARCH_MODE_FPR20
2510                               || desc.mode == KEYDB_SEARCH_MODE_FPR)
2511              && !memcmp (fprbin, desc.u.fpr, 20))
2512       ;
2513     else
2514       {
2515         log_error (_("\"%s\" is not the primary fingerprint\n"), fpr);
2516         goto leave;
2517       }
2518   }
2519
2520   if (fix_keyblock (&keyblock))
2521     modified++;
2522
2523   /* Give some info in verbose.  */
2524   if (opt.verbose)
2525     {
2526       show_key_with_all_names (ctrl, es_stdout, keyblock, 0,
2527                                1/*with_revoker*/, 1/*with_fingerprint*/,
2528                                0, 0, 1);
2529       es_fflush (es_stdout);
2530     }
2531
2532   pk = keyblock->pkt->pkt.public_key;
2533   if (pk->flags.revoked)
2534     {
2535       if (!opt.verbose)
2536         show_key_with_all_names (ctrl, es_stdout, keyblock, 0, 0, 0, 0, 0, 1);
2537       log_error ("%s%s", _("Key is revoked."), _("  Unable to sign.\n"));
2538       goto leave;
2539     }
2540
2541   /* Set the flags according to the UIDS list.  Fixme: We may want to
2542      use classify_user_id along with dedicated compare functions so
2543      that we match the same way as in the key lookup. */
2544   any = 0;
2545   menu_select_uid (keyblock, 0);   /* Better clear the flags first. */
2546   for (sl=uids; sl; sl = sl->next)
2547     {
2548       for (node = keyblock; node; node = node->next)
2549         {
2550           if (node->pkt->pkttype == PKT_USER_ID)
2551             {
2552               PKT_user_id *uid = node->pkt->pkt.user_id;
2553
2554               if (!uid->attrib_data
2555                   && ascii_memistr (uid->name, uid->len, sl->d))
2556                 {
2557                   node->flag |= NODFLG_SELUID;
2558                   any = 1;
2559                 }
2560             }
2561         }
2562     }
2563
2564   if (uids && !any)
2565     {
2566       if (!opt.verbose)
2567         show_key_with_all_names (ctrl, es_stdout, keyblock, 0, 0, 0, 0, 0, 1);
2568       es_fflush (es_stdout);
2569       log_error ("%s  %s", _("No matching user IDs."), _("Nothing to sign.\n"));
2570       goto leave;
2571     }
2572
2573   /* Sign. */
2574   sign_uids (ctrl, es_stdout, keyblock, locusr, &modified, local, 0, 0, 0, 1);
2575   es_fflush (es_stdout);
2576
2577   if (modified)
2578     {
2579       err = keydb_update_keyblock (kdbhd, keyblock);
2580       if (err)
2581         {
2582           log_error (_("update failed: %s\n"), gpg_strerror (err));
2583           goto leave;
2584         }
2585     }
2586   else
2587     log_info (_("Key not changed so no update needed.\n"));
2588
2589   if (update_trust)
2590     revalidation_mark ();
2591
2592
2593  leave:
2594   release_kbnode (keyblock);
2595   keydb_release (kdbhd);
2596 }
2597
2598
2599 \f
2600 static void
2601 tty_print_notations (int indent, PKT_signature * sig)
2602 {
2603   int first = 1;
2604   struct notation *notation, *nd;
2605
2606   if (indent < 0)
2607     {
2608       first = 0;
2609       indent = -indent;
2610     }
2611
2612   notation = sig_to_notation (sig);
2613
2614   for (nd = notation; nd; nd = nd->next)
2615     {
2616       if (!first)
2617         tty_printf ("%*s", indent, "");
2618       else
2619         first = 0;
2620
2621       tty_print_utf8_string (nd->name, strlen (nd->name));
2622       tty_printf ("=");
2623       tty_print_utf8_string (nd->value, strlen (nd->value));
2624       tty_printf ("\n");
2625     }
2626
2627   free_notation (notation);
2628 }
2629
2630
2631 /*
2632  * Show preferences of a public keyblock.
2633  */
2634 static void
2635 show_prefs (PKT_user_id * uid, PKT_signature * selfsig, int verbose)
2636 {
2637   const prefitem_t fake = { 0, 0 };
2638   const prefitem_t *prefs;
2639   int i;
2640
2641   if (!uid)
2642     return;
2643
2644   if (uid->prefs)
2645     prefs = uid->prefs;
2646   else if (verbose)
2647     prefs = &fake;
2648   else
2649     return;
2650
2651   if (verbose)
2652     {
2653       int any, des_seen = 0, sha1_seen = 0, uncomp_seen = 0;
2654
2655       tty_printf ("     ");
2656       tty_printf (_("Cipher: "));
2657       for (i = any = 0; prefs[i].type; i++)
2658         {
2659           if (prefs[i].type == PREFTYPE_SYM)
2660             {
2661               if (any)
2662                 tty_printf (", ");
2663               any = 1;
2664               /* We don't want to display strings for experimental algos */
2665               if (!openpgp_cipher_test_algo (prefs[i].value)
2666                   && prefs[i].value < 100)
2667                 tty_printf ("%s", openpgp_cipher_algo_name (prefs[i].value));
2668               else
2669                 tty_printf ("[%d]", prefs[i].value);
2670               if (prefs[i].value == CIPHER_ALGO_3DES)
2671                 des_seen = 1;
2672             }
2673         }
2674       if (!des_seen)
2675         {
2676           if (any)
2677             tty_printf (", ");
2678           tty_printf ("%s", openpgp_cipher_algo_name (CIPHER_ALGO_3DES));
2679         }
2680       tty_printf ("\n     ");
2681       tty_printf (_("Digest: "));
2682       for (i = any = 0; prefs[i].type; i++)
2683         {
2684           if (prefs[i].type == PREFTYPE_HASH)
2685             {
2686               if (any)
2687                 tty_printf (", ");
2688               any = 1;
2689               /* We don't want to display strings for experimental algos */
2690               if (!gcry_md_test_algo (prefs[i].value) && prefs[i].value < 100)
2691                 tty_printf ("%s", gcry_md_algo_name (prefs[i].value));
2692               else
2693                 tty_printf ("[%d]", prefs[i].value);
2694               if (prefs[i].value == DIGEST_ALGO_SHA1)
2695                 sha1_seen = 1;
2696             }
2697         }
2698       if (!sha1_seen)
2699         {
2700           if (any)
2701             tty_printf (", ");
2702           tty_printf ("%s", gcry_md_algo_name (DIGEST_ALGO_SHA1));
2703         }
2704       tty_printf ("\n     ");
2705       tty_printf (_("Compression: "));
2706       for (i = any = 0; prefs[i].type; i++)
2707         {
2708           if (prefs[i].type == PREFTYPE_ZIP)
2709             {
2710               const char *s = compress_algo_to_string (prefs[i].value);
2711
2712               if (any)
2713                 tty_printf (", ");
2714               any = 1;
2715               /* We don't want to display strings for experimental algos */
2716               if (s && prefs[i].value < 100)
2717                 tty_printf ("%s", s);
2718               else
2719                 tty_printf ("[%d]", prefs[i].value);
2720               if (prefs[i].value == COMPRESS_ALGO_NONE)
2721                 uncomp_seen = 1;
2722             }
2723         }
2724       if (!uncomp_seen)
2725         {
2726           if (any)
2727             tty_printf (", ");
2728           else
2729             {
2730               tty_printf ("%s", compress_algo_to_string (COMPRESS_ALGO_ZIP));
2731               tty_printf (", ");
2732             }
2733           tty_printf ("%s", compress_algo_to_string (COMPRESS_ALGO_NONE));
2734         }
2735       if (uid->flags.mdc || !uid->flags.ks_modify)
2736         {
2737           tty_printf ("\n     ");
2738           tty_printf (_("Features: "));
2739           any = 0;
2740           if (uid->flags.mdc)
2741             {
2742               tty_printf ("MDC");
2743               any = 1;
2744             }
2745           if (!uid->flags.ks_modify)
2746             {
2747               if (any)
2748                 tty_printf (", ");
2749               tty_printf (_("Keyserver no-modify"));
2750             }
2751         }
2752       tty_printf ("\n");
2753
2754       if (selfsig)
2755         {
2756           const byte *pref_ks;
2757           size_t pref_ks_len;
2758
2759           pref_ks = parse_sig_subpkt (selfsig->hashed,
2760                                       SIGSUBPKT_PREF_KS, &pref_ks_len);
2761           if (pref_ks && pref_ks_len)
2762             {
2763               tty_printf ("     ");
2764               tty_printf (_("Preferred keyserver: "));
2765               tty_print_utf8_string (pref_ks, pref_ks_len);
2766               tty_printf ("\n");
2767             }
2768
2769           if (selfsig->flags.notation)
2770             {
2771               tty_printf ("     ");
2772               tty_printf (_("Notations: "));
2773               tty_print_notations (5 + strlen (_("Notations: ")), selfsig);
2774             }
2775         }
2776     }
2777   else
2778     {
2779       tty_printf ("    ");
2780       for (i = 0; prefs[i].type; i++)
2781         {
2782           tty_printf (" %c%d", prefs[i].type == PREFTYPE_SYM ? 'S' :
2783                       prefs[i].type == PREFTYPE_HASH ? 'H' :
2784                       prefs[i].type == PREFTYPE_ZIP ? 'Z' : '?',
2785                       prefs[i].value);
2786         }
2787       if (uid->flags.mdc)
2788         tty_printf (" [mdc]");
2789       if (!uid->flags.ks_modify)
2790         tty_printf (" [no-ks-modify]");
2791       tty_printf ("\n");
2792     }
2793 }
2794
2795
2796 /* This is the version of show_key_with_all_names used when
2797    opt.with_colons is used.  It prints all available data in a easy to
2798    parse format and does not translate utf8 */
2799 static void
2800 show_key_with_all_names_colon (ctrl_t ctrl, estream_t fp, kbnode_t keyblock)
2801 {
2802   KBNODE node;
2803   int i, j, ulti_hack = 0;
2804   byte pk_version = 0;
2805   PKT_public_key *primary = NULL;
2806   int have_seckey;
2807
2808   if (!fp)
2809     fp = es_stdout;
2810
2811   /* the keys */
2812   for (node = keyblock; node; node = node->next)
2813     {
2814       if (node->pkt->pkttype == PKT_PUBLIC_KEY
2815           || (node->pkt->pkttype == PKT_PUBLIC_SUBKEY))
2816         {
2817           PKT_public_key *pk = node->pkt->pkt.public_key;
2818           u32 keyid[2];
2819
2820           if (node->pkt->pkttype == PKT_PUBLIC_KEY)
2821             {
2822               pk_version = pk->version;
2823               primary = pk;
2824             }
2825
2826           keyid_from_pk (pk, keyid);
2827           have_seckey = !agent_probe_secret_key (ctrl, pk);
2828
2829           if (node->pkt->pkttype == PKT_PUBLIC_KEY)
2830             es_fputs (have_seckey? "sec:" : "pub:", fp);
2831           else
2832             es_fputs (have_seckey? "ssb:" : "sub:", fp);
2833
2834           if (!pk->flags.valid)
2835             es_putc ('i', fp);
2836           else if (pk->flags.revoked)
2837             es_putc ('r', fp);
2838           else if (pk->has_expired)
2839             es_putc ('e', fp);
2840           else if (!(opt.fast_list_mode || opt.no_expensive_trust_checks))
2841             {
2842               int trust = get_validity_info (pk, NULL);
2843               if (trust == 'u')
2844                 ulti_hack = 1;
2845               es_putc (trust, fp);
2846             }
2847
2848           es_fprintf (fp, ":%u:%d:%08lX%08lX:%lu:%lu::",
2849                       nbits_from_pk (pk),
2850                       pk->pubkey_algo,
2851                       (ulong) keyid[0], (ulong) keyid[1],
2852                       (ulong) pk->timestamp, (ulong) pk->expiredate);
2853           if (node->pkt->pkttype == PKT_PUBLIC_KEY
2854               && !(opt.fast_list_mode || opt.no_expensive_trust_checks))
2855             es_putc (get_ownertrust_info (pk), fp);
2856           es_putc (':', fp);
2857           es_putc (':', fp);
2858           es_putc (':', fp);
2859           /* Print capabilities.  */
2860           if ((pk->pubkey_usage & PUBKEY_USAGE_ENC))
2861             es_putc ('e', fp);
2862           if ((pk->pubkey_usage & PUBKEY_USAGE_SIG))
2863             es_putc ('s', fp);
2864           if ((pk->pubkey_usage & PUBKEY_USAGE_CERT))
2865             es_putc ('c', fp);
2866           if ((pk->pubkey_usage & PUBKEY_USAGE_AUTH))
2867             es_putc ('a', fp);
2868           es_putc ('\n', fp);
2869
2870           print_fingerprint (fp, pk, 0);
2871           print_revokers (fp, pk);
2872         }
2873     }
2874
2875   /* the user ids */
2876   i = 0;
2877   for (node = keyblock; node; node = node->next)
2878     {
2879       if (node->pkt->pkttype == PKT_USER_ID)
2880         {
2881           PKT_user_id *uid = node->pkt->pkt.user_id;
2882
2883           ++i;
2884
2885           if (uid->attrib_data)
2886             es_fputs ("uat:", fp);
2887           else
2888             es_fputs ("uid:", fp);
2889
2890           if (uid->is_revoked)
2891             es_fputs ("r::::::::", fp);
2892           else if (uid->is_expired)
2893             es_fputs ("e::::::::", fp);
2894           else if (opt.fast_list_mode || opt.no_expensive_trust_checks)
2895             es_fputs ("::::::::", fp);
2896           else
2897             {
2898               int uid_validity;
2899
2900               if (primary && !ulti_hack)
2901                 uid_validity = get_validity_info (primary, uid);
2902               else
2903                 uid_validity = 'u';
2904               es_fprintf (fp, "%c::::::::", uid_validity);
2905             }
2906
2907           if (uid->attrib_data)
2908             es_fprintf (fp, "%u %lu", uid->numattribs, uid->attrib_len);
2909           else
2910             es_write_sanitized (fp, uid->name, uid->len, ":", NULL);
2911
2912           es_putc (':', fp);
2913           /* signature class */
2914           es_putc (':', fp);
2915           /* capabilities */
2916           es_putc (':', fp);
2917           /* preferences */
2918           if (pk_version > 3 || uid->selfsigversion > 3)
2919             {
2920               const prefitem_t *prefs = uid->prefs;
2921
2922               for (j = 0; prefs && prefs[j].type; j++)
2923                 {
2924                   if (j)
2925                     es_putc (' ', fp);
2926                   es_fprintf (fp,
2927                               "%c%d", prefs[j].type == PREFTYPE_SYM ? 'S' :
2928                               prefs[j].type == PREFTYPE_HASH ? 'H' :
2929                               prefs[j].type == PREFTYPE_ZIP ? 'Z' : '?',
2930                               prefs[j].value);
2931                 }
2932               if (uid->flags.mdc)
2933                 es_fputs (",mdc", fp);
2934               if (!uid->flags.ks_modify)
2935                 es_fputs (",no-ks-modify", fp);
2936             }
2937           es_putc (':', fp);
2938           /* flags */
2939           es_fprintf (fp, "%d,", i);
2940           if (uid->is_primary)
2941             es_putc ('p', fp);
2942           if (uid->is_revoked)
2943             es_putc ('r', fp);
2944           if (uid->is_expired)
2945             es_putc ('e', fp);
2946           if ((node->flag & NODFLG_SELUID))
2947             es_putc ('s', fp);
2948           if ((node->flag & NODFLG_MARK_A))
2949             es_putc ('m', fp);
2950           es_putc (':', fp);
2951           if (opt.trust_model == TM_TOFU || opt.trust_model == TM_TOFU_PGP)
2952             {
2953 #ifdef USE_TOFU
2954               enum tofu_policy policy;
2955               if (! tofu_get_policy (primary, uid, &policy)
2956                   && policy != TOFU_POLICY_NONE)
2957                 es_fprintf (fp, "%s", tofu_policy_str (policy));
2958 #endif /*USE_TOFU*/
2959             }
2960           es_putc (':', fp);
2961           es_putc ('\n', fp);
2962         }
2963     }
2964 }
2965
2966
2967 static void
2968 show_names (estream_t fp,
2969             KBNODE keyblock, PKT_public_key * pk, unsigned int flag,
2970             int with_prefs)
2971 {
2972   KBNODE node;
2973   int i = 0;
2974
2975   for (node = keyblock; node; node = node->next)
2976     {
2977       if (node->pkt->pkttype == PKT_USER_ID && !is_deleted_kbnode (node))
2978         {
2979           PKT_user_id *uid = node->pkt->pkt.user_id;
2980           ++i;
2981           if (!flag || (flag && (node->flag & flag)))
2982             {
2983               if (!(flag & NODFLG_MARK_A) && pk)
2984                 tty_fprintf (fp, "%s ", uid_trust_string_fixed (pk, uid));
2985
2986               if (flag & NODFLG_MARK_A)
2987                 tty_fprintf (fp, "     ");
2988               else if (node->flag & NODFLG_SELUID)
2989                 tty_fprintf (fp, "(%d)* ", i);
2990               else if (uid->is_primary)
2991                 tty_fprintf (fp, "(%d). ", i);
2992               else
2993                 tty_fprintf (fp, "(%d)  ", i);
2994               tty_print_utf8_string2 (fp, uid->name, uid->len, 0);
2995               tty_fprintf (fp, "\n");
2996               if (with_prefs && pk)
2997                 {
2998                   if (pk->version > 3 || uid->selfsigversion > 3)
2999                     {
3000                       PKT_signature *selfsig = NULL;
3001                       KBNODE signode;
3002
3003                       for (signode = node->next;
3004                            signode && signode->pkt->pkttype == PKT_SIGNATURE;
3005                            signode = signode->next)
3006                         {
3007                           if (signode->pkt->pkt.signature->
3008                               flags.chosen_selfsig)
3009                             {
3010                               selfsig = signode->pkt->pkt.signature;
3011                               break;
3012                             }
3013                         }
3014
3015                       show_prefs (uid, selfsig, with_prefs == 2);
3016                     }
3017                   else
3018                     tty_fprintf (fp, _("There are no preferences on a"
3019                                        " PGP 2.x-style user ID.\n"));
3020                 }
3021             }
3022         }
3023     }
3024 }
3025
3026
3027 /*
3028  * Display the key a the user ids, if only_marked is true, do only so
3029  * for user ids with mark A flag set and do not display the index
3030  * number.  If FP is not NULL print to the given stream and not to the
3031  * tty (ignored in with-colons mode).
3032  */
3033 static void
3034 show_key_with_all_names (ctrl_t ctrl, estream_t fp,
3035                          KBNODE keyblock, int only_marked, int with_revoker,
3036                          int with_fpr, int with_subkeys, int with_prefs,
3037                          int nowarn)
3038 {
3039   gpg_error_t err;
3040   kbnode_t node;
3041   int i;
3042   int do_warn = 0;
3043   int have_seckey = 0;
3044   char *serialno = NULL;
3045   PKT_public_key *primary = NULL;
3046   char pkstrbuf[PUBKEY_STRING_SIZE];
3047
3048   if (opt.with_colons)
3049     {
3050       show_key_with_all_names_colon (ctrl, fp, keyblock);
3051       return;
3052     }
3053
3054   /* the keys */
3055   for (node = keyblock; node; node = node->next)
3056     {
3057       if (node->pkt->pkttype == PKT_PUBLIC_KEY
3058           || (with_subkeys && node->pkt->pkttype == PKT_PUBLIC_SUBKEY
3059               && !is_deleted_kbnode (node)))
3060         {
3061           PKT_public_key *pk = node->pkt->pkt.public_key;
3062           const char *otrust = "err";
3063           const char *trust = "err";
3064
3065           if (node->pkt->pkttype == PKT_PUBLIC_KEY)
3066             {
3067               /* do it here, so that debug messages don't clutter the
3068                * output */
3069               static int did_warn = 0;
3070
3071               trust = get_validity_string (pk, NULL);
3072               otrust = get_ownertrust_string (pk);
3073
3074               /* Show a warning once */
3075               if (!did_warn
3076                   && (get_validity (pk, NULL, NULL, 0)
3077                       & TRUST_FLAG_PENDING_CHECK))
3078                 {
3079                   did_warn = 1;
3080                   do_warn = 1;
3081                 }
3082
3083               primary = pk;
3084             }
3085
3086           if (pk->flags.revoked)
3087             {
3088               char *user = get_user_id_string_native (pk->revoked.keyid);
3089               tty_fprintf (fp,
3090                            _("The following key was revoked on"
3091                             " %s by %s key %s\n"),
3092                           revokestr_from_pk (pk),
3093                           gcry_pk_algo_name (pk->revoked.algo), user);
3094               xfree (user);
3095             }
3096
3097           if (with_revoker)
3098             {
3099               if (!pk->revkey && pk->numrevkeys)
3100                 BUG ();
3101               else
3102                 for (i = 0; i < pk->numrevkeys; i++)
3103                   {
3104                     u32 r_keyid[2];
3105                     char *user;
3106                     const char *algo;
3107
3108                     algo = gcry_pk_algo_name (pk->revkey[i].algid);
3109                     keyid_from_fingerprint (pk->revkey[i].fpr,
3110                                             MAX_FINGERPRINT_LEN, r_keyid);
3111
3112                     user = get_user_id_string_native (r_keyid);
3113                     tty_fprintf (fp,
3114                                  _("This key may be revoked by %s key %s"),
3115                                  algo ? algo : "?", user);
3116
3117                     if (pk->revkey[i].class & 0x40)
3118                       {
3119                         tty_fprintf (fp, " ");
3120                         tty_fprintf (fp, _("(sensitive)"));
3121                       }
3122
3123                     tty_fprintf (fp, "\n");
3124                     xfree (user);
3125                   }
3126             }
3127
3128           keyid_from_pk (pk, NULL);
3129
3130           xfree (serialno);
3131           serialno = NULL;
3132           {
3133             char *hexgrip;
3134
3135             err = hexkeygrip_from_pk (pk, &hexgrip);
3136             if (err)
3137               {
3138                 log_error ("error computing a keygrip: %s\n",
3139                            gpg_strerror (err));
3140                 have_seckey = 0;
3141               }
3142             else
3143               have_seckey = !agent_get_keyinfo (ctrl, hexgrip, &serialno);
3144             xfree (hexgrip);
3145           }
3146
3147           tty_fprintf
3148             (fp, "%s%c %s/%s",
3149              node->pkt->pkttype == PKT_PUBLIC_KEY && have_seckey? "sec" :
3150              node->pkt->pkttype == PKT_PUBLIC_KEY ?               "pub" :
3151              have_seckey ?                                        "ssb" :
3152                                                                   "sub",
3153              (node->flag & NODFLG_SELKEY) ? '*' : ' ',
3154              pubkey_string (pk, pkstrbuf, sizeof pkstrbuf),
3155              keystr (pk->keyid));
3156
3157           if (opt.legacy_list_mode)
3158             tty_fprintf (fp, "  ");
3159           else
3160             tty_fprintf (fp, "\n     ");
3161
3162           tty_fprintf (fp, _("created: %s"), datestr_from_pk (pk));
3163           tty_fprintf (fp, "  ");
3164           if (pk->flags.revoked)
3165             tty_fprintf (fp, _("revoked: %s"), revokestr_from_pk (pk));
3166           else if (pk->has_expired)
3167             tty_fprintf (fp, _("expired: %s"), expirestr_from_pk (pk));
3168           else
3169             tty_fprintf (fp, _("expires: %s"), expirestr_from_pk (pk));
3170           tty_fprintf (fp, "  ");
3171           tty_fprintf (fp, _("usage: %s"), usagestr_from_pk (pk, 1));
3172           tty_fprintf (fp, "\n");
3173
3174           if (serialno)
3175             {
3176               /* The agent told us that a secret key is available and
3177                  that it has been stored on a card.  */
3178               tty_fprintf (fp, "%*s%s", opt.legacy_list_mode? 21:5, "",
3179                            _("card-no: "));
3180               if (strlen (serialno) == 32
3181                   && !strncmp (serialno, "D27600012401", 12))
3182                 {
3183                   /* This is an OpenPGP card.  Print the relevant part.  */
3184                   /* Example: D2760001240101010001000003470000 */
3185                   /*                          xxxxyyyyyyyy     */
3186                   tty_fprintf (fp, "%.*s %.*s\n",
3187                                4, serialno+16, 8, serialno+20);
3188                 }
3189               else
3190                 tty_fprintf (fp, "%s\n", serialno);
3191
3192             }
3193           else if (pk->seckey_info
3194               && pk->seckey_info->is_protected
3195               && pk->seckey_info->s2k.mode == 1002)
3196             {
3197               /* FIXME: Check wether this code path is still used.  */
3198               tty_fprintf (fp, "%*s%s", opt.legacy_list_mode? 21:5, "",
3199                            _("card-no: "));
3200               if (pk->seckey_info->ivlen == 16
3201                   && !memcmp (pk->seckey_info->iv,
3202                               "\xD2\x76\x00\x01\x24\x01", 6))
3203                 {
3204                   /* This is an OpenPGP card. */
3205                   for (i = 8; i < 14; i++)
3206                     {
3207                       if (i == 10)
3208                         tty_fprintf (fp, " ");
3209                       tty_fprintf (fp, "%02X", pk->seckey_info->iv[i]);
3210                     }
3211                 }
3212               else
3213                 {
3214                   /* Unknown card: Print all. */
3215                   for (i = 0; i < pk->seckey_info->ivlen; i++)
3216                     tty_fprintf (fp, "%02X", pk->seckey_info->iv[i]);
3217                 }
3218               tty_fprintf (fp, "\n");
3219             }
3220
3221           if (node->pkt->pkttype == PKT_PUBLIC_KEY
3222               || node->pkt->pkttype == PKT_SECRET_KEY)
3223             {
3224               if (opt.trust_model != TM_ALWAYS)
3225                 {
3226                   tty_fprintf (fp, "%*s",
3227                                opt.legacy_list_mode?
3228                                ((int) keystrlen () + 13):5, "");
3229                   /* Ownertrust is only meaningful for the PGP or
3230                      classic trust models */
3231                   if (opt.trust_model == TM_PGP
3232                       || opt.trust_model == TM_CLASSIC)
3233                     {
3234                       int width = 14 - strlen (otrust);
3235                       if (width <= 0)
3236                         width = 1;
3237                       tty_fprintf (fp, _("trust: %s"), otrust);
3238                       tty_fprintf (fp, "%*s", width, "");
3239                     }
3240
3241                   tty_fprintf (fp, _("validity: %s"), trust);
3242                   tty_fprintf (fp, "\n");
3243                 }
3244               if (node->pkt->pkttype == PKT_PUBLIC_KEY
3245                   && (get_ownertrust (pk) & TRUST_FLAG_DISABLED))
3246                 {
3247                   tty_fprintf (fp, "*** ");
3248                   tty_fprintf (fp, _("This key has been disabled"));
3249                   tty_fprintf (fp, "\n");
3250                 }
3251             }
3252
3253           if ((node->pkt->pkttype == PKT_PUBLIC_KEY
3254                || node->pkt->pkttype == PKT_SECRET_KEY) && with_fpr)
3255             {
3256               print_fingerprint (fp, pk, 2);
3257               tty_fprintf (fp, "\n");
3258             }
3259         }
3260     }
3261
3262   show_names (fp,
3263               keyblock, primary, only_marked ? NODFLG_MARK_A : 0, with_prefs);
3264
3265   if (do_warn && !nowarn)
3266     tty_fprintf (fp, _("Please note that the shown key validity"
3267                        " is not necessarily correct\n"
3268                        "unless you restart the program.\n"));
3269
3270   xfree (serialno);
3271 }
3272
3273
3274 /* Display basic key information.  This function is suitable to show
3275    information on the key without any dependencies on the trustdb or
3276    any other internal GnuPG stuff.  KEYBLOCK may either be a public or
3277    a secret key.  This function may be called with KEYBLOCK containing
3278    secret keys and thus the printing of "pub" vs. "sec" does only
3279    depend on the packet type and not by checking with gpg-agent.  */
3280 void
3281 show_basic_key_info (KBNODE keyblock)
3282 {
3283   KBNODE node;
3284   int i;
3285   char pkstrbuf[PUBKEY_STRING_SIZE];
3286
3287   /* The primary key */
3288   for (node = keyblock; node; node = node->next)
3289     {
3290       if (node->pkt->pkttype == PKT_PUBLIC_KEY
3291           || node->pkt->pkttype == PKT_SECRET_KEY)
3292         {
3293           PKT_public_key *pk = node->pkt->pkt.public_key;
3294
3295           /* Note, we use the same format string as in other show
3296              functions to make the translation job easier. */
3297           tty_printf ("%s  %s/%s  ",
3298                       node->pkt->pkttype == PKT_PUBLIC_KEY ? "pub" :
3299                       node->pkt->pkttype == PKT_PUBLIC_SUBKEY ? "sub" :
3300                       node->pkt->pkttype == PKT_SECRET_KEY ? "sec" :"ssb",
3301                       pubkey_string (pk, pkstrbuf, sizeof pkstrbuf),
3302                       keystr_from_pk (pk));
3303           tty_printf (_("created: %s"), datestr_from_pk (pk));
3304           tty_printf ("  ");
3305           tty_printf (_("expires: %s"), expirestr_from_pk (pk));
3306           tty_printf ("\n");
3307           print_fingerprint (NULL, pk, 3);
3308           tty_printf ("\n");
3309         }
3310     }
3311
3312   /* The user IDs. */
3313   for (i = 0, node = keyblock; node; node = node->next)
3314     {
3315       if (node->pkt->pkttype == PKT_USER_ID)
3316         {
3317           PKT_user_id *uid = node->pkt->pkt.user_id;
3318           ++i;
3319
3320           tty_printf ("     ");
3321           if (uid->is_revoked)
3322             tty_printf ("[%s] ", _("revoked"));
3323           else if (uid->is_expired)
3324             tty_printf ("[%s] ", _("expired"));
3325           tty_print_utf8_string (uid->name, uid->len);
3326           tty_printf ("\n");
3327         }
3328     }
3329 }
3330
3331
3332 static void
3333 show_key_and_fingerprint (kbnode_t keyblock, int with_subkeys)
3334 {
3335   kbnode_t node;
3336   PKT_public_key *pk = NULL;
3337   char pkstrbuf[PUBKEY_STRING_SIZE];
3338
3339   for (node = keyblock; node; node = node->next)
3340     {
3341       if (node->pkt->pkttype == PKT_PUBLIC_KEY)
3342         {
3343           pk = node->pkt->pkt.public_key;