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