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