gpg: Remove the edit-key toggle command.
[gnupg.git] / g10 / keyedit.c
1 /* keyedit.c - Edit properties of a key
2  * Copyright (C) 1998-2010 Free Software Foundation, Inc.
3  * Copyright (C) 1998-2015 Werner Koch
4  *
5  * This file is part of GnuPG.
6  *
7  * GnuPG is free software; you can redistribute it and/or modify
8  * it under the terms of the GNU General Public License as published by
9  * the Free Software Foundation; either version 3 of the License, or
10  * (at your option) any later version.
11  *
12  * GnuPG is distributed in the hope that it will be useful,
13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15  * GNU General Public License for more details.
16  *
17  * You should have received a copy of the GNU General Public License
18  * along with this program; if not, see <http://www.gnu.org/licenses/>.
19  */
20
21 #include <config.h>
22 #include <stdio.h>
23 #include <stdlib.h>
24 #include <string.h>
25 #include <errno.h>
26 #include <assert.h>
27 #include <ctype.h>
28 #ifdef HAVE_LIBREADLINE
29 # define GNUPG_LIBREADLINE_H_INCLUDED
30 # include <readline/readline.h>
31 #endif
32
33 #include "gpg.h"
34 #include "options.h"
35 #include "packet.h"
36 #include "status.h"
37 #include "iobuf.h"
38 #include "keydb.h"
39 #include "photoid.h"
40 #include "util.h"
41 #include "main.h"
42 #include "trustdb.h"
43 #include "filter.h"
44 #include "ttyio.h"
45 #include "status.h"
46 #include "i18n.h"
47 #include "keyserver-internal.h"
48 #include "call-agent.h"
49
50 static void show_prefs (PKT_user_id * uid, PKT_signature * selfsig,
51                         int verbose);
52 static void show_names (estream_t fp, KBNODE keyblock, PKT_public_key * pk,
53                         unsigned int flag, int with_prefs);
54 static void show_key_with_all_names (estream_t fp,
55                                      KBNODE keyblock, int only_marked,
56                                      int with_revoker, int with_fpr,
57                                      int with_subkeys, int with_prefs,
58                                      int nowarn);
59 static void show_key_and_fingerprint (KBNODE keyblock);
60 static void subkey_expire_warning (kbnode_t keyblock);
61 static int menu_adduid (KBNODE keyblock, int photo, const char *photo_name,
62                         const char *uidstr);
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                      ? GPGRT_LOG_INFO : GPGRT_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_key_signature_order (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 /* Fix various problems in the keyblock.  Returns true if the keyblock
1225    was changed.  Note that a pointer to the keyblock must be given and
1226    the function may change it (i.e. replacing the first node).  */
1227 static int
1228 fix_keyblock (kbnode_t *keyblockp)
1229 {
1230   int changed = 0;
1231
1232   if (fix_key_signature_order (*keyblockp))
1233     changed++;
1234   if (collapse_uids (keyblockp))
1235     changed++;
1236   reorder_keyblock (*keyblockp);
1237   /* If we modified the keyblock, make sure the flags are right. */
1238   if (changed)
1239     merge_keys_and_selfsig (*keyblockp);
1240
1241   return changed;
1242 }
1243
1244
1245 static int
1246 parse_sign_type (const char *str, int *localsig, int *nonrevokesig,
1247                  int *trustsig)
1248 {
1249   const char *p = str;
1250
1251   while (*p)
1252     {
1253       if (ascii_strncasecmp (p, "l", 1) == 0)
1254         {
1255           *localsig = 1;
1256           p++;
1257         }
1258       else if (ascii_strncasecmp (p, "nr", 2) == 0)
1259         {
1260           *nonrevokesig = 1;
1261           p += 2;
1262         }
1263       else if (ascii_strncasecmp (p, "t", 1) == 0)
1264         {
1265           *trustsig = 1;
1266           p++;
1267         }
1268       else
1269         return 0;
1270     }
1271
1272   return 1;
1273 }
1274
1275
1276 \f
1277 /*
1278  * Menu driven key editor.  If seckey_check is true, then a secret key
1279  * that matches username will be looked for.  If it is false, not all
1280  * commands will be available.
1281  *
1282  * Note: to keep track of certain selections we use node->mark MARKBIT_xxxx.
1283  */
1284
1285 /* Need an SK for this command */
1286 #define KEYEDIT_NEED_SK 1
1287 /* Cannot be viewing the SK for this command */
1288 #define KEYEDIT_NOT_SK  2
1289 /* Must be viewing the SK for this command */
1290 #define KEYEDIT_ONLY_SK 4
1291 /* Match the tail of the string */
1292 #define KEYEDIT_TAIL_MATCH 8
1293
1294 enum cmdids
1295 {
1296   cmdNONE = 0,
1297   cmdQUIT, cmdHELP, cmdFPR, cmdLIST, cmdSELUID, cmdCHECK, cmdSIGN,
1298   cmdREVSIG, cmdREVKEY, cmdREVUID, cmdDELSIG, cmdPRIMARY, cmdDEBUG,
1299   cmdSAVE, cmdADDUID, cmdADDPHOTO, cmdDELUID, cmdADDKEY, cmdDELKEY,
1300   cmdADDREVOKER, cmdTOGGLE, cmdSELKEY, cmdPASSWD, cmdTRUST, cmdPREF,
1301   cmdEXPIRE, cmdBACKSIGN,
1302 #ifndef NO_TRUST_MODELS
1303   cmdENABLEKEY, cmdDISABLEKEY,
1304 #endif /*!NO_TRUST_MODELS*/
1305   cmdSHOWPREF,
1306   cmdSETPREF, cmdPREFKS, cmdNOTATION, cmdINVCMD, cmdSHOWPHOTO, cmdUPDTRUST,
1307   cmdCHKTRUST, cmdADDCARDKEY, cmdKEYTOCARD, cmdBKUPTOCARD, cmdCHECKBKUPKEY,
1308   cmdCLEAN, cmdMINIMIZE, cmdNOP
1309 };
1310
1311 static struct
1312 {
1313   const char *name;
1314   enum cmdids id;
1315   int flags;
1316   const char *desc;
1317 } cmds[] =
1318 {
1319   { "quit", cmdQUIT, 0, N_("quit this menu")},
1320   { "q", cmdQUIT, 0, NULL},
1321   { "save", cmdSAVE, 0, N_("save and quit")},
1322   { "help", cmdHELP, 0, N_("show this help")},
1323   { "?", cmdHELP, 0, NULL},
1324   { "fpr", cmdFPR, 0, N_("show key fingerprint")},
1325   { "list", cmdLIST, 0, N_("list key and user IDs")},
1326   { "l", cmdLIST, 0, NULL},
1327   { "uid", cmdSELUID, 0, N_("select user ID N")},
1328   { "key", cmdSELKEY, 0, N_("select subkey N")},
1329   { "check", cmdCHECK, 0, N_("check signatures")},
1330   { "c", cmdCHECK, 0, NULL},
1331   { "cross-certify", cmdBACKSIGN, KEYEDIT_NOT_SK | KEYEDIT_NEED_SK, NULL},
1332   { "backsign", cmdBACKSIGN, KEYEDIT_NOT_SK | KEYEDIT_NEED_SK, NULL},
1333   { "sign", cmdSIGN, KEYEDIT_NOT_SK | KEYEDIT_TAIL_MATCH,
1334     N_("sign selected user IDs [* see below for related commands]")},
1335   { "s", cmdSIGN, KEYEDIT_NOT_SK, NULL},
1336     /* "lsign" and friends will never match since "sign" comes first
1337        and it is a tail match.  They are just here so they show up in
1338        the help menu. */
1339   { "lsign", cmdNOP, 0, N_("sign selected user IDs locally")},
1340   { "tsign", cmdNOP, 0, N_("sign selected user IDs with a trust signature")},
1341   { "nrsign", cmdNOP, 0,
1342     N_("sign selected user IDs with a non-revocable signature")},
1343   { "debug", cmdDEBUG, 0, NULL},
1344   { "adduid", cmdADDUID, KEYEDIT_NOT_SK | KEYEDIT_NEED_SK, N_("add a user ID")},
1345   { "addphoto", cmdADDPHOTO, KEYEDIT_NOT_SK | KEYEDIT_NEED_SK,
1346     N_("add a photo ID")},
1347   { "deluid", cmdDELUID, KEYEDIT_NOT_SK, N_("delete selected user IDs")},
1348     /* delphoto is really deluid in disguise */
1349   { "delphoto", cmdDELUID, KEYEDIT_NOT_SK, NULL},
1350   { "addkey", cmdADDKEY, KEYEDIT_NOT_SK | KEYEDIT_NEED_SK, N_("add a subkey")},
1351 #ifdef ENABLE_CARD_SUPPORT
1352   { "addcardkey", cmdADDCARDKEY, KEYEDIT_NOT_SK | KEYEDIT_NEED_SK,
1353     N_("add a key to a smartcard")},
1354   { "keytocard", cmdKEYTOCARD, KEYEDIT_NEED_SK | KEYEDIT_ONLY_SK,
1355     N_("move a key to a smartcard")},
1356   { "bkuptocard", cmdBKUPTOCARD, KEYEDIT_NEED_SK | KEYEDIT_ONLY_SK,
1357     N_("move a backup key to a smartcard")},
1358   { "checkbkupkey", cmdCHECKBKUPKEY, KEYEDIT_NEED_SK | KEYEDIT_ONLY_SK, NULL},
1359 #endif /*ENABLE_CARD_SUPPORT */
1360   { "delkey", cmdDELKEY, KEYEDIT_NOT_SK, N_("delete selected subkeys")},
1361   { "addrevoker", cmdADDREVOKER, KEYEDIT_NOT_SK | KEYEDIT_NEED_SK,
1362     N_("add a revocation key")},
1363   { "delsig", cmdDELSIG, KEYEDIT_NOT_SK,
1364     N_("delete signatures from the selected user IDs")},
1365   { "expire", cmdEXPIRE, KEYEDIT_NOT_SK | KEYEDIT_NEED_SK,
1366     N_("change the expiration date for the key or selected subkeys")},
1367   { "primary", cmdPRIMARY, KEYEDIT_NOT_SK | KEYEDIT_NEED_SK,
1368     N_("flag the selected user ID as primary")},
1369   { "toggle", cmdTOGGLE, KEYEDIT_NEED_SK, NULL},  /* Dummy command.  */
1370   { "t", cmdTOGGLE, KEYEDIT_NEED_SK, NULL},
1371   { "pref", cmdPREF, KEYEDIT_NOT_SK, N_("list preferences (expert)")},
1372   { "showpref", cmdSHOWPREF, KEYEDIT_NOT_SK, N_("list preferences (verbose)")},
1373   { "setpref", cmdSETPREF, KEYEDIT_NOT_SK | KEYEDIT_NEED_SK,
1374     N_("set preference list for the selected user IDs")},
1375   { "updpref", cmdSETPREF, KEYEDIT_NOT_SK | KEYEDIT_NEED_SK, NULL},
1376   { "keyserver", cmdPREFKS, KEYEDIT_NOT_SK | KEYEDIT_NEED_SK,
1377     N_("set the preferred keyserver URL for the selected user IDs")},
1378   { "notation", cmdNOTATION, KEYEDIT_NOT_SK | KEYEDIT_NEED_SK,
1379     N_("set a notation for the selected user IDs")},
1380   { "passwd", cmdPASSWD, KEYEDIT_NOT_SK | KEYEDIT_NEED_SK,
1381     N_("change the passphrase")},
1382   { "password", cmdPASSWD, KEYEDIT_NOT_SK | KEYEDIT_NEED_SK, NULL},
1383 #ifndef NO_TRUST_MODELS
1384   { "trust", cmdTRUST, KEYEDIT_NOT_SK, N_("change the ownertrust")},
1385 #endif /*!NO_TRUST_MODELS*/
1386   { "revsig", cmdREVSIG, KEYEDIT_NOT_SK,
1387     N_("revoke signatures on the selected user IDs")},
1388   { "revuid", cmdREVUID, KEYEDIT_NOT_SK | KEYEDIT_NEED_SK,
1389     N_("revoke selected user IDs")},
1390   { "revphoto", cmdREVUID, KEYEDIT_NOT_SK | KEYEDIT_NEED_SK, NULL},
1391   { "revkey", cmdREVKEY, KEYEDIT_NOT_SK | KEYEDIT_NEED_SK,
1392     N_("revoke key or selected subkeys")},
1393 #ifndef NO_TRUST_MODELS
1394   { "enable", cmdENABLEKEY, KEYEDIT_NOT_SK, N_("enable key")},
1395   { "disable", cmdDISABLEKEY, KEYEDIT_NOT_SK, N_("disable key")},
1396 #endif /*!NO_TRUST_MODELS*/
1397   { "showphoto", cmdSHOWPHOTO, 0, N_("show selected photo IDs")},
1398   { "clean", cmdCLEAN, KEYEDIT_NOT_SK,
1399     N_("compact unusable user IDs and remove unusable signatures from key")},
1400   { "minimize", cmdMINIMIZE, KEYEDIT_NOT_SK,
1401     N_("compact unusable user IDs and remove all signatures from key")},
1402
1403   { NULL, cmdNONE, 0, NULL}
1404 };
1405
1406
1407 \f
1408 #ifdef HAVE_LIBREADLINE
1409
1410 /*
1411    These two functions are used by readline for command completion.
1412  */
1413
1414 static char *
1415 command_generator (const char *text, int state)
1416 {
1417   static int list_index, len;
1418   const char *name;
1419
1420   /* If this is a new word to complete, initialize now.  This includes
1421      saving the length of TEXT for efficiency, and initializing the
1422      index variable to 0. */
1423   if (!state)
1424     {
1425       list_index = 0;
1426       len = strlen (text);
1427     }
1428
1429   /* Return the next partial match */
1430   while ((name = cmds[list_index].name))
1431     {
1432       /* Only complete commands that have help text */
1433       if (cmds[list_index++].desc && strncmp (name, text, len) == 0)
1434         return strdup (name);
1435     }
1436
1437   return NULL;
1438 }
1439
1440 static char **
1441 keyedit_completion (const char *text, int start, int end)
1442 {
1443   /* If we are at the start of a line, we try and command-complete.
1444      If not, just do nothing for now. */
1445
1446   (void) end;
1447
1448   if (start == 0)
1449     return rl_completion_matches (text, command_generator);
1450
1451   rl_attempted_completion_over = 1;
1452
1453   return NULL;
1454 }
1455 #endif /* HAVE_LIBREADLINE */
1456
1457
1458 \f
1459 /* Main function of the menu driven key editor.  */
1460 void
1461 keyedit_menu (ctrl_t ctrl, const char *username, strlist_t locusr,
1462               strlist_t commands, int quiet, int seckey_check)
1463 {
1464   enum cmdids cmd = 0;
1465   gpg_error_t err = 0;
1466   KBNODE keyblock = NULL;
1467   KEYDB_HANDLE kdbhd = NULL;
1468   int have_seckey = 0;
1469   char *answer = NULL;
1470   int redisplay = 1;
1471   int modified = 0;
1472   int sec_shadowing = 0;
1473   int run_subkey_warnings = 0;
1474   int have_commands = !!commands;
1475
1476   if (opt.command_fd != -1)
1477     ;
1478   else if (opt.batch && !have_commands)
1479     {
1480       log_error (_("can't do this in batch mode\n"));
1481       goto leave;
1482     }
1483
1484 #ifdef HAVE_W32_SYSTEM
1485   /* Due to Windows peculiarities we need to make sure that the
1486      trustdb stale check is done before we open another file
1487      (i.e. by searching for a key).  In theory we could make sure
1488      that the files are closed after use but the open/close caches
1489      inhibits that and flushing the cache right before the stale
1490      check is not easy to implement.  Thus we take the easy way out
1491      and run the stale check as early as possible.  Note, that for
1492      non- W32 platforms it is run indirectly trough a call to
1493      get_validity ().  */
1494   check_trustdb_stale ();
1495 #endif
1496
1497   /* Get the public key */
1498   err = get_pubkey_byname (ctrl, NULL, NULL, username, &keyblock, &kdbhd, 1, 1);
1499   if (err)
1500     {
1501       log_error (_("key \"%s\" not found: %s\n"), username, gpg_strerror (err));
1502       goto leave;
1503     }
1504
1505   if (fix_keyblock (&keyblock))
1506     modified++;
1507
1508   /* See whether we have a matching secret key.  */
1509   if (seckey_check)
1510     {
1511       have_seckey = !agent_probe_any_secret_key (ctrl, keyblock);
1512       if (have_seckey && !quiet)
1513         tty_printf (_("Secret key is available.\n"));
1514     }
1515
1516   /* Main command loop.  */
1517   for (;;)
1518     {
1519       int i, arg_number, photo;
1520       const char *arg_string = "";
1521       char *p;
1522       PKT_public_key *pk = keyblock->pkt->pkt.public_key;
1523
1524       tty_printf ("\n");
1525
1526       if (redisplay && !quiet)
1527         {
1528           /* Show using flags: with_revoker, with_subkeys.  */
1529           show_key_with_all_names (NULL, keyblock, 0, 1, 0, 1, 0, 0);
1530           tty_printf ("\n");
1531           redisplay = 0;
1532         }
1533
1534       if (run_subkey_warnings)
1535         {
1536           run_subkey_warnings = 0;
1537           if (!count_selected_keys (keyblock))
1538             subkey_expire_warning (keyblock);
1539         }
1540
1541       do
1542         {
1543           xfree (answer);
1544           if (have_commands)
1545             {
1546               if (commands)
1547                 {
1548                   answer = xstrdup (commands->d);
1549                   commands = commands->next;
1550                 }
1551               else if (opt.batch)
1552                 {
1553                   answer = xstrdup ("quit");
1554                 }
1555               else
1556                 have_commands = 0;
1557             }
1558           if (!have_commands)
1559             {
1560 #ifdef HAVE_LIBREADLINE
1561               tty_enable_completion (keyedit_completion);
1562 #endif
1563               answer = cpr_get_no_help ("keyedit.prompt", GPG_NAME "> ");
1564               cpr_kill_prompt ();
1565               tty_disable_completion ();
1566             }
1567           trim_spaces (answer);
1568         }
1569       while (*answer == '#');
1570
1571       arg_number = 0; /* Here is the init which egcc complains about.  */
1572       photo = 0;      /* Same here. */
1573       if (!*answer)
1574         cmd = cmdLIST;
1575       else if (*answer == CONTROL_D)
1576         cmd = cmdQUIT;
1577       else if (digitp (answer))
1578         {
1579           cmd = cmdSELUID;
1580           arg_number = atoi (answer);
1581         }
1582       else
1583         {
1584           if ((p = strchr (answer, ' ')))
1585             {
1586               *p++ = 0;
1587               trim_spaces (answer);
1588               trim_spaces (p);
1589               arg_number = atoi (p);
1590               arg_string = p;
1591             }
1592
1593           for (i = 0; cmds[i].name; i++)
1594             {
1595               if (cmds[i].flags & KEYEDIT_TAIL_MATCH)
1596                 {
1597                   size_t l = strlen (cmds[i].name);
1598                   size_t a = strlen (answer);
1599                   if (a >= l)
1600                     {
1601                       if (!ascii_strcasecmp (&answer[a - l], cmds[i].name))
1602                         {
1603                           answer[a - l] = '\0';
1604                           break;
1605                         }
1606                     }
1607                 }
1608               else if (!ascii_strcasecmp (answer, cmds[i].name))
1609                 break;
1610             }
1611           if ((cmds[i].flags & KEYEDIT_NEED_SK) && !have_seckey)
1612             {
1613               tty_printf (_("Need the secret key to do this.\n"));
1614               cmd = cmdNOP;
1615             }
1616           else
1617             cmd = cmds[i].id;
1618         }
1619
1620       /* Dispatch the command.  */
1621       switch (cmd)
1622         {
1623         case cmdHELP:
1624           for (i = 0; cmds[i].name; i++)
1625             {
1626               if ((cmds[i].flags & KEYEDIT_NEED_SK) && !have_seckey)
1627                 ; /* Skip those item if we do not have the secret key.  */
1628               else if (cmds[i].desc)
1629                 tty_printf ("%-11s %s\n", cmds[i].name, _(cmds[i].desc));
1630             }
1631
1632           tty_printf ("\n");
1633           tty_printf
1634             (_("* The 'sign' command may be prefixed with an 'l' for local "
1635                "signatures (lsign),\n"
1636                "  a 't' for trust signatures (tsign), an 'nr' for "
1637                "non-revocable signatures\n"
1638                "  (nrsign), or any combination thereof (ltsign, "
1639                "tnrsign, etc.).\n"));
1640           break;
1641
1642         case cmdLIST:
1643           redisplay = 1;
1644           break;
1645
1646         case cmdFPR:
1647           show_key_and_fingerprint (keyblock);
1648           break;
1649
1650         case cmdSELUID:
1651           if (strlen (arg_string) == NAMEHASH_LEN * 2)
1652             redisplay = menu_select_uid_namehash (keyblock, arg_string);
1653           else
1654             {
1655               if (*arg_string == '*'
1656                   && (!arg_string[1] || spacep (arg_string + 1)))
1657                 arg_number = -1;        /* Select all. */
1658               redisplay = menu_select_uid (keyblock, arg_number);
1659             }
1660           break;
1661
1662         case cmdSELKEY:
1663           {
1664             if (*arg_string == '*'
1665                 && (!arg_string[1] || spacep (arg_string + 1)))
1666               arg_number = -1;  /* Select all. */
1667             if (menu_select_key (keyblock, arg_number))
1668               redisplay = 1;
1669           }
1670           break;
1671
1672         case cmdCHECK:
1673           check_all_keysigs (keyblock, count_selected_uids (keyblock));
1674           break;
1675
1676         case cmdSIGN:
1677           {
1678             int localsig = 0, nonrevokesig = 0, trustsig = 0, interactive = 0;
1679
1680             if (pk->flags.revoked)
1681               {
1682                 tty_printf (_("Key is revoked."));
1683
1684                 if (opt.expert)
1685                   {
1686                     tty_printf ("  ");
1687                     if (!cpr_get_answer_is_yes
1688                         ("keyedit.sign_revoked.okay",
1689                          _("Are you sure you still want to sign it? (y/N) ")))
1690                       break;
1691                   }
1692                 else
1693                   {
1694                     tty_printf (_("  Unable to sign.\n"));
1695                     break;
1696                   }
1697               }
1698
1699             if (count_uids (keyblock) > 1 && !count_selected_uids (keyblock)
1700                 && !cpr_get_answer_is_yes ("keyedit.sign_all.okay",
1701                                            _("Really sign all user IDs?"
1702                                              " (y/N) ")))
1703               {
1704                 if (opt.interactive)
1705                   interactive = 1;
1706                 else
1707                   {
1708                     tty_printf (_("Hint: Select the user IDs to sign\n"));
1709                     have_commands = 0;
1710                     break;
1711                   }
1712
1713               }
1714             /* What sort of signing are we doing? */
1715             if (!parse_sign_type
1716                 (answer, &localsig, &nonrevokesig, &trustsig))
1717               {
1718                 tty_printf (_("Unknown signature type '%s'\n"), answer);
1719                 break;
1720               }
1721
1722             sign_uids (NULL, keyblock, locusr, &modified,
1723                        localsig, nonrevokesig, trustsig, interactive, 0);
1724           }
1725           break;
1726
1727         case cmdDEBUG:
1728           dump_kbnode (keyblock);
1729           break;
1730
1731         case cmdTOGGLE:
1732           /* The toggle command is a leftover from old gpg versions
1733              where we worked with a secret and a public keyring.  It
1734              is not necessary anymore but we keep this command for the
1735              sake of scripts using it.  */
1736           redisplay = 1;
1737           break;
1738
1739         case cmdADDPHOTO:
1740           if (RFC2440)
1741             {
1742               tty_printf (_("This command is not allowed while in %s mode.\n"),
1743                           compliance_option_string ());
1744               break;
1745             }
1746           photo = 1;
1747           /* fall through */
1748         case cmdADDUID:
1749           if (menu_adduid (keyblock, photo, arg_string, NULL))
1750             {
1751               update_trust = 1;
1752               redisplay = 1;
1753               modified = 1;
1754               merge_keys_and_selfsig (keyblock);
1755             }
1756           break;
1757
1758         case cmdDELUID:
1759           {
1760             int n1;
1761
1762             if (!(n1 = count_selected_uids (keyblock)))
1763               tty_printf (_("You must select at least one user ID.\n"));
1764             else if (real_uids_left (keyblock) < 1)
1765               tty_printf (_("You can't delete the last user ID!\n"));
1766             else if (cpr_get_answer_is_yes
1767                      ("keyedit.remove.uid.okay",
1768                       n1 > 1 ? _("Really remove all selected user IDs? (y/N) ")
1769                       :        _("Really remove this user ID? (y/N) ")))
1770               {
1771                 menu_deluid (keyblock);
1772                 redisplay = 1;
1773                 modified = 1;
1774               }
1775           }
1776           break;
1777
1778         case cmdDELSIG:
1779           {
1780             int n1;
1781
1782             if (!(n1 = count_selected_uids (keyblock)))
1783               tty_printf (_("You must select at least one user ID.\n"));
1784             else if (menu_delsig (keyblock))
1785               {
1786                 /* No redisplay here, because it may scroll away some
1787                  * of the status output of this command.  */
1788                 modified = 1;
1789               }
1790           }
1791           break;
1792
1793         case cmdADDKEY:
1794           if (!generate_subkeypair (ctrl, keyblock))
1795             {
1796               redisplay = 1;
1797               modified = 1;
1798               merge_keys_and_selfsig (keyblock);
1799             }
1800           break;
1801
1802 #ifdef ENABLE_CARD_SUPPORT
1803         case cmdADDCARDKEY:
1804           if (!card_generate_subkey (keyblock))
1805             {
1806               redisplay = 1;
1807               modified = 1;
1808               merge_keys_and_selfsig (keyblock);
1809             }
1810           break;
1811
1812         case cmdKEYTOCARD:
1813           {
1814             KBNODE node = NULL;
1815             switch (count_selected_keys (keyblock))
1816               {
1817               case 0:
1818                 if (cpr_get_answer_is_yes
1819                     ("keyedit.keytocard.use_primary",
1820                      /* TRANSLATORS: Please take care: This is about
1821                         moving the key and not about removing it.  */
1822                      _("Really move the primary key? (y/N) ")))
1823                   node = keyblock;
1824                 break;
1825               case 1:
1826                 for (node = keyblock; node; node = node->next)
1827                   {
1828                     if (node->pkt->pkttype == PKT_PUBLIC_SUBKEY
1829                         && node->flag & NODFLG_SELKEY)
1830                       break;
1831                   }
1832                 break;
1833               default:
1834                 tty_printf (_("You must select exactly one key.\n"));
1835                 break;
1836               }
1837             if (node)
1838               {
1839                 PKT_public_key *xxpk = node->pkt->pkt.public_key;
1840                 if (card_store_subkey (node, xxpk ? xxpk->pubkey_usage : 0))
1841                   {
1842                     redisplay = 1;
1843                     sec_shadowing = 1;
1844                   }
1845               }
1846           }
1847           break;
1848
1849         case cmdBKUPTOCARD:
1850         case cmdCHECKBKUPKEY:
1851           log_debug ("FIXME: This needs to be changed\n");
1852           {
1853             /* Ask for a filename, check whether this is really a
1854                backup key as generated by the card generation, parse
1855                that key and store it on card. */
1856             KBNODE node;
1857             const char *fname;
1858             PACKET *pkt;
1859             IOBUF a;
1860
1861             fname = arg_string;
1862             if (!*fname)
1863               {
1864                 tty_printf (_("Command expects a filename argument\n"));
1865                 break;
1866               }
1867
1868             /* Open that file.  */
1869             a = iobuf_open (fname);
1870             if (a && is_secured_file (iobuf_get_fd (a)))
1871               {
1872                 iobuf_close (a);
1873                 a = NULL;
1874                 gpg_err_set_errno (EPERM);
1875               }
1876             if (!a)
1877               {
1878                 tty_printf (_("Can't open '%s': %s\n"),
1879                             fname, strerror (errno));
1880                 break;
1881               }
1882
1883             /* Parse and check that file.  */
1884             pkt = xmalloc (sizeof *pkt);
1885             init_packet (pkt);
1886             err = parse_packet (a, pkt);
1887             iobuf_close (a);
1888             iobuf_ioctl (NULL, IOBUF_IOCTL_INVALIDATE_CACHE, 0, (char *) fname);
1889             if (!err && pkt->pkttype != PKT_SECRET_KEY
1890                 && pkt->pkttype != PKT_SECRET_SUBKEY)
1891               err = GPG_ERR_NO_SECKEY;
1892             if (err)
1893               {
1894                 tty_printf (_("Error reading backup key from '%s': %s\n"),
1895                             fname, gpg_strerror (err));
1896                 free_packet (pkt);
1897                 xfree (pkt);
1898                 break;
1899               }
1900             node = new_kbnode (pkt);
1901
1902             if (cmd == cmdCHECKBKUPKEY)
1903               {
1904                 /* PKT_public_key *sk = node->pkt->pkt.secret_key; */
1905                 /* switch (is_secret_key_protected (sk)) */
1906                 /*   { */
1907                 /*   case 0:    /\* Not protected. *\/ */
1908                 /*     tty_printf (_("This key is not protected.\n")); */
1909                 /*     break; */
1910                 /*   case -1: */
1911                 /*     log_error (_("unknown key protection algorithm\n")); */
1912                 /*     break; */
1913                 /*   default: */
1914                 /*     if (sk->protect.s2k.mode == 1001) */
1915                 /*       tty_printf (_("Secret parts of key" */
1916                 /*                  " are not available.\n")); */
1917                 /*     if (sk->protect.s2k.mode == 1002) */
1918                 /*       tty_printf (_("Secret parts of key" */
1919                 /*                  " are stored on-card.\n")); */
1920                     /* else */
1921                     /*   check_secret_key (sk, 0); */
1922                   /* } */
1923               }
1924             else                /* Store it.  */
1925               {
1926                 if (card_store_subkey (node, 0))
1927                   {
1928                     redisplay = 1;
1929                     sec_shadowing = 1;
1930                   }
1931               }
1932             release_kbnode (node);
1933           }
1934           break;
1935
1936 #endif /* ENABLE_CARD_SUPPORT */
1937
1938         case cmdDELKEY:
1939           {
1940             int n1;
1941
1942             if (!(n1 = count_selected_keys (keyblock)))
1943               tty_printf (_("You must select at least one key.\n"));
1944             else if (!cpr_get_answer_is_yes
1945                      ("keyedit.remove.subkey.okay",
1946                       n1 > 1 ? _("Do you really want to delete the "
1947                                  "selected keys? (y/N) ")
1948                       :  _("Do you really want to delete this key? (y/N) ")))
1949               ;
1950             else
1951               {
1952                 menu_delkey (keyblock);
1953                 redisplay = 1;
1954                 modified = 1;
1955               }
1956           }
1957           break;
1958
1959         case cmdADDREVOKER:
1960           {
1961             int sensitive = 0;
1962
1963             if (ascii_strcasecmp (arg_string, "sensitive") == 0)
1964               sensitive = 1;
1965             if (menu_addrevoker (ctrl, keyblock, sensitive))
1966               {
1967                 redisplay = 1;
1968                 modified = 1;
1969                 merge_keys_and_selfsig (keyblock);
1970               }
1971           }
1972           break;
1973
1974         case cmdREVUID:
1975           {
1976             int n1;
1977
1978             if (!(n1 = count_selected_uids (keyblock)))
1979               tty_printf (_("You must select at least one user ID.\n"));
1980             else if (cpr_get_answer_is_yes
1981                      ("keyedit.revoke.uid.okay",
1982                       n1 > 1 ? _("Really revoke all selected user IDs? (y/N) ")
1983                       :        _("Really revoke this user ID? (y/N) ")))
1984               {
1985                 if (menu_revuid (keyblock))
1986                   {
1987                     modified = 1;
1988                     redisplay = 1;
1989                   }
1990               }
1991           }
1992           break;
1993
1994         case cmdREVKEY:
1995           {
1996             int n1;
1997
1998             if (!(n1 = count_selected_keys (keyblock)))
1999               {
2000                 if (cpr_get_answer_is_yes ("keyedit.revoke.subkey.okay",
2001                                            _("Do you really want to revoke"
2002                                              " the entire key? (y/N) ")))
2003                   {
2004                     if (menu_revkey (keyblock))
2005                       modified = 1;
2006
2007                     redisplay = 1;
2008                   }
2009               }
2010             else if (cpr_get_answer_is_yes ("keyedit.revoke.subkey.okay",
2011                                             n1 > 1 ?
2012                                             _("Do you really want to revoke"
2013                                               " the selected subkeys? (y/N) ")
2014                                             : _("Do you really want to revoke"
2015                                                 " this subkey? (y/N) ")))
2016               {
2017                 if (menu_revsubkey (keyblock))
2018                   modified = 1;
2019
2020                 redisplay = 1;
2021               }
2022
2023             if (modified)
2024               merge_keys_and_selfsig (keyblock);
2025           }
2026           break;
2027
2028         case cmdEXPIRE:
2029           if (menu_expire (keyblock))
2030             {
2031               merge_keys_and_selfsig (keyblock);
2032               run_subkey_warnings = 1;
2033               modified = 1;
2034               redisplay = 1;
2035             }
2036           break;
2037
2038         case cmdBACKSIGN:
2039           if (menu_backsign (keyblock))
2040             {
2041               modified = 1;
2042               redisplay = 1;
2043             }
2044           break;
2045
2046         case cmdPRIMARY:
2047           if (menu_set_primary_uid (keyblock))
2048             {
2049               merge_keys_and_selfsig (keyblock);
2050               modified = 1;
2051               redisplay = 1;
2052             }
2053           break;
2054
2055         case cmdPASSWD:
2056           change_passphrase (ctrl, keyblock);
2057           break;
2058
2059 #ifndef NO_TRUST_MODELS
2060         case cmdTRUST:
2061           if (opt.trust_model == TM_EXTERNAL)
2062             {
2063               tty_printf (_("Owner trust may not be set while "
2064                             "using a user provided trust database\n"));
2065               break;
2066             }
2067
2068           show_key_with_all_names (NULL, keyblock, 0, 0, 0, 1, 0, 0);
2069           tty_printf ("\n");
2070           if (edit_ownertrust (find_kbnode (keyblock,
2071                                             PKT_PUBLIC_KEY)->pkt->pkt.
2072                                public_key, 1))
2073             {
2074               redisplay = 1;
2075               /* No real need to set update_trust here as
2076                  edit_ownertrust() calls revalidation_mark()
2077                  anyway. */
2078               update_trust = 1;
2079             }
2080           break;
2081 #endif /*!NO_TRUST_MODELS*/
2082
2083         case cmdPREF:
2084           {
2085             int count = count_selected_uids (keyblock);
2086             assert (keyblock->pkt->pkttype == PKT_PUBLIC_KEY);
2087             show_names (NULL, keyblock, keyblock->pkt->pkt.public_key,
2088                         count ? NODFLG_SELUID : 0, 1);
2089           }
2090           break;
2091
2092         case cmdSHOWPREF:
2093           {
2094             int count = count_selected_uids (keyblock);
2095             assert (keyblock->pkt->pkttype == PKT_PUBLIC_KEY);
2096             show_names (NULL, keyblock, keyblock->pkt->pkt.public_key,
2097                         count ? NODFLG_SELUID : 0, 2);
2098           }
2099           break;
2100
2101         case cmdSETPREF:
2102           {
2103             PKT_user_id *tempuid;
2104
2105             keygen_set_std_prefs (!*arg_string ? "default" : arg_string, 0);
2106
2107             tempuid = keygen_get_std_prefs ();
2108             tty_printf (_("Set preference list to:\n"));
2109             show_prefs (tempuid, NULL, 1);
2110             free_user_id (tempuid);
2111
2112             if (cpr_get_answer_is_yes
2113                 ("keyedit.setpref.okay",
2114                  count_selected_uids (keyblock) ?
2115                  _("Really update the preferences"
2116                    " for the selected user IDs? (y/N) ")
2117                  : _("Really update the preferences? (y/N) ")))
2118               {
2119                 if (menu_set_preferences (keyblock))
2120                   {
2121                     merge_keys_and_selfsig (keyblock);
2122                     modified = 1;
2123                     redisplay = 1;
2124                   }
2125               }
2126           }
2127           break;
2128
2129         case cmdPREFKS:
2130           if (menu_set_keyserver_url (*arg_string ? arg_string : NULL,
2131                                       keyblock))
2132             {
2133               merge_keys_and_selfsig (keyblock);
2134               modified = 1;
2135               redisplay = 1;
2136             }
2137           break;
2138
2139         case cmdNOTATION:
2140           if (menu_set_notation (*arg_string ? arg_string : NULL,
2141                                  keyblock))
2142             {
2143               merge_keys_and_selfsig (keyblock);
2144               modified = 1;
2145               redisplay = 1;
2146             }
2147           break;
2148
2149         case cmdNOP:
2150           break;
2151
2152         case cmdREVSIG:
2153           if (menu_revsig (keyblock))
2154             {
2155               redisplay = 1;
2156               modified = 1;
2157             }
2158           break;
2159
2160 #ifndef NO_TRUST_MODELS
2161         case cmdENABLEKEY:
2162         case cmdDISABLEKEY:
2163           if (enable_disable_key (keyblock, cmd == cmdDISABLEKEY))
2164             {
2165               redisplay = 1;
2166               modified = 1;
2167             }
2168           break;
2169 #endif /*!NO_TRUST_MODELS*/
2170
2171         case cmdSHOWPHOTO:
2172           menu_showphoto (keyblock);
2173           break;
2174
2175         case cmdCLEAN:
2176           if (menu_clean (keyblock, 0))
2177             redisplay = modified = 1;
2178           break;
2179
2180         case cmdMINIMIZE:
2181           if (menu_clean (keyblock, 1))
2182             redisplay = modified = 1;
2183           break;
2184
2185         case cmdQUIT:
2186           if (have_commands)
2187             goto leave;
2188           if (!modified && !sec_shadowing)
2189             goto leave;
2190           if (!cpr_get_answer_is_yes ("keyedit.save.okay",
2191                                       _("Save changes? (y/N) ")))
2192             {
2193               if (cpr_enabled ()
2194                   || cpr_get_answer_is_yes ("keyedit.cancel.okay",
2195                                             _("Quit without saving? (y/N) ")))
2196                 goto leave;
2197               break;
2198             }
2199           /* fall thru */
2200         case cmdSAVE:
2201           if (modified)
2202             {
2203               err = keydb_update_keyblock (kdbhd, keyblock);
2204               if (err)
2205                 {
2206                   log_error (_("update failed: %s\n"), gpg_strerror (err));
2207                   break;
2208                 }
2209             }
2210
2211           if (sec_shadowing)
2212             {
2213               err = agent_scd_learn (NULL, 1);
2214               if (err)
2215                 {
2216                   log_error (_("update failed: %s\n"), gpg_strerror (err));
2217                   break;
2218                 }
2219             }
2220
2221           if (!modified && !sec_shadowing)
2222             tty_printf (_("Key not changed so no update needed.\n"));
2223
2224           if (update_trust)
2225             {
2226               revalidation_mark ();
2227               update_trust = 0;
2228             }
2229           goto leave;
2230
2231         case cmdINVCMD:
2232         default:
2233           tty_printf ("\n");
2234           tty_printf (_("Invalid command  (try \"help\")\n"));
2235           break;
2236         }
2237     } /* End of the main command loop.  */
2238
2239  leave:
2240   release_kbnode (keyblock);
2241   keydb_release (kdbhd);
2242   xfree (answer);
2243 }
2244
2245
2246 /* Change the passphrase of the secret key identified by USERNAME.  */
2247 void
2248 keyedit_passwd (ctrl_t ctrl, const char *username)
2249 {
2250   gpg_error_t err;
2251   PKT_public_key *pk;
2252   kbnode_t keyblock = NULL;
2253
2254   pk = xtrycalloc (1, sizeof *pk);
2255   if (!pk)
2256     {
2257       err = gpg_error_from_syserror ();
2258       goto leave;
2259     }
2260   err = getkey_byname (NULL, pk, username, 1, &keyblock);
2261   if (err)
2262     goto leave;
2263
2264   err = change_passphrase (ctrl, keyblock);
2265
2266 leave:
2267   release_kbnode (keyblock);
2268   free_public_key (pk);
2269   if (err)
2270     {
2271       log_info ("error changing the passphrase for '%s': %s\n",
2272                 username, gpg_strerror (err));
2273       write_status_error ("keyedit.passwd", err);
2274     }
2275   else
2276     write_status_text (STATUS_SUCCESS, "keyedit.passwd");
2277 }
2278
2279
2280 /* Unattended adding of a new keyid.  USERNAME specifies the
2281    key. NEWUID is the new user id to add to the key.  */
2282 void
2283 keyedit_quick_adduid (ctrl_t ctrl, const char *username, const char *newuid)
2284 {
2285   gpg_error_t err;
2286   KEYDB_HANDLE kdbhd = NULL;
2287   KEYDB_SEARCH_DESC desc;
2288   kbnode_t keyblock = NULL;
2289   kbnode_t node;
2290   char *uidstring = NULL;
2291
2292   uidstring = xstrdup (newuid);
2293   trim_spaces (uidstring);
2294   if (!*uidstring)
2295     {
2296       log_error ("%s\n", gpg_strerror (GPG_ERR_INV_USER_ID));
2297       goto leave;
2298     }
2299
2300 #ifdef HAVE_W32_SYSTEM
2301   /* See keyedit_menu for why we need this.  */
2302   check_trustdb_stale ();
2303 #endif
2304
2305   /* Search the key; we don't want the whole getkey stuff here.  */
2306   kdbhd = keydb_new ();
2307   err = classify_user_id (username, &desc, 1);
2308   if (!err)
2309     err = keydb_search (kdbhd, &desc, 1, NULL);
2310   if (!err)
2311     {
2312       err = keydb_get_keyblock (kdbhd, &keyblock);
2313       if (err)
2314         {
2315           log_error (_("error reading keyblock: %s\n"), gpg_strerror (err));
2316           goto leave;
2317         }
2318       /* Now with the keyblock retrieved, search again to detect an
2319          ambiguous specification.  We need to save the found state so
2320          that we can do an update later.  */
2321       keydb_push_found_state (kdbhd);
2322       err = keydb_search (kdbhd, &desc, 1, NULL);
2323       if (!err)
2324         err = gpg_error (GPG_ERR_AMBIGUOUS_NAME);
2325       else if (gpg_err_code (err) == GPG_ERR_NOT_FOUND)
2326         err = 0;
2327       keydb_pop_found_state (kdbhd);
2328
2329       if (!err)
2330         {
2331           /* We require the secret primary key to add a UID.  */
2332           node = find_kbnode (keyblock, PKT_PUBLIC_KEY);
2333           if (!node)
2334             BUG ();
2335           err = agent_probe_secret_key (ctrl, node->pkt->pkt.public_key);
2336         }
2337     }
2338   if (err)
2339     {
2340       log_error (_("secret key \"%s\" not found: %s\n"),
2341                  username, gpg_strerror (err));
2342       goto leave;
2343     }
2344
2345   fix_keyblock (&keyblock);
2346
2347   if (menu_adduid (keyblock, 0, NULL, uidstring))
2348     {
2349       err = keydb_update_keyblock (kdbhd, keyblock);
2350       if (err)
2351         {
2352           log_error (_("update failed: %s\n"), gpg_strerror (err));
2353           goto leave;
2354         }
2355
2356       if (update_trust)
2357         revalidation_mark ();
2358     }
2359
2360  leave:
2361   xfree (uidstring);
2362   release_kbnode (keyblock);
2363   keydb_release (kdbhd);
2364 }
2365
2366
2367 /* Unattended key signing function.  If the key specifified by FPR is
2368    availabale and FPR is the primary fingerprint all user ids of the
2369    user ids of the key are signed using the default signing key.  If
2370    UIDS is an empty list all usable UIDs are signed, if it is not
2371    empty, only those user ids matching one of the entries of the loist
2372    are signed.  With LOCAL being true kthe signatures are marked as
2373    non-exportable.  */
2374 void
2375 keyedit_quick_sign (ctrl_t ctrl, const char *fpr, strlist_t uids,
2376                     strlist_t locusr, int local)
2377 {
2378   gpg_error_t err;
2379   kbnode_t keyblock = NULL;
2380   KEYDB_HANDLE kdbhd = NULL;
2381   int modified = 0;
2382   KEYDB_SEARCH_DESC desc;
2383   PKT_public_key *pk;
2384   kbnode_t node;
2385   strlist_t sl;
2386   int any;
2387
2388 #ifdef HAVE_W32_SYSTEM
2389   /* See keyedit_menu for why we need this.  */
2390   check_trustdb_stale ();
2391 #endif
2392
2393   /* We require a fingerprint because only this uniquely identifies a
2394      key and may thus be used to select a key for unattended key
2395      signing.  */
2396   if (classify_user_id (fpr, &desc, 1)
2397       || !(desc.mode == KEYDB_SEARCH_MODE_FPR
2398            || desc.mode == KEYDB_SEARCH_MODE_FPR16
2399            || desc.mode == KEYDB_SEARCH_MODE_FPR20))
2400     {
2401       log_error (_("\"%s\" is not a fingerprint\n"), fpr);
2402       goto leave;
2403     }
2404   err = get_pubkey_byname (ctrl, NULL, NULL, fpr, &keyblock, &kdbhd, 1, 1);
2405   if (err)
2406     {
2407       log_error (_("key \"%s\" not found: %s\n"), fpr, gpg_strerror (err));
2408       goto leave;
2409     }
2410
2411   /* Check that the primary fingerprint has been given. */
2412   {
2413     byte fprbin[MAX_FINGERPRINT_LEN];
2414     size_t fprlen;
2415
2416     fingerprint_from_pk (keyblock->pkt->pkt.public_key, fprbin, &fprlen);
2417     if (fprlen == 16 && desc.mode == KEYDB_SEARCH_MODE_FPR16
2418         && !memcmp (fprbin, desc.u.fpr, 16))
2419       ;
2420     else if (fprlen == 16 && desc.mode == KEYDB_SEARCH_MODE_FPR
2421              && !memcmp (fprbin, desc.u.fpr, 16)
2422              && !desc.u.fpr[16]
2423              && !desc.u.fpr[17]
2424              && !desc.u.fpr[18]
2425              && !desc.u.fpr[19])
2426       ;
2427     else if (fprlen == 20 && (desc.mode == KEYDB_SEARCH_MODE_FPR20
2428                               || desc.mode == KEYDB_SEARCH_MODE_FPR)
2429              && !memcmp (fprbin, desc.u.fpr, 20))
2430       ;
2431     else
2432       {
2433         log_error (_("\"%s\" is not the primary fingerprint\n"), fpr);
2434         goto leave;
2435       }
2436   }
2437
2438   if (fix_keyblock (&keyblock))
2439     modified++;
2440
2441   /* Give some info in verbose.  */
2442   if (opt.verbose)
2443     {
2444       show_key_with_all_names (es_stdout, keyblock, 0,
2445                                1/*with_revoker*/, 1/*with_fingerprint*/,
2446                                0, 0, 1);
2447       es_fflush (es_stdout);
2448     }
2449
2450   pk = keyblock->pkt->pkt.public_key;
2451   if (pk->flags.revoked)
2452     {
2453       if (!opt.verbose)
2454         show_key_with_all_names (es_stdout, keyblock, 0, 0, 0, 0, 0, 1);
2455       log_error ("%s%s", _("Key is revoked."), _("  Unable to sign.\n"));
2456       goto leave;
2457     }
2458
2459   /* Set the flags according to the UIDS list.  Fixme: We may want to
2460      use classify_user_id along with dedicated compare functions so
2461      that we match the same way as in the key lookup. */
2462   any = 0;
2463   menu_select_uid (keyblock, 0);   /* Better clear the flags first. */
2464   for (sl=uids; sl; sl = sl->next)
2465     {
2466       for (node = keyblock; node; node = node->next)
2467         {
2468           if (node->pkt->pkttype == PKT_USER_ID)
2469             {
2470               PKT_user_id *uid = node->pkt->pkt.user_id;
2471
2472               if (!uid->attrib_data
2473                   && ascii_memistr (uid->name, uid->len, sl->d))
2474                 {
2475                   node->flag |= NODFLG_SELUID;
2476                   any = 1;
2477                 }
2478             }
2479         }
2480     }
2481
2482   if (uids && !any)
2483     {
2484       if (!opt.verbose)
2485         show_key_with_all_names (es_stdout, keyblock, 0, 0, 0, 0, 0, 1);
2486       es_fflush (es_stdout);
2487       log_error ("%s  %s", _("No matching user IDs."), _("Nothing to sign.\n"));
2488       goto leave;
2489     }
2490
2491   /* Sign. */
2492   sign_uids (es_stdout, keyblock, locusr, &modified, local, 0, 0, 0, 1);
2493   es_fflush (es_stdout);
2494
2495   if (modified)
2496     {
2497       err = keydb_update_keyblock (kdbhd, keyblock);
2498       if (err)
2499         {
2500           log_error (_("update failed: %s\n"), gpg_strerror (err));
2501           goto leave;
2502         }
2503     }
2504   else
2505     log_info (_("Key not changed so no update needed.\n"));
2506
2507   if (update_trust)
2508     revalidation_mark ();
2509
2510
2511  leave:
2512   release_kbnode (keyblock);
2513   keydb_release (kdbhd);
2514 }
2515
2516
2517 \f
2518 static void
2519 tty_print_notations (int indent, PKT_signature * sig)
2520 {
2521   int first = 1;
2522   struct notation *notation, *nd;
2523
2524   if (indent < 0)
2525     {
2526       first = 0;
2527       indent = -indent;
2528     }
2529
2530   notation = sig_to_notation (sig);
2531
2532   for (nd = notation; nd; nd = nd->next)
2533     {
2534       if (!first)
2535         tty_printf ("%*s", indent, "");
2536       else
2537         first = 0;
2538
2539       tty_print_utf8_string (nd->name, strlen (nd->name));
2540       tty_printf ("=");
2541       tty_print_utf8_string (nd->value, strlen (nd->value));
2542       tty_printf ("\n");
2543     }
2544
2545   free_notation (notation);
2546 }
2547
2548
2549 /*
2550  * Show preferences of a public keyblock.
2551  */
2552 static void
2553 show_prefs (PKT_user_id * uid, PKT_signature * selfsig, int verbose)
2554 {
2555   const prefitem_t fake = { 0, 0 };
2556   const prefitem_t *prefs;
2557   int i;
2558
2559   if (!uid)
2560     return;
2561
2562   if (uid->prefs)
2563     prefs = uid->prefs;
2564   else if (verbose)
2565     prefs = &fake;
2566   else
2567     return;
2568
2569   if (verbose)
2570     {
2571       int any, des_seen = 0, sha1_seen = 0, uncomp_seen = 0;
2572
2573       tty_printf ("     ");
2574       tty_printf (_("Cipher: "));
2575       for (i = any = 0; prefs[i].type; i++)
2576         {
2577           if (prefs[i].type == PREFTYPE_SYM)
2578             {
2579               if (any)
2580                 tty_printf (", ");
2581               any = 1;
2582               /* We don't want to display strings for experimental algos */
2583               if (!openpgp_cipher_test_algo (prefs[i].value)
2584                   && prefs[i].value < 100)
2585                 tty_printf ("%s", openpgp_cipher_algo_name (prefs[i].value));
2586               else
2587                 tty_printf ("[%d]", prefs[i].value);
2588               if (prefs[i].value == CIPHER_ALGO_3DES)
2589                 des_seen = 1;
2590             }
2591         }
2592       if (!des_seen)
2593         {
2594           if (any)
2595             tty_printf (", ");
2596           tty_printf ("%s", openpgp_cipher_algo_name (CIPHER_ALGO_3DES));
2597         }
2598       tty_printf ("\n     ");
2599       tty_printf (_("Digest: "));
2600       for (i = any = 0; prefs[i].type; i++)
2601         {
2602           if (prefs[i].type == PREFTYPE_HASH)
2603             {
2604               if (any)
2605                 tty_printf (", ");
2606               any = 1;
2607               /* We don't want to display strings for experimental algos */
2608               if (!gcry_md_test_algo (prefs[i].value) && prefs[i].value < 100)
2609                 tty_printf ("%s", gcry_md_algo_name (prefs[i].value));
2610               else
2611                 tty_printf ("[%d]", prefs[i].value);
2612               if (prefs[i].value == DIGEST_ALGO_SHA1)
2613                 sha1_seen = 1;
2614             }
2615         }
2616       if (!sha1_seen)
2617         {
2618           if (any)
2619             tty_printf (", ");
2620           tty_printf ("%s", gcry_md_algo_name (DIGEST_ALGO_SHA1));
2621         }
2622       tty_printf ("\n     ");
2623       tty_printf (_("Compression: "));
2624       for (i = any = 0; prefs[i].type; i++)
2625         {
2626           if (prefs[i].type == PREFTYPE_ZIP)
2627             {
2628               const char *s = compress_algo_to_string (prefs[i].value);
2629
2630               if (any)
2631                 tty_printf (", ");
2632               any = 1;
2633               /* We don't want to display strings for experimental algos */
2634               if (s && prefs[i].value < 100)
2635                 tty_printf ("%s", s);
2636               else
2637                 tty_printf ("[%d]", prefs[i].value);
2638               if (prefs[i].value == COMPRESS_ALGO_NONE)
2639                 uncomp_seen = 1;
2640             }
2641         }
2642       if (!uncomp_seen)
2643         {
2644           if (any)
2645             tty_printf (", ");
2646           else
2647             {
2648               tty_printf ("%s", compress_algo_to_string (COMPRESS_ALGO_ZIP));
2649               tty_printf (", ");
2650             }
2651           tty_printf ("%s", compress_algo_to_string (COMPRESS_ALGO_NONE));
2652         }
2653       if (uid->flags.mdc || !uid->flags.ks_modify)
2654         {
2655           tty_printf ("\n     ");
2656           tty_printf (_("Features: "));
2657           any = 0;
2658           if (uid->flags.mdc)
2659             {
2660               tty_printf ("MDC");
2661               any = 1;
2662             }
2663           if (!uid->flags.ks_modify)
2664             {
2665               if (any)
2666                 tty_printf (", ");
2667               tty_printf (_("Keyserver no-modify"));
2668             }
2669         }
2670       tty_printf ("\n");
2671
2672       if (selfsig)
2673         {
2674           const byte *pref_ks;
2675           size_t pref_ks_len;
2676
2677           pref_ks = parse_sig_subpkt (selfsig->hashed,
2678                                       SIGSUBPKT_PREF_KS, &pref_ks_len);
2679           if (pref_ks && pref_ks_len)
2680             {
2681               tty_printf ("     ");
2682               tty_printf (_("Preferred keyserver: "));
2683               tty_print_utf8_string (pref_ks, pref_ks_len);
2684               tty_printf ("\n");
2685             }
2686
2687           if (selfsig->flags.notation)
2688             {
2689               tty_printf ("     ");
2690               tty_printf (_("Notations: "));
2691               tty_print_notations (5 + strlen (_("Notations: ")), selfsig);
2692             }
2693         }
2694     }
2695   else
2696     {
2697       tty_printf ("    ");
2698       for (i = 0; prefs[i].type; i++)
2699         {
2700           tty_printf (" %c%d", prefs[i].type == PREFTYPE_SYM ? 'S' :
2701                       prefs[i].type == PREFTYPE_HASH ? 'H' :
2702                       prefs[i].type == PREFTYPE_ZIP ? 'Z' : '?',
2703                       prefs[i].value);
2704         }
2705       if (uid->flags.mdc)
2706         tty_printf (" [mdc]");
2707       if (!uid->flags.ks_modify)
2708         tty_printf (" [no-ks-modify]");
2709       tty_printf ("\n");
2710     }
2711 }
2712
2713
2714 /* This is the version of show_key_with_all_names used when
2715    opt.with_colons is used.  It prints all available data in a easy to
2716    parse format and does not translate utf8 */
2717 static void
2718 show_key_with_all_names_colon (estream_t fp, kbnode_t keyblock)
2719 {
2720   KBNODE node;
2721   int i, j, ulti_hack = 0;
2722   byte pk_version = 0;
2723   PKT_public_key *primary = NULL;
2724
2725   if (!fp)
2726     fp = es_stdout;
2727
2728   /* the keys */
2729   for (node = keyblock; node; node = node->next)
2730     {
2731       if (node->pkt->pkttype == PKT_PUBLIC_KEY
2732           || (node->pkt->pkttype == PKT_PUBLIC_SUBKEY))
2733         {
2734           PKT_public_key *pk = node->pkt->pkt.public_key;
2735           u32 keyid[2];
2736
2737           if (node->pkt->pkttype == PKT_PUBLIC_KEY)
2738             {
2739               pk_version = pk->version;
2740               primary = pk;
2741             }
2742
2743           keyid_from_pk (pk, keyid);
2744
2745           es_fputs (node->pkt->pkttype == PKT_PUBLIC_KEY ? "pub:" : "sub:",
2746                     fp);
2747           if (!pk->flags.valid)
2748             es_putc ('i', fp);
2749           else if (pk->flags.revoked)
2750             es_putc ('r', fp);
2751           else if (pk->has_expired)
2752             es_putc ('e', fp);
2753           else if (!(opt.fast_list_mode || opt.no_expensive_trust_checks))
2754             {
2755               int trust = get_validity_info (pk, NULL);
2756               if (trust == 'u')
2757                 ulti_hack = 1;
2758               es_putc (trust, fp);
2759             }
2760
2761           es_fprintf (fp, ":%u:%d:%08lX%08lX:%lu:%lu::",
2762                       nbits_from_pk (pk),
2763                       pk->pubkey_algo,
2764                       (ulong) keyid[0], (ulong) keyid[1],
2765                       (ulong) pk->timestamp, (ulong) pk->expiredate);
2766           if (node->pkt->pkttype == PKT_PUBLIC_KEY
2767               && !(opt.fast_list_mode || opt.no_expensive_trust_checks))
2768             es_putc (get_ownertrust_info (pk), fp);
2769           es_putc (':', fp);
2770           es_putc (':', fp);
2771           es_putc (':', fp);
2772           /* Print capabilities.  */
2773           if ((pk->pubkey_usage & PUBKEY_USAGE_ENC))
2774             es_putc ('e', fp);
2775           if ((pk->pubkey_usage & PUBKEY_USAGE_SIG))
2776             es_putc ('s', fp);
2777           if ((pk->pubkey_usage & PUBKEY_USAGE_CERT))
2778             es_putc ('c', fp);
2779           if ((pk->pubkey_usage & PUBKEY_USAGE_AUTH))
2780             es_putc ('a', fp);
2781           es_putc ('\n', fp);
2782
2783           print_fingerprint (fp, pk, 0);
2784           print_revokers (fp, pk);
2785         }
2786     }
2787
2788   /* the user ids */
2789   i = 0;
2790   for (node = keyblock; node; node = node->next)
2791     {
2792       if (node->pkt->pkttype == PKT_USER_ID)
2793         {
2794           PKT_user_id *uid = node->pkt->pkt.user_id;
2795
2796           ++i;
2797
2798           if (uid->attrib_data)
2799             es_fputs ("uat:", fp);
2800           else
2801             es_fputs ("uid:", fp);
2802
2803           if (uid->is_revoked)
2804             es_fputs ("r::::::::", fp);
2805           else if (uid->is_expired)
2806             es_fputs ("e::::::::", fp);
2807           else if (opt.fast_list_mode || opt.no_expensive_trust_checks)
2808             es_fputs ("::::::::", fp);
2809           else
2810             {
2811               int uid_validity;
2812
2813               if (primary && !ulti_hack)
2814                 uid_validity = get_validity_info (primary, uid);
2815               else
2816                 uid_validity = 'u';
2817               es_fprintf (fp, "%c::::::::", uid_validity);
2818             }
2819
2820           if (uid->attrib_data)
2821             es_fprintf (fp, "%u %lu", uid->numattribs, uid->attrib_len);
2822           else
2823             es_write_sanitized (fp, uid->name, uid->len, ":", NULL);
2824
2825           es_putc (':', fp);
2826           /* signature class */
2827           es_putc (':', fp);
2828           /* capabilities */
2829           es_putc (':', fp);
2830           /* preferences */
2831           if (pk_version > 3 || uid->selfsigversion > 3)
2832             {
2833               const prefitem_t *prefs = uid->prefs;
2834
2835               for (j = 0; prefs && prefs[j].type; j++)
2836                 {
2837                   if (j)
2838                     es_putc (' ', fp);
2839                   es_fprintf (fp,
2840                               "%c%d", prefs[j].type == PREFTYPE_SYM ? 'S' :
2841                               prefs[j].type == PREFTYPE_HASH ? 'H' :
2842                               prefs[j].type == PREFTYPE_ZIP ? 'Z' : '?',
2843                               prefs[j].value);
2844                 }
2845               if (uid->flags.mdc)
2846                 es_fputs (",mdc", fp);
2847               if (!uid->flags.ks_modify)
2848                 es_fputs (",no-ks-modify", fp);
2849             }
2850           es_putc (':', fp);
2851           /* flags */
2852           es_fprintf (fp, "%d,", i);
2853           if (uid->is_primary)
2854             es_putc ('p', fp);
2855           if (uid->is_revoked)
2856             es_putc ('r', fp);
2857           if (uid->is_expired)
2858             es_putc ('e', fp);
2859           if ((node->flag & NODFLG_SELUID))
2860             es_putc ('s', fp);
2861           if ((node->flag & NODFLG_MARK_A))
2862             es_putc ('m', fp);
2863           es_putc (':', fp);
2864           es_putc ('\n', fp);
2865         }
2866     }
2867 }
2868
2869
2870 static void
2871 show_names (estream_t fp,
2872             KBNODE keyblock, PKT_public_key * pk, unsigned int flag,
2873             int with_prefs)
2874 {
2875   KBNODE node;
2876   int i = 0;
2877
2878   for (node = keyblock; node; node = node->next)
2879     {
2880       if (node->pkt->pkttype == PKT_USER_ID && !is_deleted_kbnode (node))
2881         {
2882           PKT_user_id *uid = node->pkt->pkt.user_id;
2883           ++i;
2884           if (!flag || (flag && (node->flag & flag)))
2885             {
2886               if (!(flag & NODFLG_MARK_A) && pk)
2887                 tty_fprintf (fp, "%s ", uid_trust_string_fixed (pk, uid));
2888
2889               if (flag & NODFLG_MARK_A)
2890                 tty_fprintf (fp, "     ");
2891               else if (node->flag & NODFLG_SELUID)
2892                 tty_fprintf (fp, "(%d)* ", i);
2893               else if (uid->is_primary)
2894                 tty_fprintf (fp, "(%d). ", i);
2895               else
2896                 tty_fprintf (fp, "(%d)  ", i);
2897               tty_print_utf8_string2 (fp, uid->name, uid->len, 0);
2898               tty_fprintf (fp, "\n");
2899               if (with_prefs && pk)
2900                 {
2901                   if (pk->version > 3 || uid->selfsigversion > 3)
2902                     {
2903                       PKT_signature *selfsig = NULL;
2904                       KBNODE signode;
2905
2906                       for (signode = node->next;
2907                            signode && signode->pkt->pkttype == PKT_SIGNATURE;
2908                            signode = signode->next)
2909                         {
2910                           if (signode->pkt->pkt.signature->
2911                               flags.chosen_selfsig)
2912                             {
2913                               selfsig = signode->pkt->pkt.signature;
2914                               break;
2915                             }
2916                         }
2917
2918                       show_prefs (uid, selfsig, with_prefs == 2);
2919                     }
2920                   else
2921                     tty_fprintf (fp, _("There are no preferences on a"
2922                                        " PGP 2.x-style user ID.\n"));
2923                 }
2924             }
2925         }
2926     }
2927 }
2928
2929
2930 /*
2931  * Display the key a the user ids, if only_marked is true, do only so
2932  * for user ids with mark A flag set and do not display the index
2933  * number.  If FP is not NULL print to the given stream and not to the
2934  * tty (ignored in with-colons mode).
2935  */
2936 static void
2937 show_key_with_all_names (estream_t fp,
2938                          KBNODE keyblock, int only_marked, int with_revoker,
2939                          int with_fpr, int with_subkeys, int with_prefs,
2940                          int nowarn)
2941 {
2942   KBNODE node;
2943   int i;
2944   int do_warn = 0;
2945   PKT_public_key *primary = NULL;
2946   char pkstrbuf[PUBKEY_STRING_SIZE];
2947
2948   if (opt.with_colons)
2949     {
2950       show_key_with_all_names_colon (fp, keyblock);
2951       return;
2952     }
2953
2954   /* the keys */
2955   for (node = keyblock; node; node = node->next)
2956     {
2957       if (node->pkt->pkttype == PKT_PUBLIC_KEY
2958           || (with_subkeys && node->pkt->pkttype == PKT_PUBLIC_SUBKEY
2959               && !is_deleted_kbnode (node)))
2960         {
2961           PKT_public_key *pk = node->pkt->pkt.public_key;
2962           const char *otrust = "err";
2963           const char *trust = "err";
2964
2965           if (node->pkt->pkttype == PKT_PUBLIC_KEY)
2966             {
2967               /* do it here, so that debug messages don't clutter the
2968                * output */
2969               static int did_warn = 0;
2970
2971               trust = get_validity_string (pk, NULL);
2972               otrust = get_ownertrust_string (pk);
2973
2974               /* Show a warning once */
2975               if (!did_warn
2976                   && (get_validity (pk, NULL) & TRUST_FLAG_PENDING_CHECK))
2977                 {
2978                   did_warn = 1;
2979                   do_warn = 1;
2980                 }
2981
2982               primary = pk;
2983             }
2984
2985           if (pk->flags.revoked)
2986             {
2987               char *user = get_user_id_string_native (pk->revoked.keyid);
2988               tty_fprintf (fp,
2989                            _("The following key was revoked on"
2990                             " %s by %s key %s\n"),
2991                           revokestr_from_pk (pk),
2992                           gcry_pk_algo_name (pk->revoked.algo), user);
2993               xfree (user);
2994             }
2995
2996           if (with_revoker)
2997             {
2998               if (!pk->revkey && pk->numrevkeys)
2999                 BUG ();
3000               else
3001                 for (i = 0; i < pk->numrevkeys; i++)
3002                   {
3003                     u32 r_keyid[2];
3004                     char *user;
3005                     const char *algo;
3006
3007                     algo = gcry_pk_algo_name (pk->revkey[i].algid);
3008                     keyid_from_fingerprint (pk->revkey[i].fpr,
3009                                             MAX_FINGERPRINT_LEN, r_keyid);
3010
3011                     user = get_user_id_string_native (r_keyid);
3012                     tty_fprintf (fp,
3013                                  _("This key may be revoked by %s key %s"),
3014                                  algo ? algo : "?", user);
3015
3016                     if (pk->revkey[i].class & 0x40)
3017                       {
3018                         tty_fprintf (fp, " ");
3019                         tty_fprintf (fp, _("(sensitive)"));
3020                       }
3021
3022                     tty_fprintf (fp, "\n");
3023                     xfree (user);
3024                   }
3025             }
3026
3027           keyid_from_pk (pk, NULL);
3028           tty_fprintf (fp, "%s%c %s/%s",
3029                       node->pkt->pkttype == PKT_PUBLIC_KEY ? "pub" :
3030                       node->pkt->pkttype == PKT_PUBLIC_SUBKEY ? "sub" :
3031                       node->pkt->pkttype == PKT_SECRET_KEY ? "sec" : "ssb",
3032                       (node->flag & NODFLG_SELKEY) ? '*' : ' ',
3033                       pubkey_string (pk, pkstrbuf, sizeof pkstrbuf),
3034                       keystr (pk->keyid));
3035
3036           if (opt.legacy_list_mode)
3037             tty_fprintf (fp, "  ");
3038           else
3039             tty_fprintf (fp, "\n     ");
3040
3041           tty_fprintf (fp, _("created: %s"), datestr_from_pk (pk));
3042           tty_fprintf (fp, "  ");
3043           if (pk->flags.revoked)
3044             tty_fprintf (fp, _("revoked: %s"), revokestr_from_pk (pk));
3045           else if (pk->has_expired)
3046             tty_fprintf (fp, _("expired: %s"), expirestr_from_pk (pk));
3047           else
3048             tty_fprintf (fp, _("expires: %s"), expirestr_from_pk (pk));
3049           tty_fprintf (fp, "  ");
3050           tty_fprintf (fp, _("usage: %s"), usagestr_from_pk (pk, 1));
3051           tty_fprintf (fp, "\n");
3052
3053           if (pk->seckey_info
3054               && pk->seckey_info->is_protected
3055               && pk->seckey_info->s2k.mode == 1002)
3056             {
3057               tty_fprintf (fp, "%*s%s", opt.legacy_list_mode? 21:5, "",
3058                            _("card-no: "));
3059               if (pk->seckey_info->ivlen == 16
3060                   && !memcmp (pk->seckey_info->iv,
3061                               "\xD2\x76\x00\x01\x24\x01", 6))
3062                 {
3063                   /* This is an OpenPGP card. */
3064                   for (i = 8; i < 14; i++)
3065                     {
3066                       if (i == 10)
3067                         tty_fprintf (fp, " ");
3068                       tty_fprintf (fp, "%02X", pk->seckey_info->iv[i]);
3069                     }
3070                 }
3071               else
3072                 {
3073                   /* Unknown card: Print all. */
3074                   for (i = 0; i < pk->seckey_info->ivlen; i++)
3075                     tty_fprintf (fp, "%02X", pk->seckey_info->iv[i]);
3076                 }
3077               tty_fprintf (fp, "\n");
3078             }
3079
3080           if (node->pkt->pkttype == PKT_PUBLIC_KEY
3081               || node->pkt->pkttype == PKT_SECRET_KEY)
3082             {
3083               if (opt.trust_model != TM_ALWAYS)
3084                 {
3085                   tty_fprintf (fp, "%*s",
3086                                opt.legacy_list_mode?
3087                                ((int) keystrlen () + 13):5, "");
3088                   /* Ownertrust is only meaningful for the PGP or
3089                      classic trust models */
3090                   if (opt.trust_model == TM_PGP
3091                       || opt.trust_model == TM_CLASSIC)
3092                     {
3093                       int width = 14 - strlen (otrust);
3094                       if (width <= 0)
3095                         width = 1;
3096                       tty_fprintf (fp, _("trust: %s"), otrust);
3097                       tty_fprintf (fp, "%*s", width, "");
3098                     }
3099
3100                   tty_fprintf (fp, _("validity: %s"), trust);
3101                   tty_fprintf (fp, "\n");
3102                 }
3103               if (node->pkt->pkttype == PKT_PUBLIC_KEY
3104                   && (get_ownertrust (pk) & TRUST_FLAG_DISABLED))
3105                 {
3106                   tty_fprintf (fp, "*** ");
3107                   tty_fprintf (fp, _("This key has been disabled"));
3108                   tty_fprintf (fp, "\n");
3109                 }
3110             }
3111
3112           if ((node->pkt->pkttype == PKT_PUBLIC_KEY
3113                || node->pkt->pkttype == PKT_SECRET_KEY) && with_fpr)
3114             {
3115               print_fingerprint (fp, pk, 2);
3116               tty_fprintf (fp, "\n");
3117             }
3118         }
3119     }
3120
3121   show_names (fp,
3122               keyblock, primary, only_marked ? NODFLG_MARK_A : 0, with_prefs);
3123
3124   if (do_warn && !nowarn)
3125     tty_fprintf (fp, _("Please note that the shown key validity"
3126                        " is not necessarily correct\n"
3127                        "unless you restart the program.\n"));
3128 }
3129
3130
3131 /* Display basic key information.  This function is suitable to show
3132    information on the key without any dependencies on the trustdb or
3133    any other internal GnuPG stuff.  KEYBLOCK may either be a public or
3134    a secret key.*/
3135 void
3136 show_basic_key_info (KBNODE keyblock)
3137 {
3138   KBNODE node;
3139   int i;
3140   char pkstrbuf[PUBKEY_STRING_SIZE];
3141
3142   /* The primary key */
3143   for (node = keyblock; node; node = node->next)
3144     {
3145       if (node->pkt->pkttype == PKT_PUBLIC_KEY
3146           || node->pkt->pkttype == PKT_SECRET_KEY)
3147         {
3148           PKT_public_key *pk = node->pkt->pkt.public_key;
3149
3150           /* Note, we use the same format string as in other show
3151              functions to make the translation job easier. */
3152           tty_printf ("%s  %s/%s  ",
3153                       node->pkt->pkttype == PKT_PUBLIC_KEY ? "pub" :
3154                       node->pkt->pkttype == PKT_PUBLIC_SUBKEY ? "sub" :
3155                       node->pkt->pkttype == PKT_SECRET_KEY ? "sec" :"ssb",
3156                       pubkey_string (pk, pkstrbuf, sizeof pkstrbuf),
3157                       keystr_from_pk (pk));
3158           tty_printf (_("created: %s"), datestr_from_pk (pk));
3159           tty_printf ("  ");
3160           tty_printf (_("expires: %s"), expirestr_from_pk (pk));
3161           tty_printf ("\n");
3162           print_fingerprint (NULL, pk, 3);
3163           tty_printf ("\n");
3164         }
3165     }
3166
3167   /* The user IDs. */
3168   for (i = 0, node = keyblock; node; node = node->next)
3169     {
3170       if (node->pkt->pkttype == PKT_USER_ID)
3171         {
3172           PKT_user_id *uid = node->pkt->pkt.user_id;
3173           ++i;
3174
3175           tty_printf ("     ");
3176           if (uid->is_revoked)
3177             tty_printf ("[%s] ", _("revoked"));
3178           else if (uid->is_expired)
3179             tty_printf ("[%s] ", _("expired"));
3180           tty_print_utf8_string (uid->name, uid->len);
3181           tty_printf ("\n");
3182         }
3183     }
3184 }
3185
3186 static void
3187 show_key_and_fingerprint (KBNODE keyblock)
3188 {
3189   KBNODE node;
3190   PKT_public_key *pk = NULL;
3191   char pkstrbuf[PUBKEY_STRING_SIZE];
3192
3193   for (node = keyblock; node; node = node->next)
3194     {
3195       if (node->pkt->pkttype == PKT_PUBLIC_KEY)
3196         {
3197           pk = node->pkt->pkt.public_key;
3198           tty_printf ("pub   %s/%s %s ",
3199                       pubkey_string (pk, pkstrbuf, sizeof pkstrbuf),
3200                       keystr_from_pk(pk),
3201                       datestr_from_pk (pk));
3202         }
3203       else if (node->pkt->pkttype == PKT_USER_ID)
3204         {
3205           PKT_user_id *uid = node->pkt->pkt.user_id;
3206           tty_print_utf8_string (uid->name, uid->len);
3207           break;
3208         }
3209     }
3210   tty_printf ("\n");
3211   if (pk)
3212     print_fingerprint (NULL, pk, 2);
3213 }
3214
3215
3216 /* Show a warning if no uids on the key have the primary uid flag
3217    set. */
3218 static void
3219 no_primary_warning (KBNODE keyblock)
3220 {
3221   KBNODE node;
3222   int have_primary = 0, uid_count = 0;
3223
3224   /* TODO: if we ever start behaving differently with a primary or
3225      non-primary attribute ID, we will need to check for attributes
3226      here as well. */
3227
3228   for (node = keyblock; node; node = node->next)
3229     {
3230       if (node->pkt->pkttype == PKT_USER_ID
3231           && node->pkt->pkt.user_id->attrib_data == NULL)
3232         {
3233           uid_count++;
3234
3235           if (node->pkt->pkt.user_id->is_primary == 2)
3236             {
3237               have_primary = 1;
3238               break;
3239             }
3240         }
3241     }
3242
3243   if (uid_count > 1 && !have_primary)
3244     log_info (_
3245               ("WARNING: no user ID has been marked as primary.  This command"
3246                " may\n              cause a different user ID to become"
3247                " the assumed primary.\n"));
3248 }
3249
3250
3251 /* Print a warning if the latest encryption subkey expires soon.  This
3252    function is called after the expire data of the primary key has
3253    been changed.  */
3254 static void
3255 subkey_expire_warning (kbnode_t keyblock)
3256 {
3257   u32 curtime = make_timestamp ();
3258   kbnode_t node;
3259   PKT_public_key *pk;
3260   /* u32 mainexpire = 0; */
3261   u32 subexpire = 0;
3262   u32 latest_date = 0;
3263
3264   for (node = keyblock; node; node = node->next)
3265     {
3266       /* if (node->pkt->pkttype == PKT_PUBLIC_KEY) */
3267       /*   { */
3268       /*     pk = node->pkt->pkt.public_key; */
3269       /*     mainexpire = pk->expiredate; */
3270       /*   } */
3271
3272       if (node->pkt->pkttype != PKT_PUBLIC_SUBKEY)
3273         continue;
3274       pk = node->pkt->pkt.public_key;
3275
3276       if (!pk->flags.valid)
3277         continue;
3278       if (pk->flags.revoked)
3279         continue;
3280       if (pk->timestamp > curtime)
3281         continue; /* Ignore future keys.  */
3282       if (!(pk->pubkey_usage & PUBKEY_USAGE_ENC))
3283         continue; /* Not an encryption key.  */
3284
3285       if (pk->timestamp > latest_date || (!pk->timestamp && !latest_date))
3286         {
3287           latest_date = pk->timestamp;
3288           subexpire = pk->expiredate;
3289         }
3290     }
3291
3292   if (!subexpire)
3293     return;  /* No valid subkey with an expiration time.  */
3294
3295   if (curtime + (10*86400) > subexpire)
3296     {
3297       log_info (_("WARNING: Your encryption subkey expires soon.\n"));
3298       log_info (_("You may want to change its expiration date too.\n"));
3299     }
3300 }
3301
3302
3303 /*
3304  * Ask for a new user id, add the self-signature, and update the
3305  * keyblock.  If UIDSTRING is not NULL the user ID is generated
3306  * unattended using that string.  UIDSTRING is expected to be utf-8
3307  * encoded and white space trimmed.  Returns true if there is a new
3308  * user id.
3309  */
3310 static int
3311 menu_adduid (kbnode_t pub_keyblock, int photo, const char *photo_name,
3312              const char *uidstring)
3313 {
3314   PKT_user_id *uid;
3315   PKT_public_key *pk = NULL;
3316   PKT_signature *sig = NULL;
3317   PACKET *pkt;
3318   KBNODE node;
3319   KBNODE pub_where = NULL;
3320   gpg_error_t err;
3321
3322   if (photo && uidstring)
3323     return 0;  /* Not allowed.  */
3324
3325   for (node = pub_keyblock; node; pub_where = node, node = node->next)
3326     {
3327       if (node->pkt->pkttype == PKT_PUBLIC_KEY)
3328         pk = node->pkt->pkt.public_key;
3329       else if (node->pkt->pkttype == PKT_PUBLIC_SUBKEY)
3330         break;
3331     }
3332   if (!node) /* No subkey.  */
3333     pub_where = NULL;
3334   assert (pk);
3335
3336   if (photo)
3337     {
3338       int hasattrib = 0;
3339
3340       for (node = pub_keyblock; node; node = node->next)
3341         if (node->pkt->pkttype == PKT_USER_ID &&
3342             node->pkt->pkt.user_id->attrib_data != NULL)
3343           {
3344             hasattrib = 1;
3345             break;
3346           }
3347
3348       /* It is legal but bad for compatibility to add a photo ID to a
3349          v3 key as it means that PGP2 will not be able to use that key
3350          anymore.  Also, PGP may not expect a photo on a v3 key.
3351          Don't bother to ask this if the key already has a photo - any
3352          damage has already been done at that point. -dms */
3353       if (pk->version == 3 && !hasattrib)
3354         {
3355           if (opt.expert)
3356             {
3357               tty_printf (_("WARNING: This is a PGP2-style key.  "
3358                             "Adding a photo ID may cause some versions\n"
3359                             "         of PGP to reject this key.\n"));
3360
3361               if (!cpr_get_answer_is_yes ("keyedit.v3_photo.okay",
3362                                           _("Are you sure you still want "
3363                                             "to add it? (y/N) ")))
3364                 return 0;
3365             }
3366           else
3367             {
3368               tty_printf (_("You may not add a photo ID to "
3369                             "a PGP2-style key.\n"));
3370               return 0;
3371             }
3372         }
3373
3374       uid = generate_photo_id (pk, photo_name);
3375     }
3376   else
3377     uid = generate_user_id (pub_keyblock, uidstring);
3378   if (!uid)
3379     {
3380       if (uidstring)
3381         log_error ("%s", _("Such a user ID already exists on this key!\n"));
3382       return 0;
3383     }
3384
3385   err = make_keysig_packet (&sig, pk, uid, NULL, pk, 0x13, 0, 0, 0,
3386                             keygen_add_std_prefs, pk, NULL);
3387   if (err)
3388     {
3389       log_error ("signing failed: %s\n", gpg_strerror (err));
3390       free_user_id (uid);
3391       return 0;
3392     }
3393
3394   /* Insert/append to public keyblock */
3395   pkt = xmalloc_clear (sizeof *pkt);
3396   pkt->pkttype = PKT_USER_ID;
3397   pkt->pkt.user_id = uid;
3398   node = new_kbnode (pkt);
3399   if (pub_where)
3400     insert_kbnode (pub_where, node, 0);
3401   else
3402     add_kbnode (pub_keyblock, node);
3403   pkt = xmalloc_clear (sizeof *pkt);
3404   pkt->pkttype = PKT_SIGNATURE;
3405   pkt->pkt.signature = copy_signature (NULL, sig);
3406   if (pub_where)
3407     insert_kbnode (node, new_kbnode (pkt), 0);
3408   else
3409     add_kbnode (pub_keyblock, new_kbnode (pkt));
3410   return 1;
3411 }
3412
3413
3414 /*
3415  * Remove all selected userids from the keyring
3416  */
3417 static void
3418 menu_deluid (KBNODE pub_keyblock)
3419 {
3420   KBNODE node;
3421   int selected = 0;
3422
3423   for (node = pub_keyblock; node; node = node->next)
3424     {
3425       if (node->pkt->pkttype == PKT_USER_ID)
3426         {
3427           selected = node->flag & NODFLG_SELUID;
3428           if (selected)
3429             {
3430               /* Only cause a trust update if we delete a
3431                  non-revoked user id */
3432               if (!node->pkt->pkt.user_id->is_revoked)
3433                 update_trust = 1;
3434               delete_kbnode (node);
3435             }
3436         }
3437       else if (selected && node->pkt->pkttype == PKT_SIGNATURE)
3438         delete_kbnode (node);
3439       else if (node->pkt->pkttype == PKT_PUBLIC_SUBKEY)
3440         selected = 0;
3441     }
3442   commit_kbnode (&pub_keyblock);
3443 }
3444
3445
3446 static int
3447 menu_delsig (KBNODE pub_keyblock)
3448 {
3449   KBNODE node;
3450   PKT_user_id *uid = NULL;
3451   int changed = 0;
3452
3453   for (node = pub_keyblock; node; node = node->next)
3454     {
3455       if (node->pkt->pkttype == PKT_USER_ID)
3456         {
3457           uid = (node->flag & NODFLG_SELUID) ? node->pkt->pkt.user_id : NULL;
3458         }
3459       else if (uid && node->pkt->pkttype == PKT_SIGNATURE)
3460         {
3461           int okay, valid, selfsig, inv_sig, no_key, other_err;
3462
3463           tty_printf ("uid  ");
3464           tty_print_utf8_string (uid->name, uid->len);
3465           tty_printf ("\n");
3466
3467           okay = inv_sig = no_key = other_err = 0;
3468           if (opt.with_colons)
3469             valid = print_and_check_one_sig_colon (pub_keyblock, node,
3470                                                    &inv_sig, &no_key,
3471                                                    &other_err, &selfsig, 1);
3472           else
3473             valid = print_and_check_one_sig (pub_keyblock, node,
3474                                              &inv_sig, &no_key, &other_err,
3475                                              &selfsig, 1);
3476
3477           if (valid)
3478             {
3479               okay = cpr_get_answer_yes_no_quit
3480                 ("keyedit.delsig.valid",
3481                  _("Delete this good signature? (y/N/q)"));
3482
3483               /* Only update trust if we delete a good signature.
3484                  The other two cases do not affect trust. */
3485               if (okay)
3486                 update_trust = 1;
3487             }
3488           else if (inv_sig || other_err)
3489             okay = cpr_get_answer_yes_no_quit
3490               ("keyedit.delsig.invalid",
3491                _("Delete this invalid signature? (y/N/q)"));
3492           else if (no_key)
3493             okay = cpr_get_answer_yes_no_quit
3494               ("keyedit.delsig.unknown",
3495                _("Delete this unknown signature? (y/N/q)"));
3496
3497           if (okay == -1)
3498             break;
3499           if (okay && selfsig
3500               && !cpr_get_answer_is_yes
3501               ("keyedit.delsig.selfsig",
3502                _("Really delete this self-signature? (y/N)")))
3503             okay = 0;
3504           if (okay)
3505             {
3506               delete_kbnode (node);
3507               changed++;
3508             }
3509
3510         }
3511       else if (node->pkt->pkttype == PKT_PUBLIC_SUBKEY)
3512         uid = NULL;
3513     }
3514
3515   if (changed)
3516     {
3517       commit_kbnode (&pub_keyblock);
3518       tty_printf (changed == 1 ? _("Deleted %d signature.\n")
3519                   : _("Deleted %d signatures.\n"), changed);
3520     }
3521   else
3522     tty_printf (_("Nothing deleted.\n"));
3523
3524   return changed;
3525 }
3526
3527
3528 static int
3529 menu_clean (KBNODE keyblock, int self_only)
3530 {
3531   KBNODE uidnode;
3532   int modified = 0, select_all = !count_selected_uids (keyblock);
3533
3534   for (uidnode = keyblock->next;
3535        uidnode && uidnode->pkt->pkttype != PKT_PUBLIC_SUBKEY;
3536        uidnode = uidnode->next)
3537     {
3538       if (uidnode->pkt->pkttype == PKT_USER_ID
3539           && (uidnode->flag & NODFLG_SELUID || select_all))
3540         {
3541           int uids = 0, sigs = 0;
3542           char *user = utf8_to_native (uidnode->pkt->pkt.user_id->name,
3543                                        uidnode->pkt->pkt.user_id->len,
3544                                        0);
3545
3546           clean_one_uid (keyblock, uidnode, opt.verbose, self_only, &uids,
3547                          &sigs);
3548           if (uids)
3549             {
3550               const char *reason;
3551
3552               if (uidnode->pkt->pkt.user_id->is_revoked)
3553                 reason = _("revoked");
3554               else if (uidnode->pkt->pkt.user_id->is_expired)
3555                 reason = _("expired");
3556               else
3557                 reason = _("invalid");
3558
3559               tty_printf (_("User ID \"%s\" compacted: %s\n"), user, reason);
3560
3561               modified = 1;
3562             }
3563           else if (sigs)
3564             {
3565               tty_printf (sigs == 1 ?
3566                           _("User ID \"%s\": %d signature removed\n") :
3567                           _("User ID \"%s\": %d signatures removed\n"),
3568                           user, sigs);
3569
3570               modified = 1;
3571             }
3572           else
3573             {
3574               tty_printf (self_only == 1 ?
3575                           _("User ID \"%s\": already minimized\n") :
3576                           _("User ID \"%s\": already clean\n"), user);
3577             }
3578
3579           xfree (user);
3580         }
3581     }
3582
3583   return modified;
3584 }
3585
3586
3587 /*
3588  * Remove some of the secondary keys
3589  */
3590 static void
3591 menu_delkey (KBNODE pub_keyblock)
3592 {
3593   KBNODE node;
3594   int selected = 0;
3595
3596   for (node = pub_keyblock; node; node = node->next)
3597     {
3598       if (node->pkt->pkttype == PKT_PUBLIC_SUBKEY)
3599         {
3600           selected = node->flag & NODFLG_SELKEY;
3601           if (selected)
3602             delete_kbnode (node);
3603         }
3604       else if (selected && node->pkt->pkttype == PKT_SIGNATURE)
3605         delete_kbnode (node);
3606       else
3607         selected = 0;
3608     }
3609   commit_kbnode (&pub_keyblock);
3610
3611   /* No need to set update_trust here since signing keys are no
3612      longer used to certify other keys, so there is no change in
3613      trust when revoking/removing them.   */
3614 }
3615
3616
3617 /*
3618  * Ask for a new revoker, create the self-signature and put it into
3619  * the keyblock.  Returns true if there is a new revoker.
3620  */
3621 static int
3622 menu_addrevoker (ctrl_t ctrl, kbnode_t pub_keyblock, int sensitive)
3623 {
3624   PKT_public_key *pk = NULL;
3625   PKT_public_key *revoker_pk = NULL;
3626   PKT_signature *sig = NULL;
3627   PACKET *pkt;
3628   struct revocation_key revkey;
3629   size_t fprlen;
3630   int rc;
3631
3632   assert (pub_keyblock->pkt->pkttype == PKT_PUBLIC_KEY);
3633
3634   pk = pub_keyblock->pkt->pkt.public_key;
3635
3636   if (pk->numrevkeys == 0 && pk->version == 3)
3637     {
3638       /* It is legal but bad for compatibility to add a revoker to a
3639          v3 key as it means that PGP2 will not be able to use that key
3640          anymore.  Also, PGP may not expect a revoker on a v3 key.
3641          Don't bother to ask this if the key already has a revoker -
3642          any damage has already been done at that point. -dms */
3643       if (opt.expert)
3644         {
3645           tty_printf (_("WARNING: This is a PGP 2.x-style key.  "
3646                         "Adding a designated revoker may cause\n"
3647                         "         some versions of PGP to reject this key.\n"));
3648
3649           if (!cpr_get_answer_is_yes ("keyedit.v3_revoker.okay",
3650                                       _("Are you sure you still want "
3651                                         "to add it? (y/N) ")))
3652             return 0;
3653         }
3654       else
3655         {
3656           tty_printf (_("You may not add a designated revoker to "
3657                         "a PGP 2.x-style key.\n"));
3658           return 0;
3659         }
3660     }
3661
3662   for (;;)
3663     {
3664       char *answer;
3665
3666       free_public_key (revoker_pk);
3667       revoker_pk = xmalloc_clear (sizeof (*revoker_pk));
3668
3669       tty_printf ("\n");
3670
3671       answer = cpr_get_utf8
3672         ("keyedit.add_revoker",
3673          _("Enter the user ID of the designated revoker: "));
3674       if (answer[0] == '\0' || answer[0] == CONTROL_D)
3675         {
3676           xfree (answer);
3677           goto fail;
3678         }
3679
3680       /* Note that I'm requesting CERT here, which usually implies
3681          primary keys only, but some casual testing shows that PGP and
3682          GnuPG both can handle a designated revocation from a subkey. */
3683       revoker_pk->req_usage = PUBKEY_USAGE_CERT;
3684       rc = get_pubkey_byname (ctrl, NULL, revoker_pk, answer, NULL, NULL, 1, 1);
3685       if (rc)
3686         {
3687           log_error (_("key \"%s\" not found: %s\n"), answer,
3688                      gpg_strerror (rc));
3689           xfree (answer);
3690           continue;
3691         }
3692
3693       xfree (answer);
3694
3695       fingerprint_from_pk (revoker_pk, revkey.fpr, &fprlen);
3696       if (fprlen != 20)
3697         {
3698           log_error (_("cannot appoint a PGP 2.x style key as a "
3699                        "designated revoker\n"));
3700           continue;
3701         }
3702
3703       revkey.class = 0x80;
3704       if (sensitive)
3705         revkey.class |= 0x40;
3706       revkey.algid = revoker_pk->pubkey_algo;
3707
3708       if (cmp_public_keys (revoker_pk, pk) == 0)
3709         {
3710           /* This actually causes no harm (after all, a key that
3711              designates itself as a revoker is the same as a
3712              regular key), but it's easy enough to check. */
3713           log_error (_("you cannot appoint a key as its own "
3714                        "designated revoker\n"));
3715
3716           continue;
3717         }
3718
3719       keyid_from_pk (pk, NULL);
3720
3721       /* Does this revkey already exist? */
3722       if (!pk->revkey && pk->numrevkeys)
3723         BUG ();
3724       else
3725         {
3726           int i;
3727
3728           for (i = 0; i < pk->numrevkeys; i++)
3729             {
3730               if (memcmp (&pk->revkey[i], &revkey,
3731                           sizeof (struct revocation_key)) == 0)
3732                 {
3733                   char buf[50];
3734
3735                   log_error (_("this key has already been designated "
3736                                "as a revoker\n"));
3737
3738                   sprintf (buf, "%08lX%08lX",
3739                            (ulong) pk->keyid[0], (ulong) pk->keyid[1]);
3740                   write_status_text (STATUS_ALREADY_SIGNED, buf);
3741
3742                   break;
3743                 }
3744             }
3745
3746           if (i < pk->numrevkeys)
3747             continue;
3748         }
3749
3750       print_pubkey_info (NULL, revoker_pk);
3751       print_fingerprint (NULL, revoker_pk, 2);
3752       tty_printf ("\n");
3753
3754       tty_printf (_("WARNING: appointing a key as a designated revoker "
3755                     "cannot be undone!\n"));
3756
3757       tty_printf ("\n");
3758
3759       if (!cpr_get_answer_is_yes ("keyedit.add_revoker.okay",
3760                                   _("Are you sure you want to appoint this "
3761                                     "key as a designated revoker? (y/N) ")))
3762         continue;
3763
3764       free_public_key (revoker_pk);
3765       revoker_pk = NULL;
3766       break;
3767     }
3768
3769   rc = make_keysig_packet (&sig, pk, NULL, NULL, pk, 0x1F, 0, 0, 0,
3770                            keygen_add_revkey, &revkey, NULL);
3771   if (rc)
3772     {
3773       log_error ("signing failed: %s\n", gpg_strerror (rc));
3774       goto fail;
3775     }
3776
3777   /* Insert into public keyblock.  */
3778   pkt = xmalloc_clear (sizeof *pkt);
3779   pkt->pkttype = PKT_SIGNATURE;
3780   pkt->pkt.signature = sig;
3781   insert_kbnode (pub_keyblock, new_kbnode (pkt), PKT_SIGNATURE);
3782
3783   return 1;
3784
3785 fail:
3786   if (sig)
3787     free_seckey_enc (sig);
3788   free_public_key (revoker_pk);
3789
3790   return 0;
3791 }
3792
3793
3794 static int
3795 menu_expire (KBNODE pub_keyblock)
3796 {
3797   int n1, signumber, rc;
3798   u32 expiredate;
3799   int mainkey = 0;
3800   PKT_public_key *main_pk, *sub_pk;
3801   PKT_user_id *uid;
3802   KBNODE node;
3803   u32 keyid[2];
3804
3805   n1 = count_selected_keys (pub_keyblock);
3806   if (n1 > 1)
3807     {
3808       tty_printf (_("Please select at most one subkey.\n"));
3809       return 0;
3810     }
3811   else if (n1)
3812     tty_printf (_("Changing expiration time for a subkey.\n"));
3813   else
3814     {
3815       tty_printf (_("Changing expiration time for the primary key.\n"));
3816       mainkey = 1;
3817       no_primary_warning (pub_keyblock);
3818     }
3819
3820   expiredate = ask_expiredate ();
3821
3822   /* Now we can actually change the self-signature(s) */
3823   main_pk = sub_pk = NULL;
3824   uid = NULL;
3825   signumber = 0;
3826   for (node = pub_keyblock; node; node = node->next)
3827     {
3828       if (node->pkt->pkttype == PKT_PUBLIC_KEY)
3829         {
3830           main_pk = node->pkt->pkt.public_key;
3831           keyid_from_pk (main_pk, keyid);
3832           main_pk->expiredate = expiredate;
3833         }
3834       else if (node->pkt->pkttype == PKT_PUBLIC_SUBKEY
3835                && (node->flag & NODFLG_SELKEY))
3836         {
3837           sub_pk = node->pkt->pkt.public_key;
3838           sub_pk->expiredate = expiredate;
3839         }
3840       else if (node->pkt->pkttype == PKT_USER_ID)
3841         uid = node->pkt->pkt.user_id;
3842       else if (main_pk && node->pkt->pkttype == PKT_SIGNATURE
3843                && (mainkey || sub_pk))
3844         {
3845           PKT_signature *sig = node->pkt->pkt.signature;
3846           if (keyid[0] == sig->keyid[0] && keyid[1] == sig->keyid[1]
3847               && ((mainkey && uid
3848                    && uid->created && (sig->sig_class & ~3) == 0x10)
3849                   || (!mainkey && sig->sig_class == 0x18))
3850               && sig->flags.chosen_selfsig)
3851             {
3852               /* This is a self-signature which is to be replaced.  */
3853               PKT_signature *newsig;
3854               PACKET *newpkt;
3855
3856               signumber++;
3857
3858               if ((mainkey && main_pk->version < 4)
3859                   || (!mainkey && sub_pk->version < 4))
3860                 {
3861                   log_info
3862                     (_("You can't change the expiration date of a v3 key\n"));
3863                   return 0;
3864                 }
3865
3866               if (mainkey)
3867                 rc = update_keysig_packet (&newsig, sig, main_pk, uid, NULL,
3868                                            main_pk, keygen_add_key_expire,
3869                                            main_pk);
3870               else
3871                 rc =
3872                   update_keysig_packet (&newsig, sig, main_pk, NULL, sub_pk,
3873                                         main_pk, keygen_add_key_expire, sub_pk);
3874               if (rc)
3875                 {
3876                   log_error ("make_keysig_packet failed: %s\n",
3877                              gpg_strerror (rc));
3878                   return 0;
3879                 }
3880
3881               /* Replace the packet.  */
3882               newpkt = xmalloc_clear (sizeof *newpkt);
3883               newpkt->pkttype = PKT_SIGNATURE;
3884               newpkt->pkt.signature = newsig;
3885               free_packet (node->pkt);
3886               xfree (node->pkt);
3887               node->pkt = newpkt;
3888               sub_pk = NULL;
3889             }
3890         }
3891     }
3892
3893   update_trust = 1;
3894   return 1;
3895 }
3896
3897
3898 static int
3899 menu_backsign (KBNODE pub_keyblock)
3900 {
3901   int rc, modified = 0;
3902   PKT_public_key *main_pk;
3903   KBNODE node;
3904   u32 timestamp;
3905
3906   assert (pub_keyblock->pkt->pkttype == PKT_PUBLIC_KEY);
3907
3908   merge_keys_and_selfsig (pub_keyblock);
3909   main_pk = pub_keyblock->pkt->pkt.public_key;
3910   keyid_from_pk (main_pk, NULL);
3911
3912   /* We use the same timestamp for all backsigs so that we don't
3913      reveal information about the used machine.  */
3914   timestamp = make_timestamp ();
3915
3916   for (node = pub_keyblock; node; node = node->next)
3917     {
3918       PKT_public_key *sub_pk = NULL;
3919       KBNODE node2, sig_pk = NULL /*,sig_sk = NULL*/;
3920       /* char *passphrase; */
3921
3922       /* Find a signing subkey with no backsig */
3923       if (node->pkt->pkttype == PKT_PUBLIC_SUBKEY)
3924         {
3925           if (node->pkt->pkt.public_key->pubkey_usage & PUBKEY_USAGE_SIG)
3926             {
3927               if (node->pkt->pkt.public_key->flags.backsig)
3928                 tty_printf (_
3929                             ("signing subkey %s is already cross-certified\n"),
3930                             keystr_from_pk (n