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