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