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