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