g10: Allow relative path for specifying the file for bkuptocard.
[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           {
1926             /* Ask for a filename, check whether this is really a
1927                backup key as generated by the card generation, parse
1928                that key and store it on card. */
1929             KBNODE node;
1930             char *fname;
1931             PACKET *pkt;
1932             IOBUF a;
1933
1934             if (!*arg_string)
1935               {
1936                 tty_printf (_("Command expects a filename argument\n"));
1937                 break;
1938               }
1939
1940             if (*arg_string == DIRSEP_C)
1941               fname = xstrdup (arg_string);
1942             else if (*arg_string == '~')
1943               fname = make_filename (arg_string, NULL);
1944             else
1945               fname = make_filename (opt.homedir, arg_string, NULL);
1946
1947             /* Open that file.  */
1948             a = iobuf_open (fname);
1949             if (a && is_secured_file (iobuf_get_fd (a)))
1950               {
1951                 iobuf_close (a);
1952                 a = NULL;
1953                 gpg_err_set_errno (EPERM);
1954               }
1955             if (!a)
1956               {
1957                 tty_printf (_("Can't open '%s': %s\n"),
1958                             fname, strerror (errno));
1959                 xfree (fname);
1960                 break;
1961               }
1962
1963             /* Parse and check that file.  */
1964             pkt = xmalloc (sizeof *pkt);
1965             init_packet (pkt);
1966             err = parse_packet (a, pkt);
1967             iobuf_close (a);
1968             iobuf_ioctl (NULL, IOBUF_IOCTL_INVALIDATE_CACHE, 0, (char *) fname);
1969             if (!err && pkt->pkttype != PKT_SECRET_KEY
1970                 && pkt->pkttype != PKT_SECRET_SUBKEY)
1971               err = GPG_ERR_NO_SECKEY;
1972             if (err)
1973               {
1974                 tty_printf (_("Error reading backup key from '%s': %s\n"),
1975                             fname, gpg_strerror (err));
1976                 xfree (fname);
1977                 free_packet (pkt);
1978                 xfree (pkt);
1979                 break;
1980               }
1981
1982             xfree (fname);
1983             node = new_kbnode (pkt);
1984
1985             if (cmd == cmdCHECKBKUPKEY)
1986               {
1987                 log_debug ("FIXME: This needs to be changed\n");
1988                 /* PKT_public_key *sk = node->pkt->pkt.secret_key; */
1989                 /* switch (is_secret_key_protected (sk)) */
1990                 /*   { */
1991                 /*   case 0:    /\* Not protected. *\/ */
1992                 /*     tty_printf (_("This key is not protected.\n")); */
1993                 /*     break; */
1994                 /*   case -1: */
1995                 /*     log_error (_("unknown key protection algorithm\n")); */
1996                 /*     break; */
1997                 /*   default: */
1998                 /*     if (sk->protect.s2k.mode == 1001) */
1999                 /*       tty_printf (_("Secret parts of key" */
2000                 /*                  " are not available.\n")); */
2001                 /*     if (sk->protect.s2k.mode == 1002) */
2002                 /*       tty_printf (_("Secret parts of key" */
2003                 /*                  " are stored on-card.\n")); */
2004                     /* else */
2005                     /*   check_secret_key (sk, 0); */
2006                   /* } */
2007               }
2008             else                /* Store it.  */
2009               {
2010                 /* We need to transfer it to gpg-agent.  */
2011                 err = transfer_secret_keys (ctrl, NULL, node, 1);
2012
2013                 /* Then, treat the pkt as a public key to call
2014                    card_store_subkey.  */
2015                 pkt->pkttype = PKT_PUBLIC_KEY;
2016
2017                 if (card_store_subkey (node, 0))
2018                   {
2019                     redisplay = 1;
2020                     sec_shadowing = 1;
2021                   }
2022               }
2023             release_kbnode (node);
2024           }
2025           break;
2026
2027 #endif /* ENABLE_CARD_SUPPORT */
2028
2029         case cmdDELKEY:
2030           {
2031             int n1;
2032
2033             if (!(n1 = count_selected_keys (keyblock)))
2034               {
2035                 tty_printf (_("You must select at least one key.\n"));
2036                 if (!opt.expert)
2037                   tty_printf (_("(Use the '%s' command.)\n"), "key");
2038               }
2039             else if (!cpr_get_answer_is_yes
2040                      ("keyedit.remove.subkey.okay",
2041                       n1 > 1 ? _("Do you really want to delete the "
2042                                  "selected keys? (y/N) ")
2043                       :  _("Do you really want to delete this key? (y/N) ")))
2044               ;
2045             else
2046               {
2047                 menu_delkey (keyblock);
2048                 redisplay = 1;
2049                 modified = 1;
2050               }
2051           }
2052           break;
2053
2054         case cmdADDREVOKER:
2055           {
2056             int sensitive = 0;
2057
2058             if (ascii_strcasecmp (arg_string, "sensitive") == 0)
2059               sensitive = 1;
2060             if (menu_addrevoker (ctrl, keyblock, sensitive))
2061               {
2062                 redisplay = 1;
2063                 modified = 1;
2064                 merge_keys_and_selfsig (keyblock);
2065               }
2066           }
2067           break;
2068
2069         case cmdREVUID:
2070           {
2071             int n1;
2072
2073             if (!(n1 = count_selected_uids (keyblock)))
2074               {
2075                 tty_printf (_("You must select at least one user ID.\n"));
2076                 if (!opt.expert)
2077                   tty_printf (_("(Use the '%s' command.)\n"), "uid");
2078               }
2079             else if (cpr_get_answer_is_yes
2080                      ("keyedit.revoke.uid.okay",
2081                       n1 > 1 ? _("Really revoke all selected user IDs? (y/N) ")
2082                       :        _("Really revoke this user ID? (y/N) ")))
2083               {
2084                 if (menu_revuid (keyblock))
2085                   {
2086                     modified = 1;
2087                     redisplay = 1;
2088                   }
2089               }
2090           }
2091           break;
2092
2093         case cmdREVKEY:
2094           {
2095             int n1;
2096
2097             if (!(n1 = count_selected_keys (keyblock)))
2098               {
2099                 if (cpr_get_answer_is_yes ("keyedit.revoke.subkey.okay",
2100                                            _("Do you really want to revoke"
2101                                              " the entire key? (y/N) ")))
2102                   {
2103                     if (menu_revkey (keyblock))
2104                       modified = 1;
2105
2106                     redisplay = 1;
2107                   }
2108               }
2109             else if (cpr_get_answer_is_yes ("keyedit.revoke.subkey.okay",
2110                                             n1 > 1 ?
2111                                             _("Do you really want to revoke"
2112                                               " the selected subkeys? (y/N) ")
2113                                             : _("Do you really want to revoke"
2114                                                 " this subkey? (y/N) ")))
2115               {
2116                 if (menu_revsubkey (keyblock))
2117                   modified = 1;
2118
2119                 redisplay = 1;
2120               }
2121
2122             if (modified)
2123               merge_keys_and_selfsig (keyblock);
2124           }
2125           break;
2126
2127         case cmdEXPIRE:
2128           if (menu_expire (keyblock))
2129             {
2130               merge_keys_and_selfsig (keyblock);
2131               run_subkey_warnings = 1;
2132               modified = 1;
2133               redisplay = 1;
2134             }
2135           break;
2136
2137         case cmdBACKSIGN:
2138           if (menu_backsign (keyblock))
2139             {
2140               modified = 1;
2141               redisplay = 1;
2142             }
2143           break;
2144
2145         case cmdPRIMARY:
2146           if (menu_set_primary_uid (keyblock))
2147             {
2148               merge_keys_and_selfsig (keyblock);
2149               modified = 1;
2150               redisplay = 1;
2151             }
2152           break;
2153
2154         case cmdPASSWD:
2155           change_passphrase (ctrl, keyblock);
2156           break;
2157
2158 #ifndef NO_TRUST_MODELS
2159         case cmdTRUST:
2160           if (opt.trust_model == TM_EXTERNAL)
2161             {
2162               tty_printf (_("Owner trust may not be set while "
2163                             "using a user provided trust database\n"));
2164               break;
2165             }
2166
2167           show_key_with_all_names (ctrl, NULL, keyblock, 0, 0, 0, 1, 0, 0);
2168           tty_printf ("\n");
2169           if (edit_ownertrust (find_kbnode (keyblock,
2170                                             PKT_PUBLIC_KEY)->pkt->pkt.
2171                                public_key, 1))
2172             {
2173               redisplay = 1;
2174               /* No real need to set update_trust here as
2175                  edit_ownertrust() calls revalidation_mark()
2176                  anyway. */
2177               update_trust = 1;
2178             }
2179           break;
2180 #endif /*!NO_TRUST_MODELS*/
2181
2182         case cmdPREF:
2183           {
2184             int count = count_selected_uids (keyblock);
2185             assert (keyblock->pkt->pkttype == PKT_PUBLIC_KEY);
2186             show_names (NULL, keyblock, keyblock->pkt->pkt.public_key,
2187                         count ? NODFLG_SELUID : 0, 1);
2188           }
2189           break;
2190
2191         case cmdSHOWPREF:
2192           {
2193             int count = count_selected_uids (keyblock);
2194             assert (keyblock->pkt->pkttype == PKT_PUBLIC_KEY);
2195             show_names (NULL, keyblock, keyblock->pkt->pkt.public_key,
2196                         count ? NODFLG_SELUID : 0, 2);
2197           }
2198           break;
2199
2200         case cmdSETPREF:
2201           {
2202             PKT_user_id *tempuid;
2203
2204             keygen_set_std_prefs (!*arg_string ? "default" : arg_string, 0);
2205
2206             tempuid = keygen_get_std_prefs ();
2207             tty_printf (_("Set preference list to:\n"));
2208             show_prefs (tempuid, NULL, 1);
2209             free_user_id (tempuid);
2210
2211             if (cpr_get_answer_is_yes
2212                 ("keyedit.setpref.okay",
2213                  count_selected_uids (keyblock) ?
2214                  _("Really update the preferences"
2215                    " for the selected user IDs? (y/N) ")
2216                  : _("Really update the preferences? (y/N) ")))
2217               {
2218                 if (menu_set_preferences (keyblock))
2219                   {
2220                     merge_keys_and_selfsig (keyblock);
2221                     modified = 1;
2222                     redisplay = 1;
2223                   }
2224               }
2225           }
2226           break;
2227
2228         case cmdPREFKS:
2229           if (menu_set_keyserver_url (*arg_string ? arg_string : NULL,
2230                                       keyblock))
2231             {
2232               merge_keys_and_selfsig (keyblock);
2233               modified = 1;
2234               redisplay = 1;
2235             }
2236           break;
2237
2238         case cmdNOTATION:
2239           if (menu_set_notation (*arg_string ? arg_string : NULL,
2240                                  keyblock))
2241             {
2242               merge_keys_and_selfsig (keyblock);
2243               modified = 1;
2244               redisplay = 1;
2245             }
2246           break;
2247
2248         case cmdNOP:
2249           break;
2250
2251         case cmdREVSIG:
2252           if (menu_revsig (keyblock))
2253             {
2254               redisplay = 1;
2255               modified = 1;
2256             }
2257           break;
2258
2259 #ifndef NO_TRUST_MODELS
2260         case cmdENABLEKEY:
2261         case cmdDISABLEKEY:
2262           if (enable_disable_key (keyblock, cmd == cmdDISABLEKEY))
2263             {
2264               redisplay = 1;
2265               modified = 1;
2266             }
2267           break;
2268 #endif /*!NO_TRUST_MODELS*/
2269
2270         case cmdSHOWPHOTO:
2271           menu_showphoto (keyblock);
2272           break;
2273
2274         case cmdCLEAN:
2275           if (menu_clean (keyblock, 0))
2276             redisplay = modified = 1;
2277           break;
2278
2279         case cmdMINIMIZE:
2280           if (menu_clean (keyblock, 1))
2281             redisplay = modified = 1;
2282           break;
2283
2284         case cmdQUIT:
2285           if (have_commands)
2286             goto leave;
2287           if (!modified && !sec_shadowing)
2288             goto leave;
2289           if (!cpr_get_answer_is_yes ("keyedit.save.okay",
2290                                       _("Save changes? (y/N) ")))
2291             {
2292               if (cpr_enabled ()
2293                   || cpr_get_answer_is_yes ("keyedit.cancel.okay",
2294                                             _("Quit without saving? (y/N) ")))
2295                 goto leave;
2296               break;
2297             }
2298           /* fall thru */
2299         case cmdSAVE:
2300           if (modified)
2301             {
2302               err = keydb_update_keyblock (kdbhd, keyblock);
2303               if (err)
2304                 {
2305                   log_error (_("update failed: %s\n"), gpg_strerror (err));
2306                   break;
2307                 }
2308             }
2309
2310           if (sec_shadowing)
2311             {
2312               err = agent_scd_learn (NULL, 1);
2313               if (err)
2314                 {
2315                   log_error (_("update failed: %s\n"), gpg_strerror (err));
2316                   break;
2317                 }
2318             }
2319
2320           if (!modified && !sec_shadowing)
2321             tty_printf (_("Key not changed so no update needed.\n"));
2322
2323           if (update_trust)
2324             {
2325               revalidation_mark ();
2326               update_trust = 0;
2327             }
2328           goto leave;
2329
2330         case cmdINVCMD:
2331         default:
2332           tty_printf ("\n");
2333           tty_printf (_("Invalid command  (try \"help\")\n"));
2334           break;
2335         }
2336     } /* End of the main command loop.  */
2337
2338  leave:
2339   release_kbnode (keyblock);
2340   keydb_release (kdbhd);
2341   xfree (answer);
2342 }
2343
2344
2345 /* Change the passphrase of the secret key identified by USERNAME.  */
2346 void
2347 keyedit_passwd (ctrl_t ctrl, const char *username)
2348 {
2349   gpg_error_t err;
2350   PKT_public_key *pk;
2351   kbnode_t keyblock = NULL;
2352
2353   pk = xtrycalloc (1, sizeof *pk);
2354   if (!pk)
2355     {
2356       err = gpg_error_from_syserror ();
2357       goto leave;
2358     }
2359   err = getkey_byname (ctrl, NULL, pk, username, 1, &keyblock);
2360   if (err)
2361     goto leave;
2362
2363   err = change_passphrase (ctrl, keyblock);
2364
2365 leave:
2366   release_kbnode (keyblock);
2367   free_public_key (pk);
2368   if (err)
2369     {
2370       log_info ("error changing the passphrase for '%s': %s\n",
2371                 username, gpg_strerror (err));
2372       write_status_error ("keyedit.passwd", err);
2373     }
2374   else
2375     write_status_text (STATUS_SUCCESS, "keyedit.passwd");
2376 }
2377
2378
2379 /* Unattended adding of a new keyid.  USERNAME specifies the
2380    key. NEWUID is the new user id to add to the key.  */
2381 void
2382 keyedit_quick_adduid (ctrl_t ctrl, const char *username, const char *newuid)
2383 {
2384   gpg_error_t err;
2385   KEYDB_HANDLE kdbhd = NULL;
2386   KEYDB_SEARCH_DESC desc;
2387   kbnode_t keyblock = NULL;
2388   kbnode_t node;
2389   char *uidstring = NULL;
2390
2391   uidstring = xstrdup (newuid);
2392   trim_spaces (uidstring);
2393   if (!*uidstring)
2394     {
2395       log_error ("%s\n", gpg_strerror (GPG_ERR_INV_USER_ID));
2396       goto leave;
2397     }
2398
2399 #ifdef HAVE_W32_SYSTEM
2400   /* See keyedit_menu for why we need this.  */
2401   check_trustdb_stale ();
2402 #endif
2403
2404   /* Search the key; we don't want the whole getkey stuff here.  */
2405   kdbhd = keydb_new ();
2406   if (!kdbhd)
2407     {
2408       err = gpg_error_from_syserror ();
2409       goto leave;
2410     }
2411
2412   err = classify_user_id (username, &desc, 1);
2413   if (!err)
2414     err = keydb_search (kdbhd, &desc, 1, NULL);
2415   if (!err)
2416     {
2417       err = keydb_get_keyblock (kdbhd, &keyblock);
2418       if (err)
2419         {
2420           log_error (_("error reading keyblock: %s\n"), gpg_strerror (err));
2421           goto leave;
2422         }
2423       /* Now with the keyblock retrieved, search again to detect an
2424          ambiguous specification.  We need to save the found state so
2425          that we can do an update later.  */
2426       keydb_push_found_state (kdbhd);
2427       err = keydb_search (kdbhd, &desc, 1, NULL);
2428       if (!err)
2429         err = gpg_error (GPG_ERR_AMBIGUOUS_NAME);
2430       else if (gpg_err_code (err) == GPG_ERR_NOT_FOUND)
2431         err = 0;
2432       keydb_pop_found_state (kdbhd);
2433
2434       if (!err)
2435         {
2436           /* We require the secret primary key to add a UID.  */
2437           node = find_kbnode (keyblock, PKT_PUBLIC_KEY);
2438           if (!node)
2439             BUG ();
2440           err = agent_probe_secret_key (ctrl, node->pkt->pkt.public_key);
2441         }
2442     }
2443   if (err)
2444     {
2445       log_error (_("secret key \"%s\" not found: %s\n"),
2446                  username, gpg_strerror (err));
2447       goto leave;
2448     }
2449
2450   fix_keyblock (&keyblock);
2451
2452   if (menu_adduid (keyblock, 0, NULL, uidstring))
2453     {
2454       err = keydb_update_keyblock (kdbhd, keyblock);
2455       if (err)
2456         {
2457           log_error (_("update failed: %s\n"), gpg_strerror (err));
2458           goto leave;
2459         }
2460
2461       if (update_trust)
2462         revalidation_mark ();
2463     }
2464
2465  leave:
2466   xfree (uidstring);
2467   release_kbnode (keyblock);
2468   keydb_release (kdbhd);
2469 }
2470
2471
2472 /* Unattended key signing function.  If the key specifified by FPR is
2473    availabale and FPR is the primary fingerprint all user ids of the
2474    user ids of the key are signed using the default signing key.  If
2475    UIDS is an empty list all usable UIDs are signed, if it is not
2476    empty, only those user ids matching one of the entries of the loist
2477    are signed.  With LOCAL being true kthe signatures are marked as
2478    non-exportable.  */
2479 void
2480 keyedit_quick_sign (ctrl_t ctrl, const char *fpr, strlist_t uids,
2481                     strlist_t locusr, int local)
2482 {
2483   gpg_error_t err;
2484   kbnode_t keyblock = NULL;
2485   KEYDB_HANDLE kdbhd = NULL;
2486   int modified = 0;
2487   KEYDB_SEARCH_DESC desc;
2488   PKT_public_key *pk;
2489   kbnode_t node;
2490   strlist_t sl;
2491   int any;
2492
2493 #ifdef HAVE_W32_SYSTEM
2494   /* See keyedit_menu for why we need this.  */
2495   check_trustdb_stale ();
2496 #endif
2497
2498   /* We require a fingerprint because only this uniquely identifies a
2499      key and may thus be used to select a key for unattended key
2500      signing.  */
2501   if (classify_user_id (fpr, &desc, 1)
2502       || !(desc.mode == KEYDB_SEARCH_MODE_FPR
2503            || desc.mode == KEYDB_SEARCH_MODE_FPR16
2504            || desc.mode == KEYDB_SEARCH_MODE_FPR20))
2505     {
2506       log_error (_("\"%s\" is not a fingerprint\n"), fpr);
2507       goto leave;
2508     }
2509   err = get_pubkey_byname (ctrl, NULL, NULL, fpr, &keyblock, &kdbhd, 1, 1);
2510   if (err)
2511     {
2512       log_error (_("key \"%s\" not found: %s\n"), fpr, gpg_strerror (err));
2513       goto leave;
2514     }
2515
2516   /* Check that the primary fingerprint has been given. */
2517   {
2518     byte fprbin[MAX_FINGERPRINT_LEN];
2519     size_t fprlen;
2520
2521     fingerprint_from_pk (keyblock->pkt->pkt.public_key, fprbin, &fprlen);
2522     if (fprlen == 16 && desc.mode == KEYDB_SEARCH_MODE_FPR16
2523         && !memcmp (fprbin, desc.u.fpr, 16))
2524       ;
2525     else if (fprlen == 16 && desc.mode == KEYDB_SEARCH_MODE_FPR
2526              && !memcmp (fprbin, desc.u.fpr, 16)
2527              && !desc.u.fpr[16]
2528              && !desc.u.fpr[17]
2529              && !desc.u.fpr[18]
2530              && !desc.u.fpr[19])
2531       ;
2532     else if (fprlen == 20 && (desc.mode == KEYDB_SEARCH_MODE_FPR20
2533                               || desc.mode == KEYDB_SEARCH_MODE_FPR)
2534              && !memcmp (fprbin, desc.u.fpr, 20))
2535       ;
2536     else
2537       {
2538         log_error (_("\"%s\" is not the primary fingerprint\n"), fpr);
2539         goto leave;
2540       }
2541   }
2542
2543   if (fix_keyblock (&keyblock))
2544     modified++;
2545
2546   /* Give some info in verbose.  */
2547   if (opt.verbose)
2548     {
2549       show_key_with_all_names (ctrl, es_stdout, keyblock, 0,
2550                                1/*with_revoker*/, 1/*with_fingerprint*/,
2551                                0, 0, 1);
2552       es_fflush (es_stdout);
2553     }
2554
2555   pk = keyblock->pkt->pkt.public_key;
2556   if (pk->flags.revoked)
2557     {
2558       if (!opt.verbose)
2559         show_key_with_all_names (ctrl, es_stdout, keyblock, 0, 0, 0, 0, 0, 1);
2560       log_error ("%s%s", _("Key is revoked."), _("  Unable to sign.\n"));
2561       goto leave;
2562     }
2563
2564   /* Set the flags according to the UIDS list.  Fixme: We may want to
2565      use classify_user_id along with dedicated compare functions so
2566      that we match the same way as in the key lookup. */
2567   any = 0;
2568   menu_select_uid (keyblock, 0);   /* Better clear the flags first. */
2569   for (sl=uids; sl; sl = sl->next)
2570     {
2571       for (node = keyblock; node; node = node->next)
2572         {
2573           if (node->pkt->pkttype == PKT_USER_ID)
2574             {
2575               PKT_user_id *uid = node->pkt->pkt.user_id;
2576
2577               if (!uid->attrib_data
2578                   && ascii_memistr (uid->name, uid->len, sl->d))
2579                 {
2580                   node->flag |= NODFLG_SELUID;
2581                   any = 1;
2582                 }
2583             }
2584         }
2585     }
2586
2587   if (uids && !any)
2588     {
2589       if (!opt.verbose)
2590         show_key_with_all_names (ctrl, es_stdout, keyblock, 0, 0, 0, 0, 0, 1);
2591       es_fflush (es_stdout);
2592       log_error ("%s  %s", _("No matching user IDs."), _("Nothing to sign.\n"));
2593       goto leave;
2594     }
2595
2596   /* Sign. */
2597   sign_uids (ctrl, es_stdout, keyblock, locusr, &modified, local, 0, 0, 0, 1);
2598   es_fflush (es_stdout);
2599
2600   if (modified)
2601     {
2602       err = keydb_update_keyblock (kdbhd, keyblock);
2603       if (err)
2604         {
2605           log_error (_("update failed: %s\n"), gpg_strerror (err));
2606           goto leave;
2607         }
2608     }
2609   else
2610     log_info (_("Key not changed so no update needed.\n"));
2611
2612   if (update_trust)
2613     revalidation_mark ();
2614
2615
2616  leave:
2617   release_kbnode (keyblock);
2618   keydb_release (kdbhd);
2619 }
2620
2621
2622 \f
2623 static void
2624 tty_print_notations (int indent, PKT_signature * sig)
2625 {
2626   int first = 1;
2627   struct notation *notation, *nd;
2628
2629   if (indent < 0)
2630     {
2631       first = 0;
2632       indent = -indent;
2633     }
2634
2635   notation = sig_to_notation (sig);
2636
2637   for (nd = notation; nd; nd = nd->next)
2638     {
2639       if (!first)
2640         tty_printf ("%*s", indent, "");
2641       else
2642         first = 0;
2643
2644       tty_print_utf8_string (nd->name, strlen (nd->name));
2645       tty_printf ("=");
2646       tty_print_utf8_string (nd->value, strlen (nd->value));
2647       tty_printf ("\n");
2648     }
2649
2650   free_notation (notation);
2651 }
2652
2653
2654 /*
2655  * Show preferences of a public keyblock.
2656  */
2657 static void
2658 show_prefs (PKT_user_id * uid, PKT_signature * selfsig, int verbose)
2659 {
2660   const prefitem_t fake = { 0, 0 };
2661   const prefitem_t *prefs;
2662   int i;
2663
2664   if (!uid)
2665     return;
2666
2667   if (uid->prefs)
2668     prefs = uid->prefs;
2669   else if (verbose)
2670     prefs = &fake;
2671   else
2672     return;
2673
2674   if (verbose)
2675     {
2676       int any, des_seen = 0, sha1_seen = 0, uncomp_seen = 0;
2677
2678       tty_printf ("     ");
2679       tty_printf (_("Cipher: "));
2680       for (i = any = 0; prefs[i].type; i++)
2681         {
2682           if (prefs[i].type == PREFTYPE_SYM)
2683             {
2684               if (any)
2685                 tty_printf (", ");
2686               any = 1;
2687               /* We don't want to display strings for experimental algos */
2688               if (!openpgp_cipher_test_algo (prefs[i].value)
2689                   && prefs[i].value < 100)
2690                 tty_printf ("%s", openpgp_cipher_algo_name (prefs[i].value));
2691               else
2692                 tty_printf ("[%d]", prefs[i].value);
2693               if (prefs[i].value == CIPHER_ALGO_3DES)
2694                 des_seen = 1;
2695             }
2696         }
2697       if (!des_seen)
2698         {
2699           if (any)
2700             tty_printf (", ");
2701           tty_printf ("%s", openpgp_cipher_algo_name (CIPHER_ALGO_3DES));
2702         }
2703       tty_printf ("\n     ");
2704       tty_printf (_("Digest: "));
2705       for (i = any = 0; prefs[i].type; i++)
2706         {
2707           if (prefs[i].type == PREFTYPE_HASH)
2708             {
2709               if (any)
2710                 tty_printf (", ");
2711               any = 1;
2712               /* We don't want to display strings for experimental algos */
2713               if (!gcry_md_test_algo (prefs[i].value) && prefs[i].value < 100)
2714                 tty_printf ("%s", gcry_md_algo_name (prefs[i].value));
2715               else
2716                 tty_printf ("[%d]", prefs[i].value);
2717               if (prefs[i].value == DIGEST_ALGO_SHA1)
2718                 sha1_seen = 1;
2719             }
2720         }
2721       if (!sha1_seen)
2722         {
2723           if (any)
2724             tty_printf (", ");
2725           tty_printf ("%s", gcry_md_algo_name (DIGEST_ALGO_SHA1));
2726         }
2727       tty_printf ("\n     ");
2728       tty_printf (_("Compression: "));
2729       for (i = any = 0; prefs[i].type; i++)
2730         {
2731           if (prefs[i].type == PREFTYPE_ZIP)
2732             {
2733               const char *s = compress_algo_to_string (prefs[i].value);
2734
2735               if (any)
2736                 tty_printf (", ");
2737               any = 1;
2738               /* We don't want to display strings for experimental algos */
2739               if (s && prefs[i].value < 100)
2740                 tty_printf ("%s", s);
2741               else
2742                 tty_printf ("[%d]", prefs[i].value);
2743               if (prefs[i].value == COMPRESS_ALGO_NONE)
2744                 uncomp_seen = 1;
2745             }
2746         }
2747       if (!uncomp_seen)
2748         {
2749           if (any)
2750             tty_printf (", ");
2751           else
2752             {
2753               tty_printf ("%s", compress_algo_to_string (COMPRESS_ALGO_ZIP));
2754               tty_printf (", ");
2755             }
2756           tty_printf ("%s", compress_algo_to_string (COMPRESS_ALGO_NONE));
2757         }
2758       if (uid->flags.mdc || !uid->flags.ks_modify)
2759         {
2760           tty_printf ("\n     ");
2761           tty_printf (_("Features: "));
2762           any = 0;
2763           if (uid->flags.mdc)
2764             {
2765               tty_printf ("MDC");
2766               any = 1;
2767             }
2768           if (!uid->flags.ks_modify)
2769             {
2770               if (any)
2771                 tty_printf (", ");
2772               tty_printf (_("Keyserver no-modify"));
2773             }
2774         }
2775       tty_printf ("\n");
2776
2777       if (selfsig)
2778         {
2779           const byte *pref_ks;
2780           size_t pref_ks_len;
2781
2782           pref_ks = parse_sig_subpkt (selfsig->hashed,
2783                                       SIGSUBPKT_PREF_KS, &pref_ks_len);
2784           if (pref_ks && pref_ks_len)
2785             {
2786               tty_printf ("     ");
2787               tty_printf (_("Preferred keyserver: "));
2788               tty_print_utf8_string (pref_ks, pref_ks_len);
2789               tty_printf ("\n");
2790             }
2791
2792           if (selfsig->flags.notation)
2793             {
2794               tty_printf ("     ");
2795               tty_printf (_("Notations: "));
2796               tty_print_notations (5 + strlen (_("Notations: ")), selfsig);
2797             }
2798         }
2799     }
2800   else
2801     {
2802       tty_printf ("    ");
2803       for (i = 0; prefs[i].type; i++)
2804         {
2805           tty_printf (" %c%d", prefs[i].type == PREFTYPE_SYM ? 'S' :
2806                       prefs[i].type == PREFTYPE_HASH ? 'H' :
2807                       prefs[i].type == PREFTYPE_ZIP ? 'Z' : '?',
2808                       prefs[i].value);
2809         }
2810       if (uid->flags.mdc)
2811         tty_printf (" [mdc]");
2812       if (!uid->flags.ks_modify)
2813         tty_printf (" [no-ks-modify]");
2814       tty_printf ("\n");
2815     }
2816 }
2817
2818
2819 /* This is the version of show_key_with_all_names used when
2820    opt.with_colons is used.  It prints all available data in a easy to
2821    parse format and does not translate utf8 */
2822 static void
2823 show_key_with_all_names_colon (ctrl_t ctrl, estream_t fp, kbnode_t keyblock)
2824 {
2825   KBNODE node;
2826   int i, j, ulti_hack = 0;
2827   byte pk_version = 0;
2828   PKT_public_key *primary = NULL;
2829   int have_seckey;
2830
2831   if (!fp)
2832     fp = es_stdout;
2833
2834   /* the keys */
2835   for (node = keyblock; node; node = node->next)
2836     {
2837       if (node->pkt->pkttype == PKT_PUBLIC_KEY
2838           || (node->pkt->pkttype == PKT_PUBLIC_SUBKEY))
2839         {
2840           PKT_public_key *pk = node->pkt->pkt.public_key;
2841           u32 keyid[2];
2842
2843           if (node->pkt->pkttype == PKT_PUBLIC_KEY)
2844             {
2845               pk_version = pk->version;
2846               primary = pk;
2847             }
2848
2849           keyid_from_pk (pk, keyid);
2850           have_seckey = !agent_probe_secret_key (ctrl, pk);
2851
2852           if (node->pkt->pkttype == PKT_PUBLIC_KEY)
2853             es_fputs (have_seckey? "sec:" : "pub:", fp);
2854           else
2855             es_fputs (have_seckey? "ssb:" : "sub:", fp);
2856
2857           if (!pk->flags.valid)
2858             es_putc ('i', fp);
2859           else if (pk->flags.revoked)
2860             es_putc ('r', fp);
2861           else if (pk->has_expired)
2862             es_putc ('e', fp);
2863           else if (!(opt.fast_list_mode || opt.no_expensive_trust_checks))
2864             {
2865               int trust = get_validity_info (pk, NULL);
2866               if (trust == 'u')
2867                 ulti_hack = 1;
2868               es_putc (trust, fp);
2869             }
2870
2871           es_fprintf (fp, ":%u:%d:%08lX%08lX:%lu:%lu::",
2872                       nbits_from_pk (pk),
2873                       pk->pubkey_algo,
2874                       (ulong) keyid[0], (ulong) keyid[1],
2875                       (ulong) pk->timestamp, (ulong) pk->expiredate);
2876           if (node->pkt->pkttype == PKT_PUBLIC_KEY
2877               && !(opt.fast_list_mode || opt.no_expensive_trust_checks))
2878             es_putc (get_ownertrust_info (pk), fp);
2879           es_putc (':', fp);
2880           es_putc (':', fp);
2881           es_putc (':', fp);
2882           /* Print capabilities.  */
2883           if ((pk->pubkey_usage & PUBKEY_USAGE_ENC))
2884             es_putc ('e', fp);
2885           if ((pk->pubkey_usage & PUBKEY_USAGE_SIG))
2886             es_putc ('s', fp);
2887           if ((pk->pubkey_usage & PUBKEY_USAGE_CERT))
2888             es_putc ('c', fp);
2889           if ((pk->pubkey_usage & PUBKEY_USAGE_AUTH))
2890             es_putc ('a', fp);
2891           es_putc ('\n', fp);
2892
2893           print_fingerprint (fp, pk, 0);
2894           print_revokers (fp, pk);
2895         }
2896     }
2897
2898   /* the user ids */
2899   i = 0;
2900   for (node = keyblock; node; node = node->next)
2901     {
2902       if (node->pkt->pkttype == PKT_USER_ID)
2903         {
2904           PKT_user_id *uid = node->pkt->pkt.user_id;
2905
2906           ++i;
2907
2908           if (uid->attrib_data)
2909             es_fputs ("uat:", fp);
2910           else
2911             es_fputs ("uid:", fp);
2912
2913           if (uid->is_revoked)
2914             es_fputs ("r::::::::", fp);
2915           else if (uid->is_expired)
2916             es_fputs ("e::::::::", fp);
2917           else if (opt.fast_list_mode || opt.no_expensive_trust_checks)
2918             es_fputs ("::::::::", fp);
2919           else
2920             {
2921               int uid_validity;
2922
2923               if (primary && !ulti_hack)
2924                 uid_validity = get_validity_info (primary, uid);
2925               else
2926                 uid_validity = 'u';
2927               es_fprintf (fp, "%c::::::::", uid_validity);
2928             }
2929
2930           if (uid->attrib_data)
2931             es_fprintf (fp, "%u %lu", uid->numattribs, uid->attrib_len);
2932           else
2933             es_write_sanitized (fp, uid->name, uid->len, ":", NULL);
2934
2935           es_putc (':', fp);
2936           /* signature class */
2937           es_putc (':', fp);
2938           /* capabilities */
2939           es_putc (':', fp);
2940           /* preferences */
2941           if (pk_version > 3 || uid->selfsigversion > 3)
2942             {
2943               const prefitem_t *prefs = uid->prefs;
2944
2945               for (j = 0; prefs && prefs[j].type; j++)
2946                 {
2947                   if (j)
2948                     es_putc (' ', fp);
2949                   es_fprintf (fp,
2950                               "%c%d", prefs[j].type == PREFTYPE_SYM ? 'S' :
2951                               prefs[j].type == PREFTYPE_HASH ? 'H' :
2952                               prefs[j].type == PREFTYPE_ZIP ? 'Z' : '?',
2953                               prefs[j].value);
2954                 }
2955               if (uid->flags.mdc)
2956                 es_fputs (",mdc", fp);
2957               if (!uid->flags.ks_modify)
2958                 es_fputs (",no-ks-modify", fp);
2959             }
2960           es_putc (':', fp);
2961           /* flags */
2962           es_fprintf (fp, "%d,", i);
2963           if (uid->is_primary)
2964             es_putc ('p', fp);
2965           if (uid->is_revoked)
2966             es_putc ('r', fp);
2967           if (uid->is_expired)
2968             es_putc ('e', fp);
2969           if ((node->flag & NODFLG_SELUID))
2970             es_putc ('s', fp);
2971           if ((node->flag & NODFLG_MARK_A))
2972             es_putc ('m', fp);
2973           es_putc (':', fp);
2974           if (opt.trust_model == TM_TOFU || opt.trust_model == TM_TOFU_PGP)
2975             {
2976 #ifdef USE_TOFU
2977               enum tofu_policy policy;
2978               if (! tofu_get_policy (primary, uid, &policy)
2979                   && policy != TOFU_POLICY_NONE)
2980                 es_fprintf (fp, "%s", tofu_policy_str (policy));
2981 #endif /*USE_TOFU*/
2982             }
2983           es_putc (':', fp);
2984           es_putc ('\n', fp);
2985         }
2986     }
2987 }
2988
2989
2990 static void
2991 show_names (estream_t fp,
2992             KBNODE keyblock, PKT_public_key * pk, unsigned int flag,
2993             int with_prefs)
2994 {
2995   KBNODE node;
2996   int i = 0;
2997
2998   for (node = keyblock; node; node = node->next)
2999     {
3000       if (node->pkt->pkttype == PKT_USER_ID && !is_deleted_kbnode (node))
3001         {
3002           PKT_user_id *uid = node->pkt->pkt.user_id;
3003           ++i;
3004           if (!flag || (flag && (node->flag & flag)))
3005             {
3006               if (!(flag & NODFLG_MARK_A) && pk)
3007                 tty_fprintf (fp, "%s ", uid_trust_string_fixed (pk, uid));
3008
3009               if (flag & NODFLG_MARK_A)
3010                 tty_fprintf (fp, "     ");
3011               else if (node->flag & NODFLG_SELUID)
3012                 tty_fprintf (fp, "(%d)* ", i);
3013               else if (uid->is_primary)
3014                 tty_fprintf (fp, "(%d). ", i);
3015               else
3016                 tty_fprintf (fp, "(%d)  ", i);
3017               tty_print_utf8_string2 (fp, uid->name, uid->len, 0);
3018               tty_fprintf (fp, "\n");
3019               if (with_prefs && pk)
3020                 {
3021                   if (pk->version > 3 || uid->selfsigversion > 3)
3022                     {
3023                       PKT_signature *selfsig = NULL;
3024                       KBNODE signode;
3025
3026                       for (signode = node->next;
3027                            signode && signode->pkt->pkttype == PKT_SIGNATURE;
3028                            signode = signode->next)
3029                         {
3030                           if (signode->pkt->pkt.signature->
3031                               flags.chosen_selfsig)
3032                             {
3033                               selfsig = signode->pkt->pkt.signature;
3034                               break;
3035                             }
3036                         }
3037
3038                       show_prefs (uid, selfsig, with_prefs == 2);
3039                     }
3040                   else
3041                     tty_fprintf (fp, _("There are no preferences on a"
3042                                        " PGP 2.x-style user ID.\n"));
3043                 }
3044             }
3045         }
3046     }
3047 }
3048
3049
3050 /*
3051  * Display the key a the user ids, if only_marked is true, do only so
3052  * for user ids with mark A flag set and do not display the index
3053  * number.  If FP is not NULL print to the given stream and not to the
3054  * tty (ignored in with-colons mode).
3055  */
3056 static void
3057 show_key_with_all_names (ctrl_t ctrl, estream_t fp,
3058                          KBNODE keyblock, int only_marked, int with_revoker,
3059                          int with_fpr, int with_subkeys, int with_prefs,
3060                          int nowarn)
3061 {
3062   gpg_error_t err;
3063   kbnode_t node;
3064   int i;
3065   int do_warn = 0;
3066   int have_seckey = 0;
3067   char *serialno = NULL;
3068   PKT_public_key *primary = NULL;
3069   char pkstrbuf[PUBKEY_STRING_SIZE];
3070
3071   if (opt.with_colons)
3072     {
3073       show_key_with_all_names_colon (ctrl, fp, keyblock);
3074       return;
3075     }
3076
3077   /* the keys */
3078   for (node = keyblock; node; node = node->next)
3079     {
3080       if (node->pkt->pkttype == PKT_PUBLIC_KEY
3081           || (with_subkeys && node->pkt->pkttype == PKT_PUBLIC_SUBKEY
3082               && !is_deleted_kbnode (node)))
3083         {
3084           PKT_public_key *pk = node->pkt->pkt.public_key;
3085           const char *otrust = "err";
3086           const char *trust = "err";
3087
3088           if (node->pkt->pkttype == PKT_PUBLIC_KEY)
3089             {
3090               /* do it here, so that debug messages don't clutter the
3091                * output */
3092               static int did_warn = 0;
3093
3094               trust = get_validity_string (pk, NULL);
3095               otrust = get_ownertrust_string (pk);
3096
3097               /* Show a warning once */
3098               if (!did_warn
3099                   && (get_validity (pk, NULL, NULL, 0)
3100                       & TRUST_FLAG_PENDING_CHECK))
3101                 {
3102                   did_warn = 1;
3103                   do_warn = 1;
3104                 }
3105
3106               primary = pk;
3107             }
3108
3109           if (pk->flags.revoked)
3110             {
3111               char *user = get_user_id_string_native (pk->revoked.keyid);
3112               tty_fprintf (fp,
3113                            _("The following key was revoked on"
3114                             " %s by %s key %s\n"),
3115                           revokestr_from_pk (pk),
3116                           gcry_pk_algo_name (pk->revoked.algo), user);
3117               xfree (user);
3118             }
3119
3120           if (with_revoker)
3121             {
3122               if (!pk->revkey && pk->numrevkeys)
3123                 BUG ();
3124               else
3125                 for (i = 0; i < pk->numrevkeys; i++)
3126                   {
3127                     u32 r_keyid[2];
3128                     char *user;
3129                     const char *algo;
3130
3131                     algo = gcry_pk_algo_name (pk->revkey[i].algid);
3132                     keyid_from_fingerprint (pk->revkey[i].fpr,
3133                                             MAX_FINGERPRINT_LEN, r_keyid);
3134
3135                     user = get_user_id_string_native (r_keyid);
3136                     tty_fprintf (fp,
3137                                  _("This key may be revoked by %s key %s"),
3138                                  algo ? algo : "?", user);
3139
3140                     if (pk->revkey[i].class & 0x40)
3141                       {
3142                         tty_fprintf (fp, " ");
3143                         tty_fprintf (fp, _("(sensitive)"));
3144                       }
3145
3146                     tty_fprintf (fp, "\n");
3147                     xfree (user);
3148                   }
3149             }
3150
3151           keyid_from_pk (pk, NULL);
3152
3153           xfree (serialno);
3154           serialno = NULL;
3155           {
3156             char *hexgrip;
3157
3158             err = hexkeygrip_from_pk (pk, &hexgrip);
3159             if (err)
3160               {
3161                 log_error ("error computing a keygrip: %s\n",
3162                            gpg_strerror (err));
3163                 have_seckey = 0;
3164               }
3165             else
3166               have_seckey = !agent_get_keyinfo (ctrl, hexgrip, &serialno);
3167             xfree (hexgrip);
3168           }
3169
3170           tty_fprintf
3171             (fp, "%s%c %s/%s",
3172              node->pkt->pkttype == PKT_PUBLIC_KEY && have_seckey? "sec" :
3173              node->pkt->pkttype == PKT_PUBLIC_KEY ?               "pub" :
3174              have_seckey ?                                        "ssb" :
3175                                                                   "sub",
3176              (node->flag & NODFLG_SELKEY) ? '*' : ' ',
3177              pubkey_string (pk, pkstrbuf, sizeof pkstrbuf),
3178              keystr (pk->keyid));
3179
3180           if (opt.legacy_list_mode)
3181             tty_fprintf (fp, "  ");
3182           else
3183             tty_fprintf (fp, "\n     ");
3184
3185           tty_fprintf (fp, _("created: %s"), datestr_from_pk (pk));
3186           tty_fprintf (fp, "  ");
3187           if (pk->flags.revoked)
3188             tty_fprintf (fp, _("revoked: %s"), revokestr_from_pk (pk));
3189           else if (pk->has_expired)
3190             tty_fprintf (fp, _("expired: %s"), expirestr_from_pk (pk));
3191           else
3192             tty_fprintf (fp, _("expires: %s"), expirestr_from_pk (pk));
3193           tty_fprintf (fp, "  ");
3194           tty_fprintf (fp, _("usage: %s"), usagestr_from_pk (pk, 1));
3195           tty_fprintf (fp, "\n");
3196
3197           if (serialno)
3198             {
3199               /* The agent told us that a secret key is available and
3200                  that it has been stored on a card.  */
3201               tty_fprintf (fp, "%*s%s", opt.legacy_list_mode? 21:5, "",
3202                            _("card-no: "));
3203               if (strlen (serialno) == 32
3204                   && !strncmp (serialno, "D27600012401", 12))
3205                 {
3206                   /* This is an OpenPGP card.  Print the relevant part.  */
3207                   /* Example: D2760001240101010001000003470000 */
3208                   /*                          xxxxyyyyyyyy     */
3209                   tty_fprintf (fp, "%.*s %.*s\n",
3210                                4, serialno+16, 8, serialno+20);
3211                 }
3212               else
3213                 tty_fprintf (fp, "%s\n", serialno);
3214
3215             }
3216           else if (pk->seckey_info
3217               && pk->seckey_info->is_protected
3218               && pk->seckey_info->s2k.mode == 1002)
3219             {
3220               /* FIXME: Check wether this code path is still used.  */
3221               tty_fprintf (fp, "%*s%s", opt.legacy_list_mode? 21:5, "",
3222                            _("card-no: "));
3223               if (pk->seckey_info->ivlen == 16
3224                   && !memcmp (pk->seckey_info->iv,
3225                               "\xD2\x76\x00\x01\x24\x01", 6))
3226                 {
3227                   /* This is an OpenPGP card. */
3228                   for (i = 8; i < 14; i++)
3229                     {
3230                       if (i == 10)
3231                         tty_fprintf (fp, " ");
3232                       tty_fprintf (fp, "%02X", pk->seckey_info->iv[i]);
3233                     }
3234                 }
3235               else
3236                 {
3237                   /* Unknown card: Print all. */
3238                   for (i = 0; i < pk->seckey_info->ivlen; i++)
3239                     tty_fprintf (fp, "%02X", pk->seckey_info->iv[i]);
3240                 }
3241               tty_fprintf (fp, "\n");
3242             }
3243
3244           if (node->pkt->pkttype == PKT_PUBLIC_KEY
3245               || node->pkt->pkttype == PKT_SECRET_KEY)
3246             {
3247               if (opt.trust_model != TM_ALWAYS)
3248                 {
3249                   tty_fprintf (fp, "%*s",
3250                                opt.legacy_list_mode?
3251                                ((int) keystrlen () + 13):5, "");
3252                   /* Ownertrust is only meaningful for the PGP or
3253                      classic trust models, or PGP combined with TOFU */
3254                   if (opt.trust_model == TM_PGP
3255                       || opt.trust_model == TM_CLASSIC
3256                       || opt.trust_model == TM_TOFU_PGP)
3257                     {
3258                       int width = 14 - strlen (otrust);
3259                       if (width <= 0)
3260                         width = 1;
3261                       tty_fprintf (fp, _("trust: %s"), otrust);
3262                       tty_fprintf (fp, "%*s", width, "");
3263                     }
3264
3265                   tty_fprintf (fp, _("validity: %s"), trust);
3266                   tty_fprintf (fp, "\n");
3267                 }
3268               if (node->pkt->pkttype == PKT_PUBLIC_KEY
3269                   && (get_ownertrust (pk) & TRUST_FLAG_DISABLED))
3270                 {
3271                   tty_fprintf (fp, "*** ");
3272                   tty_fprintf (fp, _("This key has been disabled"));
3273                   tty_fprintf (fp, "\n");
3274                 }
3275             }
3276
3277           if ((node->pkt->pkttype == PKT_PUBLIC_KEY
3278                || node->pkt->pkttype == PKT_SECRET_KEY) && with_fpr)
3279             {
3280               print_fingerprint (fp, pk, 2);
3281               tty_fprintf (fp, "\n");
3282             }
3283         }
3284     }
3285
3286   show_names (fp,
3287               keyblock, primary, only_marked ? NODFLG_MARK_A : 0, with_prefs);
3288
3289   if (do_warn && !nowarn)
3290     tty_fprintf (fp, _("Please note that the shown key validity"
3291                        " is not necessarily correct\n"
3292                        "unless you restart the program.\n"));
3293
3294   xfree (serialno);
3295 }
3296
3297
3298 /* Display basic key information.  This function is suitable to show
3299    information on the key without any dependencies on the trustdb or
3300    any other internal GnuPG stuff.  KEYBLOCK may either be a public or
3301    a secret key.  This function may be called with KEYBLOCK containing
3302    secret keys and thus the printing of "pub" vs. "sec" does only
3303    depend on the packet type and not by checking with gpg-agent.  */
3304 void
3305 show_basic_key_info (KBNODE keyblock)
3306 {
3307   KBNODE node;
3308   int i;
3309   char pkstrbuf[PUBKEY_STRING_SIZE];
3310
3311   /* The primary key */
3312   for (node = keyblock; node; node = node->next)
3313     {
3314       if (node->pkt->pkttype == PKT_PUBLIC_KEY
3315           || node->pkt->pkttype == PKT_SECRET_KEY)
3316         {
3317           PKT_public_key *pk = node->pkt->pkt.public_key;
3318
3319           /* Note, we use the same format string as in other show
3320              functions to make the translation job easier. */
3321           tty_printf ("%s  %s/%s  ",
3322                       node->pkt->pkttype == PKT_PUBLIC_KEY ? "pub" :
3323                       node->pkt->pkttype == PKT_PUBLIC_SUBKEY ? "sub" :
3324                       node->pkt->pkttype == PKT_SECRET_KEY ? "sec" :"ssb",
3325                       pubkey_string (pk, pkstrbuf, sizeof pkstrbuf),
3326                       keystr_from_pk (pk));
3327           tty_printf (_("created: %s"), datestr_from_pk (pk));
3328           tty_printf ("  ");
3329           tty_printf (_("expires: %s"), expirestr_from_pk (pk));
3330           tty_printf ("\n");
3331           print_fingerprint (NULL, pk, 3);
3332           tty_printf ("\n");
3333         }
3334     }
3335
3336   /* The user IDs. */
3337   for (i = 0, node = keyblock; node; node = node->next)
3338     {
3339       if (node->pkt->pkttype == PKT_USER_ID)
3340         {
3341           PKT_user_id *uid = node->pkt->pkt.user_id;
3342           ++i;
3343
3344           tty_printf ("     ");
3345           if (uid->is_revoked)
3346             tty_printf ("[%s] ", _("revoked"));
3347           else if (uid->is_expired)
3348             tty_printf ("[%s] ", _("expired"));
3349           tty_print_utf8_string (uid->name, uid->len);
3350           tty_printf ("\n");
3351         }
3352     }
3353 }
3354
3355
3356 static void
3357 show_key_and_fingerprint (kbnode_t keyblock, int with_subkeys)
3358 {
3359   kbnode_t node;
3360   PKT_public_key *pk = NULL;
3361   char pkstrbuf[PUBKEY_STRING_SIZE];
3362
3363   for (node = keyblock; node; node = node->next)
3364     {
3365       if (node->pkt->pkttype == PKT_PUBLIC_KEY)
3366         {
3367           pk = node->pkt->pkt.public_key;
3368           tty_printf ("pub   %s/%s %s ",
3369                       pubkey_string (pk, pkstrbuf, sizeof pkstrbuf),
3370                       keystr_from_pk(pk),
3371                       datestr_from_pk (pk));
3372         }
3373       else if (node->pkt->pkttype == PKT_USER_ID)
3374         {
3375           PKT_user_id *uid = node->pkt->pkt.user_id;
3376           tty_print_utf8_string (uid->name, uid->len);
3377           break;
3378         }
3379     }
3380   tty_printf ("\n");
3381   if (pk)
3382     print_fingerprint (NULL, pk, 2);
3383   if (with_subkeys)
3384     {
3385       for (node = keyblock; node; node = node->next)
3386         {
3387           if (node->pkt->pkttype == PKT_PUBLIC_SUBKEY)
3388             {
3389               pk = node->pkt->pkt.public_key;
3390               tty_printf ("sub   %s/%s %s [%s]\n",
3391                           pubkey_string (pk, pkstrbuf, sizeof pkstrbuf),
3392                           keystr_from_pk(pk),
3393                           datestr_from_pk (pk),
3394                           usagestr_from_pk (pk, 0));
3395
3396               print_fingerprint (NULL, pk, 4);
3397             }
3398         }
3399     }
3400 }
3401
3402
3403 /* Show a listing of the primary and its subkeys along with their
3404    keygrips.  */
3405 static void
3406 show_key_and_grip (kbnode_t keyblock)
3407 {
3408   kbnode_t node;
3409   PKT_public_key *pk = NULL;
3410   char pkstrbuf[PUBKEY_STRING_SIZE];
3411   char *hexgrip;
3412
3413   for (node = keyblock; node; node = node->next)
3414     {
3415       if (node->pkt->pkttype == PKT_PUBLIC_KEY
3416           || node->pkt->pkttype == PKT_PUBLIC_SUBKEY)
3417         {
3418           pk = node->pkt->pkt.public_key;
3419           tty_printf ("%s   %s/%s %s [%s]\n",
3420                       node->pkt->pkttype == PKT_PUBLIC_KEY? "pub":"sub",
3421                       pubkey_string (pk, pkstrbuf, sizeof pkstrbuf),
3422                       keystr_from_pk(pk),
3423                       datestr_from_pk (pk),
3424                       usagestr_from_pk (pk, 0));
3425
3426           if (!hexkeygrip_from_pk (pk, &hexgrip))
3427             {
3428               tty_printf ("      Keygrip: %s\n", hexgrip);
3429               xfree (hexgrip);
3430             }
3431         }
3432     }
3433 }
3434
3435
3436 /* Show a warning if no uids on the key have the primary uid flag
3437    set. */
3438 static void
3439 no_primary_warning (KBNODE keyblock)
3440 {
3441   KBNODE node;
3442   int have_primary = 0, uid_count = 0;
3443
3444   /* TODO: if we ever start behaving differently with a primary or
3445      non-primary attribute ID, we will need to check for attributes
3446      here as well. */
3447
3448   for (node = keyblock; node; node = node->next)
3449     {
3450       if (node->pkt->pkttype == PKT_USER_ID
3451           && node->pkt->pkt.user_id->attrib_data == NULL)
3452         {
3453           uid_count++;
3454
3455           if (node->pkt->pkt.user_id->is_primary == 2)
3456             {
3457               have_primary = 1;
3458               break;
3459             }
3460         }
3461     }
3462
3463   if (uid_count > 1 && !have_primary)
3464     log_info (_
3465               ("WARNING: no user ID has been marked as primary.  This command"
3466                " may\n              cause a different user ID to become"
3467                " the assumed primary.\n"));
3468 }
3469
3470
3471 /* Print a warning if the latest encryption subkey expires soon.  This
3472    function is called after the expire data of the primary key has
3473    been changed.  */
3474 static void
3475 subkey_expire_warning (kbnode_t keyblock)
3476 {
3477   u32 curtime = make_timestamp ();
3478   kbnode_t node;
3479   PKT_public_key *pk;
3480   /* u32 mainexpire = 0; */
3481   u32 subexpire = 0;
3482   u32 latest_date = 0;
3483
3484   for (node = keyblock; node; node = node->next)
3485     {
3486       /* if (node->pkt->pkttype == PKT_PUBLIC_KEY) */
3487       /*   { */
3488       /*     pk = node->pkt->pkt.public_key; */
3489       /*     mainexpire = pk->expiredate; */
3490       /*   } */
3491
3492       if (node->pkt->pkttype != PKT_PUBLIC_SUBKEY)
3493         continue;
3494       pk = node->pkt->pkt.public_key;
3495
3496       if (!pk->flags.valid)
3497         continue;
3498       if (pk->flags.revoked)
3499         continue;
3500       if (pk->timestamp > curtime)
3501         continue; /* Ignore future keys.  */
3502       if (!(pk->pubkey_usage & PUBKEY_USAGE_ENC))
3503         continue; /* Not an encryption key.  */
3504
3505       if (pk->timestamp > latest_date || (!pk->timestamp && !latest_date))
3506         {
3507           latest_date = pk->timestamp;
3508           subexpire = pk->expiredate;
3509         }
3510     }
3511
3512   if (!subexpire)
3513     return;  /* No valid subkey with an expiration time.  */
3514
3515   if (curtime + (10*86400) > subexpire)
3516     {
3517       log_info (_("WARNING: Your encryption subkey expires soon.\n"));
3518       log_info (_("You may want to change its expiration date too.\n"));
3519     }
3520 }
3521
3522
3523 /*
3524  * Ask for a new user id, add the self-signature, and update the
3525  * keyblock.  If UIDSTRING is not NULL the user ID is generated
3526  * unattended using that string.  UIDSTRING is expected to be utf-8
3527  * encoded and white space trimmed.  Returns true if there is a new
3528  * user id.
3529  */
3530 static int
3531 menu_adduid (kbnode_t pub_keyblock, int photo, const char *photo_name,
3532              const char *uidstring)
3533 {
3534   PKT_user_id *uid;
3535   PKT_public_key *pk = NULL;
3536   PKT_signature *sig = NULL;
3537   PACKET *pkt;
3538   KBNODE node;
3539   KBNODE pub_where = NULL;
3540   gpg_error_t err;
3541
3542   if (photo && uidstring)
3543     return 0;  /* Not allowed.  */
3544
3545   for (node = pub_keyblock; node; pub_where = node, node = node->next)
3546     {
3547       if (node->pkt->pkttype == PKT_PUBLIC_KEY)
3548         pk = node->pkt->pkt.public_key;
3549       else if (node->pkt->pkttype == PKT_PUBLIC_SUBKEY)
3550         break;
3551     }
3552   if (!node) /* No subkey.  */
3553     pub_where = NULL;
3554   assert (pk);
3555
3556   if (photo)
3557     {
3558       int hasattrib = 0;
3559
3560       for (node = pub_keyblock; node; node = node->next)
3561         if (node->pkt->pkttype == PKT_USER_ID &&
3562             node->pkt->pkt.user_id->attrib_data != NULL)
3563           {
3564             hasattrib = 1;
3565             break;
3566           }
3567
3568       /* It is legal but bad for compatibility to add a photo ID to a
3569          v3 key as it means that PGP2 will not be able to use that key
3570          anymore.  Also, PGP may not expect a photo on a v3 key.
3571          Don't bother to ask this if the key already has a photo - any
3572          damage has already been done at that point. -dms */
3573       if (pk->version == 3 && !hasattrib)
3574         {
3575           if (opt.expert)
3576             {
3577               tty_printf (_("WARNING: This is a PGP2-style key.  "
3578                             "Adding a photo ID may cause some versions\n"
3579                             "         of PGP to reject this key.\n"));
3580
3581               if (!cpr_get_answer_is_yes ("keyedit.v3_photo.okay",
3582                                           _("Are you sure you still want "
3583                                             "to add it? (y/N) ")))
3584                 return 0;
3585             }
3586           else
3587             {
3588               tty_printf (_("You may not add a photo ID to "
3589                             "a PGP2-style key.\n"));
3590               return 0;
3591             }
3592         }
3593
3594       uid = generate_photo_id (pk, photo_name);
3595     }
3596   else
3597     uid = generate_user_id (pub_keyblock, uidstring);
3598   if (!uid)
3599     {
3600       if (uidstring)
3601         log_error ("%s", _("Such a user ID already exists on this key!\n"));
3602       return 0;
3603     }
3604
3605   err = make_keysig_packet (&sig, pk, uid, NULL, pk, 0x13, 0, 0, 0,
3606                             keygen_add_std_prefs, pk, NULL);
3607   if (err)
3608     {
3609       write_status_error ("keysig", err);
3610       log_error ("signing failed: %s\n", gpg_strerror (err));
3611       free_user_id (uid);
3612       return 0;
3613     }
3614
3615   /* Insert/append to public keyblock */
3616   pkt = xmalloc_clear (sizeof *pkt);
3617   pkt->pkttype = PKT_USER_ID;
3618   pkt->pkt.user_id = uid;
3619   node = new_kbnode (pkt);
3620   if (pub_where)
3621     insert_kbnode (pub_where, node, 0);
3622   else
3623     add_kbnode (pub_keyblock, node);
3624   pkt = xmalloc_clear (sizeof *pkt);
3625   pkt->pkttype = PKT_SIGNATURE;
3626   pkt->pkt.signature = copy_signature (NULL, sig);
3627   if (pub_where)
3628     insert_kbnode (node, new_kbnode (pkt), 0);
3629   else
3630     add_kbnode (pub_keyblock, new_kbnode (pkt));
3631   return 1;
3632 }
3633
3634
3635 /*
3636  * Remove all selected userids from the keyring
3637  */
3638 static void
3639 menu_deluid (KBNODE pub_keyblock)
3640 {
3641   KBNODE node;
3642   int selected = 0;
3643
3644   for (node = pub_keyblock; node; node = node->next)
3645     {
3646       if (node->pkt->pkttype == PKT_USER_ID)
3647         {
3648           selected = node->flag & NODFLG_SELUID;
3649           if (selected)
3650             {
3651               /* Only cause a trust update if we delete a
3652                  non-revoked user id */
3653               if (!node->pkt->pkt.user_id->is_revoked)
3654                 update_trust = 1;
3655               delete_kbnode (node);
3656             }
3657         }
3658       else if (selected && node->pkt->pkttype == PKT_SIGNATURE)
3659         delete_kbnode (node);
3660       else if (node->pkt->pkttype == PKT_PUBLIC_SUBKEY)
3661         selected = 0;
3662     }
3663   commit_kbnode (&pub_keyblock);
3664 }
3665
3666
3667 static int
3668 menu_delsig (KBNODE pub_keyblock)
3669 {
3670   KBNODE node;
3671   PKT_user_id *uid = NULL;
3672   int changed = 0;
3673
3674   for (node = pub_keyblock; node; node = node->next)
3675     {
3676       if (node->pkt->pkttype == PKT_USER_ID)
3677         {
3678           uid = (node->flag & NODFLG_SELUID) ? node->pkt->pkt.user_id : NULL;
3679         }
3680       else if (uid && node->pkt->pkttype == PKT_SIGNATURE)
3681         {
3682           int okay, valid, selfsig, inv_sig, no_key, other_err;
3683
3684           tty_printf ("uid  ");
3685           tty_print_utf8_string (uid->name, uid->len);
3686           tty_printf ("\n");
3687
3688           okay = inv_sig = no_key = other_err = 0;
3689           if (opt.with_colons)
3690             valid = print_and_check_one_sig_colon (pub_keyblock, node,
3691                                                    &inv_sig, &no_key,
3692                                                    &other_err, &selfsig, 1);
3693           else
3694             valid = print_and_check_one_sig (pub_keyblock, node,
3695                                              &inv_sig, &no_key, &other_err,
3696                                              &selfsig, 1, 0);
3697
3698           if (valid)
3699             {
3700               okay = cpr_get_answer_yes_no_quit
3701                 ("keyedit.delsig.valid",
3702                  _("Delete this good signature? (y/N/q)"));
3703
3704               /* Only update trust if we delete a good signature.
3705                  The other two cases do not affect trust. */
3706               if (okay)
3707                 update_trust = 1;
3708             }
3709           else if (inv_sig || other_err)
3710             okay = cpr_get_answer_yes_no_quit
3711               ("keyedit.delsig.invalid",
3712                _("Delete this invalid signature? (y/N/q)"));
3713           else if (no_key)
3714             okay = cpr_get_answer_yes_no_quit
3715               ("keyedit.delsig.unknown",
3716                _("Delete this unknown signature? (y/N/q)"));
3717
3718           if (okay == -1)
3719             break;
3720           if (okay && selfsig
3721               && !cpr_get_answer_is_yes
3722               ("keyedit.delsig.selfsig",
3723                _("Really delete this self-signature? (y/N)")))
3724             okay = 0;
3725           if (okay)
3726             {
3727               delete_kbnode (node);
3728               changed++;
3729             }
3730
3731         }
3732       else if (node->pkt->pkttype == PKT_PUBLIC_SUBKEY)
3733         uid = NULL;
3734     }
3735
3736   if (changed)
3737     {
3738       commit_kbnode (&pub_keyblock);
3739       tty_printf (changed == 1 ? _("Deleted %d signature.\n")
3740                   : _("Deleted %d signatures.\n"), changed);
3741     }
3742   else
3743     tty_printf (_("Nothing deleted.\n"));
3744
3745   return changed;
3746 }
3747
3748
3749 static int
3750 menu_clean (KBNODE keyblock, int self_only)
3751 {
3752   KBNODE uidnode;
3753   int modified = 0, select_all = !count_selected_uids (keyblock);
3754
3755   for (uidnode = keyblock->next;
3756        uidnode && uidnode->pkt->pkttype != PKT_PUBLIC_SUBKEY;
3757        uidnode = uidnode->next)
3758     {
3759       if (uidnode->pkt->pkttype == PKT_USER_ID
3760           && (uidnode->flag & NODFLG_SELUID || select_all))
3761         {
3762           int uids = 0, sigs = 0;
3763           char *user = utf8_to_native (uidnode->pkt->pkt.user_id->name,
3764                                        uidnode->pkt->pkt.user_id->len,
3765                                        0);
3766
3767           clean_one_uid (keyblock, uidnode, opt.verbose, self_only, &uids,
3768                          &sigs);
3769           if (uids)
3770             {
3771               const char *reason;
3772
3773               if (uidnode->pkt->pkt.user_id->is_revoked)
3774                 reason = _("revoked");
3775               else if (uidnode->pkt->pkt.user_id->is_expired)
3776                 reason = _("expired");
3777               else
3778                 reason = _("invalid");
3779
3780               tty_printf (_("User ID \"%s\" compacted: %s\n"), user, reason);
3781
3782               modified = 1;
3783             }
3784           else if (sigs)
3785             {
3786               tty_printf (sigs == 1 ?
3787                           _("User ID \"%s\": %d signature removed\n") :
3788                           _("User ID \"%s\": %d signatures removed\n"),
3789                           user, sigs);
3790
3791               modified = 1;
3792             }
3793           else
3794             {
3795               tty_printf (self_only == 1 ?
3796                           _("User ID \"%s\": already minimized\n") :
3797                           _("User ID \"%s\": already clean\n"), user);
3798             }
3799
3800           xfree (user);
3801         }
3802     }
3803
3804   return modified;
3805 }
3806
3807
3808 /*
3809  * Remove some of the secondary keys
3810  */
3811 static void
3812 menu_delkey (KBNODE pub_keyblock)
3813 {
3814   KBNODE node;
3815   int selected = 0;
3816
3817   for (node = pub_keyblock; node; node = node->next)
3818     {
3819       if (node->pkt->pkttype == PKT_PUBLIC_SUBKEY)
3820         {
3821           selected = node->flag & NODFLG_SELKEY;
3822           if (selected)
3823             delete_kbnode (node);
3824         }
3825       else if (selected && node->pkt->pkttype == PKT_SIGNATURE)
3826         delete_kbnode (node);
3827       else
3828         selected = 0;
3829     }
3830   commit_kbnode (&pub_keyblock);
3831
3832   /* No need to set update_trust here since signing keys are no
3833      longer used to certify other keys, so there is no change in
3834      trust when revoking/removing them.   */
3835 }
3836
3837
3838 /*
3839  * Ask for a new revoker, create the self-signature and put it into
3840  * the keyblock.  Returns true if there is a new revoker.
3841  */
3842 static int
3843 menu_addrevoker (ctrl_t ctrl, kbnode_t pub_keyblock, int sensitive)
3844 {
3845   PKT_public_key *pk = NULL;
3846   PKT_public_key *revoker_pk = NULL;
3847   PKT_signature *sig = NULL;
3848   PACKET *pkt;
3849   struct revocation_key revkey;
3850   size_t fprlen;
3851   int rc;
3852
3853   assert (pub_keyblock->pkt->pkttype == PKT_PUBLIC_KEY);
3854
3855   pk = pub_keyblock->pkt->pkt.public_key;
3856
3857   if (pk->numrevkeys == 0 && pk->version == 3)
3858     {
3859       /* It is legal but bad for compatibility to add a revoker to a
3860          v3 key as it means that PGP2 will not be able to use that key
3861          anymore.  Also, PGP may not expect a revoker on a v3 key.
3862          Don't bother to ask this if the key already has a revoker -
3863          any damage has already been done at that point. -dms */
3864       if (opt.expert)
3865         {
3866           tty_printf (_("WARNING: This is a PGP 2.x-style key.  "
3867                         "Adding a designated revoker may cause\n"
3868                         "         some versions of PGP to reject this key.\n"));
3869
3870           if (!cpr_get_answer_is_yes ("keyedit.v3_revoker.okay",
3871                                       _("Are you sure you still want "
3872                                         "to add it? (y/N) ")))
3873             return 0;
3874         }
3875       else
3876         {
3877           tty_printf (_("You may not add a designated revoker to "
3878                         "a PGP 2.x-style key.\n"));
3879           return 0;
3880         }
3881     }
3882
3883   for (;;)
3884     {
3885       char *answer;
3886
3887       free_public_key (revoker_pk);
3888       revoker_pk = xmalloc_clear (sizeof (*revoker_pk));
3889
3890       tty_printf ("\n");
3891
3892       answer = cpr_get_utf8
3893         ("keyedit.add_revoker",
3894          _("Enter the user ID of the designated revoker: "));
3895       if (answer[0] == '\0' || answer[0] == CONTROL_D)
3896         {
3897           xfree (answer);
3898           goto fail;
3899         }
3900
3901       /* Note that I'm requesting CERT here, which usually implies
3902          primary keys only, but some casual testing shows that PGP and
3903          GnuPG both can handle a designated revocation from a subkey. */
3904       revoker_pk->req_usage = PUBKEY_USAGE_CERT;
3905       rc = get_pubkey_byname (ctrl, NULL, revoker_pk, answer, NULL, NULL, 1, 1);
3906       if (r