gpg: Replace remaining old error code macros by GPG_ERR_.
[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       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         printf ("%d %d", sig->trust_depth, sig->trust_value);
168
169       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       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 run_subkey_warnings = 0;
1454   int toggle;
1455   int have_commands = !!commands;
1456
1457   if (opt.command_fd != -1)
1458     ;
1459   else if (opt.batch && !have_commands)
1460     {
1461       log_error (_("can't do this in batch mode\n"));
1462       goto leave;
1463     }
1464
1465 #ifdef HAVE_W32_SYSTEM
1466   /* Due to Windows peculiarities we need to make sure that the
1467      trustdb stale check is done before we open another file
1468      (i.e. by searching for a key).  In theory we could make sure
1469      that the files are closed after use but the open/close caches
1470      inhibits that and flushing the cache right before the stale
1471      check is not easy to implement.  Thus we take the easy way out
1472      and run the stale check as early as possible.  Note, that for
1473      non- W32 platforms it is run indirectly trough a call to
1474      get_validity ().  */
1475   check_trustdb_stale ();
1476 #endif
1477
1478   /* Get the public key */
1479   err = get_pubkey_byname (ctrl, NULL, NULL, username, &keyblock, &kdbhd, 1, 1);
1480   if (err)
1481     {
1482       log_error (_("key \"%s\" not found: %s\n"), username, gpg_strerror (err));
1483       goto leave;
1484     }
1485   if (fix_keyblock (keyblock))
1486     modified++;
1487   if (collapse_uids (&keyblock))
1488     modified++;
1489   reorder_keyblock (keyblock);
1490   /* We modified the keyblock, so let's make sure the flags are
1491      right. */
1492   if (modified)
1493     merge_keys_and_selfsig (keyblock);
1494
1495   /* See whether we have a matching secret key.  */
1496   if (seckey_check)
1497     {
1498       have_seckey = !agent_probe_any_secret_key (ctrl, keyblock);
1499       if (have_seckey && !quiet)
1500         tty_printf (_("Secret key is available.\n"));
1501     }
1502
1503   toggle = 0;
1504
1505   /* Main command loop.  */
1506   for (;;)
1507     {
1508       int i, arg_number, photo;
1509       const char *arg_string = "";
1510       char *p;
1511       PKT_public_key *pk = keyblock->pkt->pkt.public_key;
1512
1513       tty_printf ("\n");
1514
1515       if (redisplay && !quiet)
1516         {
1517           show_key_with_all_names (NULL, keyblock, 0, 1, 0, 1, 0, 0);
1518           tty_printf ("\n");
1519           redisplay = 0;
1520         }
1521
1522       if (run_subkey_warnings)
1523         {
1524           run_subkey_warnings = 0;
1525           if (!count_selected_keys (keyblock))
1526             subkey_expire_warning (keyblock);
1527         }
1528
1529       do
1530         {
1531           xfree (answer);
1532           if (have_commands)
1533             {
1534               if (commands)
1535                 {
1536                   answer = xstrdup (commands->d);
1537                   commands = commands->next;
1538                 }
1539               else if (opt.batch)
1540                 {
1541                   answer = xstrdup ("quit");
1542                 }
1543               else
1544                 have_commands = 0;
1545             }
1546           if (!have_commands)
1547             {
1548 #ifdef HAVE_LIBREADLINE
1549               tty_enable_completion (keyedit_completion);
1550 #endif
1551               answer = cpr_get_no_help ("keyedit.prompt", GPG_NAME "> ");
1552               cpr_kill_prompt ();
1553               tty_disable_completion ();
1554             }
1555           trim_spaces (answer);
1556         }
1557       while (*answer == '#');
1558
1559       arg_number = 0; /* Here is the init which egcc complains about.  */
1560       photo = 0;      /* Same here. */
1561       if (!*answer)
1562         cmd = cmdLIST;
1563       else if (*answer == CONTROL_D)
1564         cmd = cmdQUIT;
1565       else if (digitp (answer))
1566         {
1567           cmd = cmdSELUID;
1568           arg_number = atoi (answer);
1569         }
1570       else
1571         {
1572           if ((p = strchr (answer, ' ')))
1573             {
1574               *p++ = 0;
1575               trim_spaces (answer);
1576               trim_spaces (p);
1577               arg_number = atoi (p);
1578               arg_string = p;
1579             }
1580
1581           for (i = 0; cmds[i].name; i++)
1582             {
1583               if (cmds[i].flags & KEYEDIT_TAIL_MATCH)
1584                 {
1585                   size_t l = strlen (cmds[i].name);
1586                   size_t a = strlen (answer);
1587                   if (a >= l)
1588                     {
1589                       if (!ascii_strcasecmp (&answer[a - l], cmds[i].name))
1590                         {
1591                           answer[a - l] = '\0';
1592                           break;
1593                         }
1594                     }
1595                 }
1596               else if (!ascii_strcasecmp (answer, cmds[i].name))
1597                 break;
1598             }
1599           if ((cmds[i].flags & KEYEDIT_NEED_SK) && !have_seckey)
1600             {
1601               tty_printf (_("Need the secret key to do this.\n"));
1602               cmd = cmdNOP;
1603             }
1604           else if (((cmds[i].flags & KEYEDIT_NOT_SK) && have_seckey && toggle)
1605                    || ((cmds[i].flags & KEYEDIT_ONLY_SK) && have_seckey
1606                        && !toggle))
1607             {
1608               tty_printf (_("Please use the command \"toggle\" first.\n"));
1609               cmd = cmdNOP;
1610             }
1611           else
1612             cmd = cmds[i].id;
1613         }
1614
1615       /* Dispatch the command.  */
1616       switch (cmd)
1617         {
1618         case cmdHELP:
1619           for (i = 0; cmds[i].name; i++)
1620             {
1621               if ((cmds[i].flags & KEYEDIT_NEED_SK) && !have_seckey)
1622                 ; /* Skip those item if we do not have the secret key.  */
1623               else if (cmds[i].desc)
1624                 tty_printf ("%-11s %s\n", cmds[i].name, _(cmds[i].desc));
1625             }
1626
1627           tty_printf ("\n");
1628           tty_printf
1629             (_("* The 'sign' command may be prefixed with an 'l' for local "
1630                "signatures (lsign),\n"
1631                "  a 't' for trust signatures (tsign), an 'nr' for "
1632                "non-revocable signatures\n"
1633                "  (nrsign), or any combination thereof (ltsign, "
1634                "tnrsign, etc.).\n"));
1635           break;
1636
1637         case cmdLIST:
1638           redisplay = 1;
1639           break;
1640
1641         case cmdFPR:
1642           show_key_and_fingerprint (keyblock);
1643           break;
1644
1645         case cmdSELUID:
1646           if (strlen (arg_string) == NAMEHASH_LEN * 2)
1647             redisplay = menu_select_uid_namehash (keyblock, arg_string);
1648           else
1649             {
1650               if (*arg_string == '*'
1651                   && (!arg_string[1] || spacep (arg_string + 1)))
1652                 arg_number = -1;        /* Select all. */
1653               redisplay = menu_select_uid (keyblock, arg_number);
1654             }
1655           break;
1656
1657         case cmdSELKEY:
1658           {
1659             if (*arg_string == '*'
1660                 && (!arg_string[1] || spacep (arg_string + 1)))
1661               arg_number = -1;  /* Select all. */
1662             if (menu_select_key (keyblock, arg_number))
1663               redisplay = 1;
1664           }
1665           break;
1666
1667         case cmdCHECK:
1668           check_all_keysigs (keyblock, count_selected_uids (keyblock));
1669           break;
1670
1671         case cmdSIGN:
1672           {
1673             int localsig = 0, nonrevokesig = 0, trustsig = 0, interactive = 0;
1674
1675             if (pk->flags.revoked)
1676               {
1677                 tty_printf (_("Key is revoked."));
1678
1679                 if (opt.expert)
1680                   {
1681                     tty_printf ("  ");
1682                     if (!cpr_get_answer_is_yes
1683                         ("keyedit.sign_revoked.okay",
1684                          _("Are you sure you still want to sign it? (y/N) ")))
1685                       break;
1686                   }
1687                 else
1688                   {
1689                     tty_printf (_("  Unable to sign.\n"));
1690                     break;
1691                   }
1692               }
1693
1694             if (count_uids (keyblock) > 1 && !count_selected_uids (keyblock)
1695                 && !cpr_get_answer_is_yes ("keyedit.sign_all.okay",
1696                                            _("Really sign all user IDs?"
1697                                              " (y/N) ")))
1698               {
1699                 if (opt.interactive)
1700                   interactive = 1;
1701                 else
1702                   {
1703                     tty_printf (_("Hint: Select the user IDs to sign\n"));
1704                     have_commands = 0;
1705                     break;
1706                   }
1707
1708               }
1709             /* What sort of signing are we doing? */
1710             if (!parse_sign_type
1711                 (answer, &localsig, &nonrevokesig, &trustsig))
1712               {
1713                 tty_printf (_("Unknown signature type '%s'\n"), answer);
1714                 break;
1715               }
1716
1717             sign_uids (NULL, keyblock, locusr, &modified,
1718                        localsig, nonrevokesig, trustsig, interactive, 0);
1719           }
1720           break;
1721
1722         case cmdDEBUG:
1723           dump_kbnode (keyblock);
1724           break;
1725
1726         case cmdTOGGLE:
1727           /* The toggle command is a leftover from old gpg versions
1728              where we worked with a secret and a public keyring.  It
1729              is not necessary anymore but we keep this command for the
1730              sake of scripts using it.  */
1731           toggle = !toggle;
1732           redisplay = 1;
1733           break;
1734
1735         case cmdADDPHOTO:
1736           if (RFC2440)
1737             {
1738               tty_printf (_("This command is not allowed while in %s mode.\n"),
1739                           compliance_option_string ());
1740               break;
1741             }
1742           photo = 1;
1743           /* fall through */
1744         case cmdADDUID:
1745           if (menu_adduid (keyblock, photo, arg_string))
1746             {
1747               update_trust = 1;
1748               redisplay = 1;
1749               modified = 1;
1750               merge_keys_and_selfsig (keyblock);
1751             }
1752           break;
1753
1754         case cmdDELUID:
1755           {
1756             int n1;
1757
1758             if (!(n1 = count_selected_uids (keyblock)))
1759               tty_printf (_("You must select at least one user ID.\n"));
1760             else if (real_uids_left (keyblock) < 1)
1761               tty_printf (_("You can't delete the last user ID!\n"));
1762             else if (cpr_get_answer_is_yes
1763                      ("keyedit.remove.uid.okay",
1764                       n1 > 1 ? _("Really remove all selected user IDs? (y/N) ")
1765                       :        _("Really remove this user ID? (y/N) ")))
1766               {
1767                 menu_deluid (keyblock);
1768                 redisplay = 1;
1769                 modified = 1;
1770               }
1771           }
1772           break;
1773
1774         case cmdDELSIG:
1775           {
1776             int n1;
1777
1778             if (!(n1 = count_selected_uids (keyblock)))
1779               tty_printf (_("You must select at least one user ID.\n"));
1780             else if (menu_delsig (keyblock))
1781               {
1782                 /* No redisplay here, because it may scroll away some
1783                  * of the status output of this command.  */
1784                 modified = 1;
1785               }
1786           }
1787           break;
1788
1789         case cmdADDKEY:
1790           if (!generate_subkeypair (ctrl, keyblock))
1791             {
1792               redisplay = 1;
1793               modified = 1;
1794               merge_keys_and_selfsig (keyblock);
1795             }
1796           break;
1797
1798 #ifdef ENABLE_CARD_SUPPORT
1799         case cmdADDCARDKEY:
1800           if (!card_generate_subkey (keyblock))
1801             {
1802               redisplay = 1;
1803               modified = 1;
1804               merge_keys_and_selfsig (keyblock);
1805             }
1806           break;
1807
1808         case cmdKEYTOCARD:
1809           {
1810             KBNODE node = NULL;
1811             switch (count_selected_keys (keyblock))
1812               {
1813               case 0:
1814                 if (cpr_get_answer_is_yes
1815                     ("keyedit.keytocard.use_primary",
1816                      /* TRANSLATORS: Please take care: This is about
1817                         moving the key and not about removing it.  */
1818                      _("Really move the primary key? (y/N) ")))
1819                   node = keyblock;
1820                 break;
1821               case 1:
1822                 for (node = keyblock; node; node = node->next)
1823                   {
1824                     if (node->pkt->pkttype == PKT_PUBLIC_SUBKEY
1825                         && node->flag & NODFLG_SELKEY)
1826                       break;
1827                   }
1828                 break;
1829               default:
1830                 tty_printf (_("You must select exactly one key.\n"));
1831                 break;
1832               }
1833             if (node)
1834               {
1835                 PKT_public_key *xxpk = node->pkt->pkt.public_key;
1836                 if (card_store_subkey (node, xxpk ? xxpk->pubkey_usage : 0))
1837                   {
1838                     redisplay = 1;
1839                     /* Only the secret key has been modified; thus
1840                        there is no need to set the modified flag.  */
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                     /* FIXME:sec_modified = 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)
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           else
2208             tty_printf (_("Key not changed so no update needed.\n"));
2209
2210           if (update_trust)
2211             {
2212               revalidation_mark ();
2213               update_trust = 0;
2214             }
2215           goto leave;
2216
2217         case cmdINVCMD:
2218         default:
2219           tty_printf ("\n");
2220           tty_printf (_("Invalid command  (try \"help\")\n"));
2221           break;
2222         }
2223     } /* End of the main command loop.  */
2224
2225  leave:
2226   release_kbnode (keyblock);
2227   keydb_release (kdbhd);
2228   xfree (answer);
2229 }
2230
2231
2232 /* Change the passphrase of the secret key identified by USERNAME.  */
2233 void
2234 keyedit_passwd (ctrl_t ctrl, const char *username)
2235 {
2236   gpg_error_t err;
2237   PKT_public_key *pk;
2238   kbnode_t keyblock = NULL;
2239
2240   pk = xtrycalloc (1, sizeof *pk);
2241   if (!pk)
2242     {
2243       err = gpg_error_from_syserror ();
2244       goto leave;
2245     }
2246   err = getkey_byname (NULL, pk, username, 1, &keyblock);
2247   if (err)
2248     goto leave;
2249
2250   err = change_passphrase (ctrl, keyblock);
2251
2252 leave:
2253   release_kbnode (keyblock);
2254   free_public_key (pk);
2255   if (err)
2256     {
2257       log_info ("error changing the passphrase for '%s': %s\n",
2258                 username, gpg_strerror (err));
2259       write_status_error ("keyedit.passwd", err);
2260     }
2261   else
2262     write_status_text (STATUS_SUCCESS, "keyedit.passwd");
2263 }
2264
2265
2266 /* Unattended key signing function.  If the key specifified by FPR is
2267    availabale and FPR is the primary fingerprint all user ids of the
2268    user ids of the key are signed using the default signing key.  If
2269    UIDS is an empty list all usable UIDs are signed, if it is not
2270    empty, only those user ids matching one of the entries of the loist
2271    are signed.  With LOCAL being true kthe signatures are marked as
2272    non-exportable.  */
2273 void
2274 keyedit_quick_sign (ctrl_t ctrl, const char *fpr, strlist_t uids,
2275                     strlist_t locusr, int local)
2276 {
2277   gpg_error_t err;
2278   kbnode_t keyblock = NULL;
2279   KEYDB_HANDLE kdbhd = NULL;
2280   int modified = 0;
2281   KEYDB_SEARCH_DESC desc;
2282   PKT_public_key *pk;
2283   kbnode_t node;
2284   strlist_t sl;
2285   int any;
2286
2287 #ifdef HAVE_W32_SYSTEM
2288   /* See keyedit_menu for why we need this.  */
2289   check_trustdb_stale ();
2290 #endif
2291
2292   /* We require a fingerprint because only this uniquely identifies a
2293      key and may thus be used to select a key for unattended key
2294      signing.  */
2295   if (classify_user_id (fpr, &desc, 1)
2296       || !(desc.mode == KEYDB_SEARCH_MODE_FPR
2297            || desc.mode == KEYDB_SEARCH_MODE_FPR16
2298            || desc.mode == KEYDB_SEARCH_MODE_FPR20))
2299     {
2300       log_error (_("\"%s\" is not a fingerprint\n"), fpr);
2301       goto leave;
2302     }
2303   err = get_pubkey_byname (ctrl, NULL, NULL, fpr, &keyblock, &kdbhd, 1, 1);
2304   if (err)
2305     {
2306       log_error (_("key \"%s\" not found: %s\n"), fpr, gpg_strerror (err));
2307       goto leave;
2308     }
2309   if (fix_keyblock (keyblock))
2310     modified++;
2311   if (collapse_uids (&keyblock))
2312     modified++;
2313   reorder_keyblock (keyblock);
2314
2315   /* Check that the primary fingerprint has been given. */
2316   {
2317     byte fprbin[MAX_FINGERPRINT_LEN];
2318     size_t fprlen;
2319
2320     fingerprint_from_pk (keyblock->pkt->pkt.public_key, fprbin, &fprlen);
2321     if (fprlen == 16 && desc.mode == KEYDB_SEARCH_MODE_FPR16
2322         && !memcmp (fprbin, desc.u.fpr, 16))
2323       ;
2324     else if (fprlen == 16 && desc.mode == KEYDB_SEARCH_MODE_FPR
2325              && !memcmp (fprbin, desc.u.fpr, 16)
2326              && !desc.u.fpr[16]
2327              && !desc.u.fpr[17]
2328              && !desc.u.fpr[18]
2329              && !desc.u.fpr[19])
2330       ;
2331     else if (fprlen == 20 && (desc.mode == KEYDB_SEARCH_MODE_FPR20
2332                               || desc.mode == KEYDB_SEARCH_MODE_FPR)
2333              && !memcmp (fprbin, desc.u.fpr, 20))
2334       ;
2335     else
2336       {
2337         log_error (_("\"%s\" is not the primary fingerprint\n"), fpr);
2338         goto leave;
2339       }
2340   }
2341
2342   /* If we modified the keyblock, make sure the flags are right. */
2343   if (modified)
2344     merge_keys_and_selfsig (keyblock);
2345
2346   /* Give some info in verbose.  */
2347   if (opt.verbose)
2348     {
2349       show_key_with_all_names (es_stdout, keyblock, 0,
2350                                1/*with_revoker*/, 1/*with_fingerprint*/,
2351                                0, 0, 1);
2352       es_fflush (es_stdout);
2353     }
2354
2355   pk = keyblock->pkt->pkt.public_key;
2356   if (pk->flags.revoked)
2357     {
2358       if (!opt.verbose)
2359         show_key_with_all_names (es_stdout, keyblock, 0, 0, 0, 0, 0, 1);
2360       log_error ("%s%s", _("Key is revoked."), _("  Unable to sign.\n"));
2361       goto leave;
2362     }
2363
2364   /* Set the flags according to the UIDS list.  Fixme: We may want to
2365      use classify_user_id along with dedicated compare functions so
2366      that we match the same way as in the key lookup. */
2367   any = 0;
2368   menu_select_uid (keyblock, 0);   /* Better clear the flags first. */
2369   for (sl=uids; sl; sl = sl->next)
2370     {
2371       for (node = keyblock; node; node = node->next)
2372         {
2373           if (node->pkt->pkttype == PKT_USER_ID)
2374             {
2375               PKT_user_id *uid = node->pkt->pkt.user_id;
2376
2377               if (!uid->attrib_data
2378                   && ascii_memistr (uid->name, uid->len, sl->d))
2379                 {
2380                   node->flag |= NODFLG_SELUID;
2381                   any = 1;
2382                 }
2383             }
2384         }
2385     }
2386
2387   if (uids && !any)
2388     {
2389       if (!opt.verbose)
2390         show_key_with_all_names (es_stdout, keyblock, 0, 0, 0, 0, 0, 1);
2391       es_fflush (es_stdout);
2392       log_error ("%s  %s", _("No matching user IDs."), _("Nothing to sign.\n"));
2393       goto leave;
2394     }
2395
2396   /* Sign. */
2397   sign_uids (es_stdout, keyblock, locusr, &modified, local, 0, 0, 0, 1);
2398   es_fflush (es_stdout);
2399
2400   if (modified)
2401     {
2402       err = keydb_update_keyblock (kdbhd, keyblock);
2403       if (err)
2404         {
2405           log_error (_("update failed: %s\n"), gpg_strerror (err));
2406           goto leave;
2407         }
2408     }
2409   else
2410     log_info (_("Key not changed so no update needed.\n"));
2411
2412   if (update_trust)
2413     revalidation_mark ();
2414
2415
2416  leave:
2417   release_kbnode (keyblock);
2418   keydb_release (kdbhd);
2419 }
2420
2421
2422 \f
2423 static void
2424 tty_print_notations (int indent, PKT_signature * sig)
2425 {
2426   int first = 1;
2427   struct notation *notation, *nd;
2428
2429   if (indent < 0)
2430     {
2431       first = 0;
2432       indent = -indent;
2433     }
2434
2435   notation = sig_to_notation (sig);
2436
2437   for (nd = notation; nd; nd = nd->next)
2438     {
2439       if (!first)
2440         tty_printf ("%*s", indent, "");
2441       else
2442         first = 0;
2443
2444       tty_print_utf8_string (nd->name, strlen (nd->name));
2445       tty_printf ("=");
2446       tty_print_utf8_string (nd->value, strlen (nd->value));
2447       tty_printf ("\n");
2448     }
2449
2450   free_notation (notation);
2451 }
2452
2453
2454 /*
2455  * Show preferences of a public keyblock.
2456  */
2457 static void
2458 show_prefs (PKT_user_id * uid, PKT_signature * selfsig, int verbose)
2459 {
2460   const prefitem_t fake = { 0, 0 };
2461   const prefitem_t *prefs;
2462   int i;
2463
2464   if (!uid)
2465     return;
2466
2467   if (uid->prefs)
2468     prefs = uid->prefs;
2469   else if (verbose)
2470     prefs = &fake;
2471   else
2472     return;
2473
2474   if (verbose)
2475     {
2476       int any, des_seen = 0, sha1_seen = 0, uncomp_seen = 0;
2477
2478       tty_printf ("     ");
2479       tty_printf (_("Cipher: "));
2480       for (i = any = 0; prefs[i].type; i++)
2481         {
2482           if (prefs[i].type == PREFTYPE_SYM)
2483             {
2484               if (any)
2485                 tty_printf (", ");
2486               any = 1;
2487               /* We don't want to display strings for experimental algos */
2488               if (!openpgp_cipher_test_algo (prefs[i].value)
2489                   && prefs[i].value < 100)
2490                 tty_printf ("%s", openpgp_cipher_algo_name (prefs[i].value));
2491               else
2492                 tty_printf ("[%d]", prefs[i].value);
2493               if (prefs[i].value == CIPHER_ALGO_3DES)
2494                 des_seen = 1;
2495             }
2496         }
2497       if (!des_seen)
2498         {
2499           if (any)
2500             tty_printf (", ");
2501           tty_printf ("%s", openpgp_cipher_algo_name (CIPHER_ALGO_3DES));
2502         }
2503       tty_printf ("\n     ");
2504       tty_printf (_("Digest: "));
2505       for (i = any = 0; prefs[i].type; i++)
2506         {
2507           if (prefs[i].type == PREFTYPE_HASH)
2508             {
2509               if (any)
2510                 tty_printf (", ");
2511               any = 1;
2512               /* We don't want to display strings for experimental algos */
2513               if (!gcry_md_test_algo (prefs[i].value) && prefs[i].value < 100)
2514                 tty_printf ("%s", gcry_md_algo_name (prefs[i].value));
2515               else
2516                 tty_printf ("[%d]", prefs[i].value);
2517               if (prefs[i].value == DIGEST_ALGO_SHA1)
2518                 sha1_seen = 1;
2519             }
2520         }
2521       if (!sha1_seen)
2522         {
2523           if (any)
2524             tty_printf (", ");
2525           tty_printf ("%s", gcry_md_algo_name (DIGEST_ALGO_SHA1));
2526         }
2527       tty_printf ("\n     ");
2528       tty_printf (_("Compression: "));
2529       for (i = any = 0; prefs[i].type; i++)
2530         {
2531           if (prefs[i].type == PREFTYPE_ZIP)
2532             {
2533               const char *s = compress_algo_to_string (prefs[i].value);
2534
2535               if (any)
2536                 tty_printf (", ");
2537               any = 1;
2538               /* We don't want to display strings for experimental algos */
2539               if (s && prefs[i].value < 100)
2540                 tty_printf ("%s", s);
2541               else
2542                 tty_printf ("[%d]", prefs[i].value);
2543               if (prefs[i].value == COMPRESS_ALGO_NONE)
2544                 uncomp_seen = 1;
2545             }
2546         }
2547       if (!uncomp_seen)
2548         {
2549           if (any)
2550             tty_printf (", ");
2551           else
2552             {
2553               tty_printf ("%s", compress_algo_to_string (COMPRESS_ALGO_ZIP));
2554               tty_printf (", ");
2555             }
2556           tty_printf ("%s", compress_algo_to_string (COMPRESS_ALGO_NONE));
2557         }
2558       if (uid->flags.mdc || !uid->flags.ks_modify)
2559         {
2560           tty_printf ("\n     ");
2561           tty_printf (_("Features: "));
2562           any = 0;
2563           if (uid->flags.mdc)
2564             {
2565               tty_printf ("MDC");
2566               any = 1;
2567             }
2568           if (!uid->flags.ks_modify)
2569             {
2570               if (any)
2571                 tty_printf (", ");
2572               tty_printf (_("Keyserver no-modify"));
2573             }
2574         }
2575       tty_printf ("\n");
2576
2577       if (selfsig)
2578         {
2579           const byte *pref_ks;
2580           size_t pref_ks_len;
2581
2582           pref_ks = parse_sig_subpkt (selfsig->hashed,
2583                                       SIGSUBPKT_PREF_KS, &pref_ks_len);
2584           if (pref_ks && pref_ks_len)
2585             {
2586               tty_printf ("     ");
2587               tty_printf (_("Preferred keyserver: "));
2588               tty_print_utf8_string (pref_ks, pref_ks_len);
2589               tty_printf ("\n");
2590             }
2591
2592           if (selfsig->flags.notation)
2593             {
2594               tty_printf ("     ");
2595               tty_printf (_("Notations: "));
2596               tty_print_notations (5 + strlen (_("Notations: ")), selfsig);
2597             }
2598         }
2599     }
2600   else
2601     {
2602       tty_printf ("    ");
2603       for (i = 0; prefs[i].type; i++)
2604         {
2605           tty_printf (" %c%d", prefs[i].type == PREFTYPE_SYM ? 'S' :
2606                       prefs[i].type == PREFTYPE_HASH ? 'H' :
2607                       prefs[i].type == PREFTYPE_ZIP ? 'Z' : '?',
2608                       prefs[i].value);
2609         }
2610       if (uid->flags.mdc)
2611         tty_printf (" [mdc]");
2612       if (!uid->flags.ks_modify)
2613         tty_printf (" [no-ks-modify]");
2614       tty_printf ("\n");
2615     }
2616 }
2617
2618
2619 /* This is the version of show_key_with_all_names used when
2620    opt.with_colons is used.  It prints all available data in a easy to
2621    parse format and does not translate utf8 */
2622 static void
2623 show_key_with_all_names_colon (estream_t fp, kbnode_t keyblock)
2624 {
2625   KBNODE node;
2626   int i, j, ulti_hack = 0;
2627   byte pk_version = 0;
2628   PKT_public_key *primary = NULL;
2629
2630   if (!fp)
2631     fp = es_stdout;
2632
2633   /* the keys */
2634   for (node = keyblock; node; node = node->next)
2635     {
2636       if (node->pkt->pkttype == PKT_PUBLIC_KEY
2637           || (node->pkt->pkttype == PKT_PUBLIC_SUBKEY))
2638         {
2639           PKT_public_key *pk = node->pkt->pkt.public_key;
2640           u32 keyid[2];
2641
2642           if (node->pkt->pkttype == PKT_PUBLIC_KEY)
2643             {
2644               pk_version = pk->version;
2645               primary = pk;
2646             }
2647
2648           keyid_from_pk (pk, keyid);
2649
2650           es_fputs (node->pkt->pkttype == PKT_PUBLIC_KEY ? "pub:" : "sub:",
2651                     fp);
2652           if (!pk->flags.valid)
2653             es_putc ('i', fp);
2654           else if (pk->flags.revoked)
2655             es_putc ('r', fp);
2656           else if (pk->has_expired)
2657             es_putc ('e', fp);
2658           else if (!(opt.fast_list_mode || opt.no_expensive_trust_checks))
2659             {
2660               int trust = get_validity_info (pk, NULL);
2661               if (trust == 'u')
2662                 ulti_hack = 1;
2663               es_putc (trust, fp);
2664             }
2665
2666           es_fprintf (fp, ":%u:%d:%08lX%08lX:%lu:%lu::",
2667                       nbits_from_pk (pk),
2668                       pk->pubkey_algo,
2669                       (ulong) keyid[0], (ulong) keyid[1],
2670                       (ulong) pk->timestamp, (ulong) pk->expiredate);
2671           if (node->pkt->pkttype == PKT_PUBLIC_KEY
2672               && !(opt.fast_list_mode || opt.no_expensive_trust_checks))
2673             es_putc (get_ownertrust_info (pk), fp);
2674           es_putc (':', fp);
2675           es_putc (':', fp);
2676           es_putc (':', fp);
2677           /* Print capabilities.  */
2678           if ((pk->pubkey_usage & PUBKEY_USAGE_ENC))
2679             es_putc ('e', fp);
2680           if ((pk->pubkey_usage & PUBKEY_USAGE_SIG))
2681             es_putc ('s', fp);
2682           if ((pk->pubkey_usage & PUBKEY_USAGE_CERT))
2683             es_putc ('c', fp);
2684           if ((pk->pubkey_usage & PUBKEY_USAGE_AUTH))
2685             es_putc ('a', fp);
2686           es_putc ('\n', fp);
2687
2688           print_fingerprint (fp, pk, 0);
2689           print_revokers (fp, pk);
2690         }
2691     }
2692
2693   /* the user ids */
2694   i = 0;
2695   for (node = keyblock; node; node = node->next)
2696     {
2697       if (node->pkt->pkttype == PKT_USER_ID)
2698         {
2699           PKT_user_id *uid = node->pkt->pkt.user_id;
2700
2701           ++i;
2702
2703           if (uid->attrib_data)
2704             es_fputs ("uat:", fp);
2705           else
2706             es_fputs ("uid:", fp);
2707
2708           if (uid->is_revoked)
2709             es_fputs ("r::::::::", fp);
2710           else if (uid->is_expired)
2711             es_fputs ("e::::::::", fp);
2712           else if (opt.fast_list_mode || opt.no_expensive_trust_checks)
2713             es_fputs ("::::::::", fp);
2714           else
2715             {
2716               int uid_validity;
2717
2718               if (primary && !ulti_hack)
2719                 uid_validity = get_validity_info (primary, uid);
2720               else
2721                 uid_validity = 'u';
2722               es_fprintf (fp, "%c::::::::", uid_validity);
2723             }
2724
2725           if (uid->attrib_data)
2726             es_fprintf (fp, "%u %lu", uid->numattribs, uid->attrib_len);
2727           else
2728             es_write_sanitized (fp, uid->name, uid->len, ":", NULL);
2729
2730           es_putc (':', fp);
2731           /* signature class */
2732           es_putc (':', fp);
2733           /* capabilities */
2734           es_putc (':', fp);
2735           /* preferences */
2736           if (pk_version > 3 || uid->selfsigversion > 3)
2737             {
2738               const prefitem_t *prefs = uid->prefs;
2739
2740               for (j = 0; prefs && prefs[j].type; j++)
2741                 {
2742                   if (j)
2743                     es_putc (' ', fp);
2744                   es_fprintf (fp,
2745                               "%c%d", prefs[j].type == PREFTYPE_SYM ? 'S' :
2746                               prefs[j].type == PREFTYPE_HASH ? 'H' :
2747                               prefs[j].type == PREFTYPE_ZIP ? 'Z' : '?',
2748                               prefs[j].value);
2749                 }
2750               if (uid->flags.mdc)
2751                 es_fputs (",mdc", fp);
2752               if (!uid->flags.ks_modify)
2753                 es_fputs (",no-ks-modify", fp);
2754             }
2755           es_putc (':', fp);
2756           /* flags */
2757           es_fprintf (fp, "%d,", i);
2758           if (uid->is_primary)
2759             es_putc ('p', fp);
2760           if (uid->is_revoked)
2761             es_putc ('r', fp);
2762           if (uid->is_expired)
2763             es_putc ('e', fp);
2764           if ((node->flag & NODFLG_SELUID))
2765             es_putc ('s', fp);
2766           if ((node->flag & NODFLG_MARK_A))
2767             es_putc ('m', fp);
2768           es_putc (':', fp);
2769           es_putc ('\n', fp);
2770         }
2771     }
2772 }
2773
2774
2775 static void
2776 show_names (estream_t fp,
2777             KBNODE keyblock, PKT_public_key * pk, unsigned int flag,
2778             int with_prefs)
2779 {
2780   KBNODE node;
2781   int i = 0;
2782
2783   for (node = keyblock; node; node = node->next)
2784     {
2785       if (node->pkt->pkttype == PKT_USER_ID && !is_deleted_kbnode (node))
2786         {
2787           PKT_user_id *uid = node->pkt->pkt.user_id;
2788           ++i;
2789           if (!flag || (flag && (node->flag & flag)))
2790             {
2791               if (!(flag & NODFLG_MARK_A) && pk)
2792                 tty_fprintf (fp, "%s ", uid_trust_string_fixed (pk, uid));
2793
2794               if (flag & NODFLG_MARK_A)
2795                 tty_fprintf (fp, "     ");
2796               else if (node->flag & NODFLG_SELUID)
2797                 tty_fprintf (fp, "(%d)* ", i);
2798               else if (uid->is_primary)
2799                 tty_fprintf (fp, "(%d). ", i);
2800               else
2801                 tty_fprintf (fp, "(%d)  ", i);
2802               tty_print_utf8_string2 (fp, uid->name, uid->len, 0);
2803               tty_fprintf (fp, "\n");
2804               if (with_prefs && pk)
2805                 {
2806                   if (pk->version > 3 || uid->selfsigversion > 3)
2807                     {
2808                       PKT_signature *selfsig = NULL;
2809                       KBNODE signode;
2810
2811                       for (signode = node->next;
2812                            signode && signode->pkt->pkttype == PKT_SIGNATURE;
2813                            signode = signode->next)
2814                         {
2815                           if (signode->pkt->pkt.signature->
2816                               flags.chosen_selfsig)
2817                             {
2818                               selfsig = signode->pkt->pkt.signature;
2819                               break;
2820                             }
2821                         }
2822
2823                       show_prefs (uid, selfsig, with_prefs == 2);
2824                     }
2825                   else
2826                     tty_fprintf (fp, _("There are no preferences on a"
2827                                        " PGP 2.x-style user ID.\n"));
2828                 }
2829             }
2830         }
2831     }
2832 }
2833
2834
2835 /*
2836  * Display the key a the user ids, if only_marked is true, do only so
2837  * for user ids with mark A flag set and do not display the index
2838  * number.  If FP is not NULL print to the given stream and not to the
2839  * tty (ignored in with-colons mode).
2840  */
2841 static void
2842 show_key_with_all_names (estream_t fp,
2843                          KBNODE keyblock, int only_marked, int with_revoker,
2844                          int with_fpr, int with_subkeys, int with_prefs,
2845                          int nowarn)
2846 {
2847   KBNODE node;
2848   int i;
2849   int do_warn = 0;
2850   PKT_public_key *primary = NULL;
2851   char pkstrbuf[PUBKEY_STRING_SIZE];
2852
2853   if (opt.with_colons)
2854     {
2855       show_key_with_all_names_colon (fp, keyblock);
2856       return;
2857     }
2858
2859   /* the keys */
2860   for (node = keyblock; node; node = node->next)
2861     {
2862       if (node->pkt->pkttype == PKT_PUBLIC_KEY
2863           || (with_subkeys && node->pkt->pkttype == PKT_PUBLIC_SUBKEY
2864               && !is_deleted_kbnode (node)))
2865         {
2866           PKT_public_key *pk = node->pkt->pkt.public_key;
2867           const char *otrust = "err";
2868           const char *trust = "err";
2869
2870           if (node->pkt->pkttype == PKT_PUBLIC_KEY)
2871             {
2872               /* do it here, so that debug messages don't clutter the
2873                * output */
2874               static int did_warn = 0;
2875
2876               trust = get_validity_string (pk, NULL);
2877               otrust = get_ownertrust_string (pk);
2878
2879               /* Show a warning once */
2880               if (!did_warn
2881                   && (get_validity (pk, NULL) & TRUST_FLAG_PENDING_CHECK))
2882                 {
2883                   did_warn = 1;
2884                   do_warn = 1;
2885                 }
2886
2887               primary = pk;
2888             }
2889
2890           if (pk->flags.revoked)
2891             {
2892               char *user = get_user_id_string_native (pk->revoked.keyid);
2893               tty_fprintf (fp,
2894                            _("The following key was revoked on"
2895                             " %s by %s key %s\n"),
2896                           revokestr_from_pk (pk),
2897                           gcry_pk_algo_name (pk->revoked.algo), user);
2898               xfree (user);
2899             }
2900
2901           if (with_revoker)
2902             {
2903               if (!pk->revkey && pk->numrevkeys)
2904                 BUG ();
2905               else
2906                 for (i = 0; i < pk->numrevkeys; i++)
2907                   {
2908                     u32 r_keyid[2];
2909                     char *user;
2910                     const char *algo;
2911
2912                     algo = gcry_pk_algo_name (pk->revkey[i].algid);
2913                     keyid_from_fingerprint (pk->revkey[i].fpr,
2914                                             MAX_FINGERPRINT_LEN, r_keyid);
2915
2916                     user = get_user_id_string_native (r_keyid);
2917                     tty_fprintf (fp,
2918                                  _("This key may be revoked by %s key %s"),
2919                                  algo ? algo : "?", user);
2920
2921                     if (pk->revkey[i].class & 0x40)
2922                       {
2923                         tty_fprintf (fp, " ");
2924                         tty_fprintf (fp, _("(sensitive)"));
2925                       }
2926
2927                     tty_fprintf (fp, "\n");
2928                     xfree (user);
2929                   }
2930             }
2931
2932           keyid_from_pk (pk, NULL);
2933           tty_fprintf (fp, "%s%c %s/%s",
2934                       node->pkt->pkttype == PKT_PUBLIC_KEY ? "pub" :
2935                       node->pkt->pkttype == PKT_PUBLIC_SUBKEY ? "sub" :
2936                       node->pkt->pkttype == PKT_SECRET_KEY ? "sec" : "ssb",
2937                       (node->flag & NODFLG_SELKEY) ? '*' : ' ',
2938                       pubkey_string (pk, pkstrbuf, sizeof pkstrbuf),
2939                       keystr (pk->keyid));
2940
2941           if (opt.legacy_list_mode)
2942             tty_fprintf (fp, "  ");
2943           else
2944             tty_fprintf (fp, "\n     ");
2945
2946           tty_fprintf (fp, _("created: %s"), datestr_from_pk (pk));
2947           tty_fprintf (fp, "  ");
2948           if (pk->flags.revoked)
2949             tty_fprintf (fp, _("revoked: %s"), revokestr_from_pk (pk));
2950           else if (pk->has_expired)
2951             tty_fprintf (fp, _("expired: %s"), expirestr_from_pk (pk));
2952           else
2953             tty_fprintf (fp, _("expires: %s"), expirestr_from_pk (pk));
2954           tty_fprintf (fp, "  ");
2955           tty_fprintf (fp, _("usage: %s"), usagestr_from_pk (pk, 1));
2956           tty_fprintf (fp, "\n");
2957
2958           if (pk->seckey_info
2959               && pk->seckey_info->is_protected
2960               && pk->seckey_info->s2k.mode == 1002)
2961             {
2962               tty_fprintf (fp, "%*s%s", opt.legacy_list_mode? 21:5, "",
2963                            _("card-no: "));
2964               if (pk->seckey_info->ivlen == 16
2965                   && !memcmp (pk->seckey_info->iv,
2966                               "\xD2\x76\x00\x01\x24\x01", 6))
2967                 {
2968                   /* This is an OpenPGP card. */
2969                   for (i = 8; i < 14; i++)
2970                     {
2971                       if (i == 10)
2972                         tty_fprintf (fp, " ");
2973                       tty_fprintf (fp, "%02X", pk->seckey_info->iv[i]);
2974                     }
2975                 }
2976               else
2977                 {
2978                   /* Unknown card: Print all. */
2979                   for (i = 0; i < pk->seckey_info->ivlen; i++)
2980                     tty_fprintf (fp, "%02X", pk->seckey_info->iv[i]);
2981                 }
2982               tty_fprintf (fp, "\n");
2983             }
2984
2985           if (node->pkt->pkttype == PKT_PUBLIC_KEY
2986               || node->pkt->pkttype == PKT_SECRET_KEY)
2987             {
2988               if (opt.trust_model != TM_ALWAYS)
2989                 {
2990                   tty_fprintf (fp, "%*s",
2991                                opt.legacy_list_mode?
2992                                ((int) keystrlen () + 13):5, "");
2993                   /* Ownertrust is only meaningful for the PGP or
2994                      classic trust models */
2995                   if (opt.trust_model == TM_PGP
2996                       || opt.trust_model == TM_CLASSIC)
2997                     {
2998                       int width = 14 - strlen (otrust);
2999                       if (width <= 0)
3000                         width = 1;
3001                       tty_fprintf (fp, _("trust: %s"), otrust);
3002                       tty_fprintf (fp, "%*s", width, "");
3003                     }
3004
3005                   tty_fprintf (fp, _("validity: %s"), trust);
3006                   tty_fprintf (fp, "\n");
3007                 }
3008               if (node->pkt->pkttype == PKT_PUBLIC_KEY
3009                   && (get_ownertrust (pk) & TRUST_FLAG_DISABLED))
3010                 {
3011                   tty_fprintf (fp, "*** ");
3012                   tty_fprintf (fp, _("This key has been disabled"));
3013                   tty_fprintf (fp, "\n");
3014                 }
3015             }
3016
3017           if ((node->pkt->pkttype == PKT_PUBLIC_KEY
3018                || node->pkt->pkttype == PKT_SECRET_KEY) && with_fpr)
3019             {
3020               print_fingerprint (fp, pk, 2);
3021               tty_fprintf (fp, "\n");
3022             }
3023         }
3024     }
3025
3026   show_names (fp,
3027               keyblock, primary, only_marked ? NODFLG_MARK_A : 0, with_prefs);
3028
3029   if (do_warn && !nowarn)
3030     tty_fprintf (fp, _("Please note that the shown key validity"
3031                        " is not necessarily correct\n"
3032                        "unless you restart the program.\n"));
3033 }
3034
3035
3036 /* Display basic key information.  This function is suitable to show
3037    information on the key without any dependencies on the trustdb or
3038    any other internal GnuPG stuff.  KEYBLOCK may either be a public or
3039    a secret key.*/
3040 void
3041 show_basic_key_info (KBNODE keyblock)
3042 {
3043   KBNODE node;
3044   int i;
3045   char pkstrbuf[PUBKEY_STRING_SIZE];
3046
3047   /* The primary key */
3048   for (node = keyblock; node; node = node->next)
3049     {
3050       if (node->pkt->pkttype == PKT_PUBLIC_KEY
3051           || node->pkt->pkttype == PKT_SECRET_KEY)
3052         {
3053           PKT_public_key *pk = node->pkt->pkt.public_key;
3054
3055           /* Note, we use the same format string as in other show
3056              functions to make the translation job easier. */
3057           tty_printf ("%s  %s/%s  ",
3058                       node->pkt->pkttype == PKT_PUBLIC_KEY ? "pub" :
3059                       node->pkt->pkttype == PKT_PUBLIC_SUBKEY ? "sub" :
3060                       node->pkt->pkttype == PKT_SECRET_KEY ? "sec" :"ssb",
3061                       pubkey_string (pk, pkstrbuf, sizeof pkstrbuf),
3062                       keystr_from_pk (pk));
3063           tty_printf (_("created: %s"), datestr_from_pk (pk));
3064           tty_printf ("  ");
3065           tty_printf (_("expires: %s"), expirestr_from_pk (pk));
3066           tty_printf ("\n");
3067           print_fingerprint (NULL, pk, 3);
3068           tty_printf ("\n");
3069         }
3070     }
3071
3072   /* The user IDs. */
3073   for (i = 0, node = keyblock; node; node = node->next)
3074     {
3075       if (node->pkt->pkttype == PKT_USER_ID)
3076         {
3077           PKT_user_id *uid = node->pkt->pkt.user_id;
3078           ++i;
3079
3080           tty_printf ("     ");
3081           if (uid->is_revoked)
3082             tty_printf ("[%s] ", _("revoked"));
3083           else if (uid->is_expired)
3084             tty_printf ("[%s] ", _("expired"));
3085           tty_print_utf8_string (uid->name, uid->len);
3086           tty_printf ("\n");
3087         }
3088     }
3089 }
3090
3091 static void
3092 show_key_and_fingerprint (KBNODE keyblock)
3093 {
3094   KBNODE node;
3095   PKT_public_key *pk = NULL;
3096   char pkstrbuf[PUBKEY_STRING_SIZE];
3097
3098   for (node = keyblock; node; node = node->next)
3099     {
3100       if (node->pkt->pkttype == PKT_PUBLIC_KEY)
3101         {
3102           pk = node->pkt->pkt.public_key;
3103           tty_printf ("pub   %s/%s %s ",
3104                       pubkey_string (pk, pkstrbuf, sizeof pkstrbuf),
3105                       keystr_from_pk(pk),
3106                       datestr_from_pk (pk));
3107         }
3108       else if (node->pkt->pkttype == PKT_USER_ID)
3109         {
3110           PKT_user_id *uid = node->pkt->pkt.user_id;
3111           tty_print_utf8_string (uid->name, uid->len);
3112           break;
3113         }
3114     }
3115   tty_printf ("\n");
3116   if (pk)
3117     print_fingerprint (NULL, pk, 2);
3118 }
3119
3120
3121 /* Show a warning if no uids on the key have the primary uid flag
3122    set. */
3123 static void
3124 no_primary_warning (KBNODE keyblock)
3125 {
3126   KBNODE node;
3127   int have_primary = 0, uid_count = 0;
3128
3129   /* TODO: if we ever start behaving differently with a primary or
3130      non-primary attribute ID, we will need to check for attributes
3131      here as well. */
3132
3133   for (node = keyblock; node; node = node->next)
3134     {
3135       if (node->pkt->pkttype == PKT_USER_ID
3136           && node->pkt->pkt.user_id->attrib_data == NULL)
3137         {
3138           uid_count++;
3139
3140           if (node->pkt->pkt.user_id->is_primary == 2)
3141             {
3142               have_primary = 1;
3143               break;
3144             }
3145         }
3146     }
3147
3148   if (uid_count > 1 && !have_primary)
3149     log_info (_
3150               ("WARNING: no user ID has been marked as primary.  This command"
3151                " may\n              cause a different user ID to become"
3152                " the assumed primary.\n"));
3153 }
3154
3155
3156 /* Print a warning if the latest encryption subkey expires soon.  This
3157    function is called after the expire data of the primary key has
3158    been changed.  */
3159 static void
3160 subkey_expire_warning (kbnode_t keyblock)
3161 {
3162   u32 curtime = make_timestamp ();
3163   kbnode_t node;
3164   PKT_public_key *pk;
3165   /* u32 mainexpire = 0; */
3166   u32 subexpire = 0;
3167   u32 latest_date = 0;
3168
3169   for (node = keyblock; node; node = node->next)
3170     {
3171       /* if (node->pkt->pkttype == PKT_PUBLIC_KEY) */
3172       /*   { */
3173       /*     pk = node->pkt->pkt.public_key; */
3174       /*     mainexpire = pk->expiredate; */
3175       /*   } */
3176
3177       if (node->pkt->pkttype != PKT_PUBLIC_SUBKEY)
3178         continue;
3179       pk = node->pkt->pkt.public_key;
3180
3181       if (!pk->flags.valid)
3182         continue;
3183       if (pk->flags.revoked)
3184         continue;
3185       if (pk->timestamp > curtime)
3186         continue; /* Ignore future keys.  */
3187       if (!(pk->pubkey_usage & PUBKEY_USAGE_ENC))
3188         continue; /* Not an encryption key.  */
3189
3190       if (pk->timestamp > latest_date || (!pk->timestamp && !latest_date))
3191         {
3192           latest_date = pk->timestamp;
3193           subexpire = pk->expiredate;
3194         }
3195     }
3196
3197   if (!subexpire)
3198     return;  /* No valid subkey with an expiration time.  */
3199
3200   if (curtime + (10*86400) > subexpire)
3201     {
3202       log_info (_("WARNING: Your encryption subkey expires soon.\n"));
3203       log_info (_("You may want to change its expiration date too.\n"));
3204     }
3205 }
3206
3207
3208 /*
3209  * Ask for a new user id, add the self-signature and update the keyblock.
3210  * Return true if there is a new user id
3211  */
3212 static int
3213 menu_adduid (KBNODE pub_keyblock, int photo, const char *photo_name)
3214 {
3215   PKT_user_id *uid;
3216   PKT_public_key *pk = NULL;
3217   PKT_signature *sig = NULL;
3218   PACKET *pkt;
3219   KBNODE node;
3220   KBNODE pub_where = NULL;
3221   gpg_error_t err;
3222
3223   for (node = pub_keyblock; node; pub_where = node, node = node->next)
3224     {
3225       if (node->pkt->pkttype == PKT_PUBLIC_KEY)
3226         pk = node->pkt->pkt.public_key;
3227       else if (node->pkt->pkttype == PKT_PUBLIC_SUBKEY)
3228         break;
3229     }
3230   if (!node) /* No subkey.  */
3231     pub_where = NULL;
3232   assert (pk);
3233
3234   if (photo)
3235     {
3236       int hasattrib = 0;
3237
3238       for (node = pub_keyblock; node; node = node->next)
3239         if (node->pkt->pkttype == PKT_USER_ID &&
3240             node->pkt->pkt.user_id->attrib_data != NULL)
3241           {
3242             hasattrib = 1;
3243             break;
3244           }
3245
3246       /* It is legal but bad for compatibility to add a photo ID to a
3247          v3 key as it means that PGP2 will not be able to use that key
3248          anymore.  Also, PGP may not expect a photo on a v3 key.
3249          Don't bother to ask this if the key already has a photo - any
3250          damage has already been done at that point. -dms */
3251       if (pk->version == 3 && !hasattrib)
3252         {
3253           if (opt.expert)
3254             {
3255               tty_printf (_("WARNING: This is a PGP2-style key.  "
3256                             "Adding a photo ID may cause some versions\n"
3257                             "         of PGP to reject this key.\n"));
3258
3259               if (!cpr_get_answer_is_yes ("keyedit.v3_photo.okay",
3260                                           _("Are you sure you still want "
3261                                             "to add it? (y/N) ")))
3262                 return 0;
3263             }
3264           else
3265             {
3266               tty_printf (_("You may not add a photo ID to "
3267                             "a PGP2-style key.\n"));
3268               return 0;
3269             }
3270         }
3271
3272       uid = generate_photo_id (pk, photo_name);
3273     }
3274   else
3275     uid = generate_user_id (pub_keyblock);
3276   if (!uid)
3277     return 0;
3278
3279   err = make_keysig_packet (&sig, pk, uid, NULL, pk, 0x13, 0, 0, 0,
3280                             keygen_add_std_prefs, pk, NULL);
3281   if (err)
3282     {
3283       log_error ("signing failed: %s\n", gpg_strerror (err));
3284       free_user_id (uid);
3285       return 0;
3286     }
3287
3288   /* Insert/append to public keyblock */
3289   pkt = xmalloc_clear (sizeof *pkt);
3290   pkt->pkttype = PKT_USER_ID;
3291   pkt->pkt.user_id = uid;
3292   node = new_kbnode (pkt);
3293   if (pub_where)
3294     insert_kbnode (pub_where, node, 0);
3295   else
3296     add_kbnode (pub_keyblock, node);
3297   pkt = xmalloc_clear (sizeof *pkt);
3298   pkt->pkttype = PKT_SIGNATURE;
3299   pkt->pkt.signature = copy_signature (NULL, sig);
3300   if (pub_where)
3301     insert_kbnode (node, new_kbnode (pkt), 0);
3302   else
3303     add_kbnode (pub_keyblock, new_kbnode (pkt));
3304   return 1;
3305 }
3306
3307
3308 /*
3309  * Remove all selected userids from the keyring
3310  */
3311 static void
3312 menu_deluid (KBNODE pub_keyblock)
3313 {
3314   KBNODE node;
3315   int selected = 0;
3316
3317   for (node = pub_keyblock; node; node = node->next)
3318     {
3319       if (node->pkt->pkttype == PKT_USER_ID)
3320         {
3321           selected = node->flag & NODFLG_SELUID;
3322           if (selected)
3323             {
3324               /* Only cause a trust update if we delete a
3325                  non-revoked user id */
3326               if (!node->pkt->pkt.user_id->is_revoked)
3327                 update_trust = 1;
3328               delete_kbnode (node);
3329             }
3330         }
3331       else if (selected && node->pkt->pkttype == PKT_SIGNATURE)
3332         delete_kbnode (node);
3333       else if (node->pkt->pkttype == PKT_PUBLIC_SUBKEY)
3334         selected = 0;
3335     }
3336   commit_kbnode (&pub_keyblock);
3337 }
3338
3339
3340 static int
3341 menu_delsig (KBNODE pub_keyblock)
3342 {
3343   KBNODE node;
3344   PKT_user_id *uid = NULL;
3345   int changed = 0;
3346
3347   for (node = pub_keyblock; node; node = node->next)
3348     {
3349       if (node->pkt->pkttype == PKT_USER_ID)
3350         {
3351           uid = (node->flag & NODFLG_SELUID) ? node->pkt->pkt.user_id : NULL;
3352         }
3353       else if (uid && node->pkt->pkttype == PKT_SIGNATURE)
3354         {
3355           int okay, valid, selfsig, inv_sig, no_key, other_err;
3356
3357           tty_printf ("uid  ");
3358           tty_print_utf8_string (uid->name, uid->len);
3359           tty_printf ("\n");
3360
3361           okay = inv_sig = no_key = other_err = 0;
3362           if (opt.with_colons)
3363             valid = print_and_check_one_sig_colon (pub_keyblock, node,
3364                                                    &inv_sig, &no_key,
3365                                                    &other_err, &selfsig, 1);
3366           else
3367             valid = print_and_check_one_sig (pub_keyblock, node,
3368                                              &inv_sig, &no_key, &other_err,
3369                                              &selfsig, 1);
3370
3371           if (valid)
3372             {
3373               okay = cpr_get_answer_yes_no_quit
3374                 ("keyedit.delsig.valid",
3375                  _("Delete this good signature? (y/N/q)"));
3376
3377               /* Only update trust if we delete a good signature.
3378                  The other two cases do not affect trust. */
3379               if (okay)
3380                 update_trust = 1;
3381             }
3382           else if (inv_sig || other_err)
3383             okay = cpr_get_answer_yes_no_quit
3384               ("keyedit.delsig.invalid",
3385                _("Delete this invalid signature? (y/N/q)"));
3386           else if (no_key)
3387             okay = cpr_get_answer_yes_no_quit
3388               ("keyedit.delsig.unknown",
3389                _("Delete this unknown signature? (y/N/q)"));
3390
3391           if (okay == -1)
3392             break;
3393           if (okay && selfsig
3394               && !cpr_get_answer_is_yes
3395               ("keyedit.delsig.selfsig",
3396                _("Really delete this self-signature? (y/N)")))
3397             okay = 0;
3398           if (okay)
3399             {
3400               delete_kbnode (node);
3401               changed++;
3402             }
3403
3404         }
3405       else if (node->pkt->pkttype == PKT_PUBLIC_SUBKEY)
3406         uid = NULL;
3407     }
3408
3409   if (changed)
3410     {
3411       commit_kbnode (&pub_keyblock);
3412       tty_printf (changed == 1 ? _("Deleted %d signature.\n")
3413                   : _("Deleted %d signatures.\n"), changed);
3414     }
3415   else
3416     tty_printf (_("Nothing deleted.\n"));
3417
3418   return changed;
3419 }
3420
3421
3422 static int
3423 menu_clean (KBNODE keyblock, int self_only)
3424 {
3425   KBNODE uidnode;
3426   int modified = 0, select_all = !count_selected_uids (keyblock);
3427
3428   for (uidnode = keyblock->next;
3429        uidnode && uidnode->pkt->pkttype != PKT_PUBLIC_SUBKEY;
3430        uidnode = uidnode->next)
3431     {
3432       if (uidnode->pkt->pkttype == PKT_USER_ID
3433           && (uidnode->flag & NODFLG_SELUID || select_all))
3434         {
3435           int uids = 0, sigs = 0;
3436           char *user = utf8_to_native (uidnode->pkt->pkt.user_id->name,
3437                                        uidnode->pkt->pkt.user_id->len,
3438                                        0);
3439
3440           clean_one_uid (keyblock, uidnode, opt.verbose, self_only, &uids,
3441                          &sigs);
3442           if (uids)
3443             {
3444               const char *reason;
3445
3446               if (uidnode->pkt->pkt.user_id->is_revoked)
3447                 reason = _("revoked");
3448               else if (uidnode->pkt->pkt.user_id->is_expired)
3449                 reason = _("expired");
3450               else
3451                 reason = _("invalid");
3452
3453               tty_printf (_("User ID \"%s\" compacted: %s\n"), user, reason);
3454
3455               modified = 1;
3456             }
3457           else if (sigs)
3458             {
3459               tty_printf (sigs == 1 ?
3460                           _("User ID \"%s\": %d signature removed\n") :
3461                           _("User ID \"%s\": %d signatures removed\n"),
3462                           user, sigs);
3463
3464               modified = 1;
3465             }
3466           else
3467             {
3468               tty_printf (self_only == 1 ?
3469                           _("User ID \"%s\": already minimized\n") :
3470                           _("User ID \"%s\": already clean\n"), user);
3471             }
3472
3473           xfree (user);
3474         }
3475     }
3476
3477   return modified;
3478 }
3479
3480
3481 /*
3482  * Remove some of the secondary keys
3483  */
3484 static void
3485 menu_delkey (KBNODE pub_keyblock)
3486 {
3487   KBNODE node;
3488   int selected = 0;
3489
3490   for (node = pub_keyblock; node; node = node->next)
3491     {
3492       if (node->pkt->pkttype == PKT_PUBLIC_SUBKEY)
3493         {
3494           selected = node->flag & NODFLG_SELKEY;
3495           if (selected)
3496             delete_kbnode (node);
3497         }
3498       else if (selected && node->pkt->pkttype == PKT_SIGNATURE)
3499         delete_kbnode (node);
3500       else
3501         selected = 0;
3502     }
3503   commit_kbnode (&pub_keyblock);
3504
3505   /* No need to set update_trust here since signing keys are no
3506      longer used to certify other keys, so there is no change in
3507      trust when revoking/removing them.   */
3508 }
3509
3510
3511 /*
3512  * Ask for a new revoker, create the self-signature and put it into
3513  * the keyblock.  Returns true if there is a new revoker.
3514  */
3515 static int
3516 menu_addrevoker (ctrl_t ctrl, kbnode_t pub_keyblock, int sensitive)
3517 {
3518   PKT_public_key *pk = NULL;
3519   PKT_public_key *revoker_pk = NULL;
3520   PKT_signature *sig = NULL;
3521   PACKET *pkt;
3522   struct revocation_key revkey;
3523   size_t fprlen;
3524   int rc;
3525
3526   assert (pub_keyblock->pkt->pkttype == PKT_PUBLIC_KEY);
3527
3528   pk = pub_keyblock->pkt->pkt.public_key;
3529
3530   if (pk->numrevkeys == 0 && pk->version == 3)
3531     {
3532       /* It is legal but bad for compatibility to add a revoker to a
3533          v3 key as it means that PGP2 will not be able to use that key
3534          anymore.  Also, PGP may not expect a revoker on a v3 key.
3535          Don't bother to ask this if the key already has a revoker -
3536          any damage has already been done at that point. -dms */
3537       if (opt.expert)
3538         {
3539           tty_printf (_("WARNING: This is a PGP 2.x-style key.  "
3540                         "Adding a designated revoker may cause\n"
3541                         "         some versions of PGP to reject this key.\n"));
3542
3543           if (!cpr_get_answer_is_yes ("keyedit.v3_revoker.okay",
3544                                       _("Are you sure you still want "
3545                                         "to add it? (y/N) ")))
3546             return 0;
3547         }
3548       else
3549         {
3550           tty_printf (_("You may not add a designated revoker to "
3551                         "a PGP 2.x-style key.\n"));
3552           return 0;
3553         }
3554     }
3555
3556   for (;;)
3557     {
3558       char *answer;
3559
3560       free_public_key (revoker_pk);
3561       revoker_pk = xmalloc_clear (sizeof (*revoker_pk));
3562
3563       tty_printf ("\n");
3564
3565       answer = cpr_get_utf8
3566         ("keyedit.add_revoker",
3567          _("Enter the user ID of the designated revoker: "));
3568       if (answer[0] == '\0' || answer[0] == CONTROL_D)
3569         {
3570           xfree (answer);
3571           goto fail;
3572         }
3573
3574       /* Note that I'm requesting CERT here, which usually implies
3575          primary keys only, but some casual testing shows that PGP and
3576          GnuPG both can handle a designated revocation from a subkey. */
3577       revoker_pk->req_usage = PUBKEY_USAGE_CERT;
3578       rc = get_pubkey_byname (ctrl, NULL, revoker_pk, answer, NULL, NULL, 1, 1);
3579       if (rc)
3580         {
3581           log_error (_("key \"%s\" not found: %s\n"), answer,
3582                      gpg_strerror (rc));
3583           xfree (answer);
3584           continue;
3585         }
3586
3587       xfree (answer);
3588
3589       fingerprint_from_pk (revoker_pk, revkey.fpr, &fprlen);
3590       if (fprlen != 20)
3591         {
3592           log_error (_("cannot appoint a PGP 2.x style key as a "
3593                        "designated revoker\n"));
3594           continue;
3595         }
3596
3597       revkey.class = 0x80;
3598       if (sensitive)
3599         revkey.class |= 0x40;
3600       revkey.algid = revoker_pk->pubkey_algo;
3601
3602       if (cmp_public_keys (revoker_pk, pk) == 0)
3603         {
3604           /* This actually causes no harm (after all, a key that
3605              designates itself as a revoker is the same as a
3606              regular key), but it's easy enough to check. */
3607           log_error (_("you cannot appoint a key as its own "
3608                        "designated revoker\n"));
3609
3610           continue;
3611         }
3612
3613       keyid_from_pk (pk, NULL);
3614
3615       /* Does this revkey already exist? */
3616       if (!pk->revkey && pk->numrevkeys)
3617         BUG ();
3618       else
3619         {
3620           int i;
3621
3622           for (i = 0; i < pk->numrevkeys; i++)
3623             {
3624               if (memcmp (&pk->revkey[i], &revkey,
3625                           sizeof (struct revocation_key)) == 0)
3626                 {
3627                   char buf[50];
3628
3629                   log_error (_("this key has already been designated "
3630                                "as a revoker\n"));
3631
3632                   sprintf (buf, "%08lX%08lX",
3633                            (ulong) pk->keyid[0], (ulong) pk->keyid[1]);
3634                   write_status_text (STATUS_ALREADY_SIGNED, buf);
3635
3636                   break;
3637                 }
3638             }
3639
3640           if (i < pk->numrevkeys)
3641             continue;
3642         }
3643
3644       print_pubkey_info (NULL, revoker_pk);
3645       print_fingerprint (NULL, revoker_pk, 2);
3646       tty_printf ("\n");
3647
3648       tty_printf (_("WARNING: appointing a key as a designated revoker "
3649                     "cannot be undone!\n"));
3650
3651       tty_printf ("\n");
3652
3653       if (!cpr_get_answer_is_yes ("keyedit.add_revoker.okay",
3654                                   _("Are you sure you want to appoint this "
3655                                     "key as a designated revoker? (y/N) ")))
3656         continue;
3657
3658       free_public_key (revoker_pk);
3659       revoker_pk = NULL;
3660       break;
3661     }
3662
3663   rc = make_keysig_packet (&sig, pk, NULL, NULL, pk, 0x1F, 0, 0, 0,
3664                            keygen_add_revkey, &revkey, NULL);
3665   if (rc)
3666     {
3667       log_error ("signing failed: %s\n", gpg_strerror (rc));
3668       goto fail;
3669     }
3670
3671   /* Insert into public keyblock.  */
3672   pkt = xmalloc_clear (sizeof *pkt);
3673   pkt->pkttype = PKT_SIGNATURE;
3674   pkt->pkt.signature = sig;
3675   insert_kbnode (pub_keyblock, new_kbnode (pkt), PKT_SIGNATURE);
3676
3677   return 1;
3678
3679 fail:
3680   if (sig)
3681     free_seckey_enc (sig);
3682   free_public_key (revoker_pk);
3683
3684   return 0;
3685 }
3686
3687
3688 static int
3689 menu_expire (KBNODE pub_keyblock)
3690 {
3691   int n1, signumber, rc;
3692   u32 expiredate;
3693   int mainkey = 0;
3694   PKT_public_key *main_pk, *sub_pk;
3695   PKT_user_id *uid;
3696   KBNODE node;
3697   u32 keyid[2];
3698
3699   n1 = count_selected_keys (pub_keyblock);
3700   if (n1 > 1)
3701     {
3702       tty_printf (_("Please select at most one subkey.\n"));
3703       return 0;
3704     }
3705   else if (n1)
3706     tty_printf (_("Changing expiration time for a subkey.\n"));
3707   else
3708     {
3709       tty_printf (_("Changing expiration time for the primary key.\n"));
3710       mainkey = 1;
3711       no_primary_warning (pub_keyblock);
3712     }
3713
3714   expiredate = ask_expiredate ();
3715
3716   /* Now we can actually change the self-signature(s) */
3717   main_pk = sub_pk = NULL;
3718   uid = NULL;
3719   signumber = 0;
3720   for (node = pub_keyblock; node; node = node->next)
3721     {
3722       if (node->pkt->pkttype == PKT_PUBLIC_KEY)
3723         {
3724           main_pk = node->pkt->pkt.public_key;
3725           keyid_from_pk (main_pk, keyid);
3726           main_pk->expiredate = expiredate;
3727         }
3728       else if (node->pkt->pkttype == PKT_PUBLIC_SUBKEY
3729                && (node->flag & NODFLG_SELKEY))
3730         {
3731           sub_pk = node->pkt->pkt.public_key;
3732           sub_pk->expiredate = expiredate;
3733         }
3734       else if (node->pkt->pkttype == PKT_USER_ID)
3735         uid = node->pkt->pkt.user_id;
3736       else if (main_pk && node->pkt->pkttype == PKT_SIGNATURE
3737                && (mainkey || sub_pk))
3738         {
3739           PKT_signature *sig = node->pkt->pkt.signature;
3740           if (keyid[0] == sig->keyid[0] && keyid[1] == sig->keyid[1]
3741               && ((mainkey && uid
3742                    && uid->created && (sig->sig_class & ~3) == 0x10)
3743                   || (!mainkey && sig->sig_class == 0x18))
3744               && sig->flags.chosen_selfsig)
3745             {
3746               /* This is a self-signature which is to be replaced.  */
3747               PKT_signature *newsig;
3748               PACKET *newpkt;
3749
3750               signumber++;
3751
3752               if ((mainkey && main_pk->version < 4)
3753                   || (!mainkey && sub_pk->version < 4))
3754                 {
3755                   log_info
3756                     (_("You can't change the expiration date of a v3 key\n"));
3757                   return 0;
3758                 }
3759
3760               if (mainkey)
3761                 rc = update_keysig_packet (&newsig, sig, main_pk, uid, NULL,
3762                                            main_pk, keygen_add_key_expire,
3763                                            main_pk);
3764               else
3765                 rc =
3766                   update_keysig_packet (&newsig, sig, main_pk, NULL, sub_pk,
3767                                         main_pk, keygen_add_key_expire, sub_pk);
3768               if (rc)
3769                 {
3770                   log_error ("make_keysig_packet failed: %s\n",
3771                              gpg_strerror (rc));
3772                   return 0;
3773                 }
3774
3775               /* Replace the packet.  */
3776               newpkt = xmalloc_clear (sizeof *newpkt);
3777               newpkt->pkttype = PKT_SIGNATURE;
3778               newpkt->pkt.signature = newsig;
3779               free_packet (node->pkt);
3780               xfree (node->pkt);
3781               node->pkt = newpkt;
3782               sub_pk = NULL;
3783             }
3784         }
3785     }
3786
3787   update_trust = 1;
3788   return 1;
3789 }
3790
3791
3792 static int
3793 menu_backsign (KBNODE pub_keyblock)
3794 {
3795   int rc, modified = 0;
3796   PKT_public_key *main_pk;
3797   KBNODE node;
3798   u32 timestamp;
3799
3800   assert (pub_keyblock->pkt->pkttype == PKT_PUBLIC_KEY);
3801
3802   merge_keys_and_selfsig (pub_keyblock);
3803   main_pk = pub_keyblock->pkt->pkt.public_key;
3804   keyid_from_pk (main_pk, NULL);
3805
3806   /* We use the same timestamp for all backsigs so that we don't
3807      reveal information about the used machine.  */
3808   timestamp = make_timestamp ();
3809
3810   for (node = pub_keyblock; node; node = node->next)
3811     {
3812       PKT_public_key *sub_pk = NULL;
3813       KBNODE node2, sig_pk = NULL /*,sig_sk = NULL*/;
3814       /* char *passphrase; */
3815
3816       /* Find a signing subkey with no backsig */
3817       if (node->pkt->pkttype == PKT_PUBLIC_SUBKEY)
3818         {
3819           if (node->pkt->pkt.public_key->pubkey_usage & PUBKEY_USAGE_SIG)
3820             {
3821               if (node->pkt->pkt.public_key->flags.backsig)
3822                 tty_printf (_
3823                             ("signing subkey %s is already cross-certified\n"),
3824                             keystr_from_pk (node->pkt->pkt.public_key));
3825               else
3826                 sub_pk = node->pkt->pkt.public_key;
3827             }
3828           else
3829             tty_printf (_("subkey %s does not sign and so does"
3830                           " not need to be cross-certified\n"),
3831                         keystr_from_pk (node->pkt->pkt.public_key));
3832         }
3833
3834       if (!sub_pk)
3835         continue;
3836
3837       /* Find the selected selfsig on this subkey */
3838       for (node2 = node->next;
3839            node2 && node2->pkt->pkttype == PKT_SIGNATURE; node2 = node2->next)
3840         if (node2->pkt->pkt.signature->version >= 4
3841             && node2->pkt->pkt.signature->flags.chosen_selfsig)
3842           {
3843             sig_pk = node2;
3844             break;
3845           }
3846
3847       if (!sig_pk)
3848         continue;
3849
3850       /* Find the secret subkey that matches the public subkey */
3851       log_debug ("FIXME: Check whether a secret subkey is available.\n");
3852       /* if (!sub_sk) */
3853       /*   { */
3854       /*     tty_printf (_("no secret subkey for public subkey %s - ignoring\n"), */
3855       /*              keystr_from_pk (sub_pk)); */
3856       /*     continue; */
3857       /*   } */
3858
3859
3860       /* Now we can get to work.  */
3861
3862       rc = make_backsig (sig_pk->pkt->pkt.signature, main_pk, sub_pk, sub_pk,
3863                          timestamp, NULL);
3864       if (!rc)
3865         {
3866           PKT_signature *newsig;
3867           PACKET *newpkt;
3868
3869           rc = update_keysig_packet (&newsig, sig_pk->pkt->pkt.signature,
3870                                      main_pk, NULL, sub_pk, main_pk,
3871                                      NULL, NULL);
3872           if (!rc)
3873             {
3874               /* Put the new sig into place on the pubkey */
3875               newpkt = xmalloc_clear (sizeof (*newpkt));
3876               newpkt->pkttype = PKT_SIGNATURE;
3877               newpkt->pkt.signature = newsig;
3878               free_packet (sig_pk->pkt);
3879               xfree (sig_pk->pkt);
3880               sig_pk->pkt = newpkt;
3881
3882               modified = 1;
3883             }
3884           else
3885             {
3886               log_error ("update_keysig_packet failed: %s\n",
3887                          gpg_strerror (rc));
3888               break;
3889             }
3890         }
3891       else
3892         {
3893           log_error ("make_backsig failed: %s\n", gpg_strerror (rc));
3894           break;
3895         }
3896     }
3897
3898   return modified;
3899 }
3900
3901
3902 static int
3903 change_primary_uid_cb (PKT_signature * sig, void *opaque)
3904 {
3905   byte buf[1];
3906
3907   /* first clear all primary uid flags so that we are sure none are
3908    * lingering around */
3909   delete_sig_subpkt (sig->hashed, SIGSUBPKT_PRIMARY_UID);
3910   delete_sig_subpkt (sig->unhashed, SIGSUBPKT_PRIMARY_UID);
3911
3912   /* if opaque is set,we want to set the primary id */
3913   if (opaque)
3914     {
3915       buf[0] = 1;
3916       build_sig_subpkt (sig, SIGSUBPKT_PRIMARY_UID, buf, 1);
3917     }
3918
3919   return 0;
3920 }