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