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