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