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