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