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