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