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