gpg: Change last commit to avoid extra translations.
[gnupg.git] / g10 / keyedit.c
1 /* keyedit.c - Edit properties of a key
2  * Copyright (C) 1998-2010 Free Software Foundation, Inc.
3  * Copyright (C) 1998-2015 Werner Koch
4  *
5  * This file is part of GnuPG.
6  *
7  * GnuPG is free software; you can redistribute it and/or modify
8  * it under the terms of the GNU General Public License as published by
9  * the Free Software Foundation; either version 3 of the License, or
10  * (at your option) any later version.
11  *
12  * GnuPG is distributed in the hope that it will be useful,
13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15  * GNU General Public License for more details.
16  *
17  * You should have received a copy of the GNU General Public License
18  * along with this program; if not, see <http://www.gnu.org/licenses/>.
19  */
20
21 #include <config.h>
22 #include <stdio.h>
23 #include <stdlib.h>
24 #include <string.h>
25 #include <errno.h>
26 #include <assert.h>
27 #include <ctype.h>
28 #ifdef HAVE_LIBREADLINE
29 # define GNUPG_LIBREADLINE_H_INCLUDED
30 # include <readline/readline.h>
31 #endif
32
33 #include "gpg.h"
34 #include "options.h"
35 #include "packet.h"
36 #include "status.h"
37 #include "iobuf.h"
38 #include "keydb.h"
39 #include "photoid.h"
40 #include "util.h"
41 #include "main.h"
42 #include "trustdb.h"
43 #include "filter.h"
44 #include "ttyio.h"
45 #include "status.h"
46 #include "i18n.h"
47 #include "keyserver-internal.h"
48 #include "call-agent.h"
49
50 static void show_prefs (PKT_user_id * uid, PKT_signature * selfsig,
51                         int verbose);
52 static void show_names (estream_t fp, KBNODE keyblock, PKT_public_key * pk,
53                         unsigned int flag, int with_prefs);
54 static void show_key_with_all_names (ctrl_t ctrl, estream_t fp,
55                                      KBNODE keyblock, int only_marked,
56                                      int with_revoker, int with_fpr,
57                                      int with_subkeys, int with_prefs,
58                                      int nowarn);
59 static void show_key_and_fingerprint (kbnode_t keyblock, int with_subkeys);
60 static void show_key_and_grip (kbnode_t keyblock);
61 static void subkey_expire_warning (kbnode_t keyblock);
62 static int menu_adduid (KBNODE keyblock, int photo, const char *photo_name,
63                         const char *uidstr);
64 static void menu_deluid (KBNODE pub_keyblock);
65 static int menu_delsig (KBNODE pub_keyblock);
66 static int menu_clean (KBNODE keyblock, int self_only);
67 static void menu_delkey (KBNODE pub_keyblock);
68 static int menu_addrevoker (ctrl_t ctrl, kbnode_t pub_keyblock, int sensitive);
69 static int menu_expire (KBNODE pub_keyblock);
70 static int menu_backsign (KBNODE pub_keyblock);
71 static int menu_set_primary_uid (KBNODE pub_keyblock);
72 static int menu_set_preferences (KBNODE pub_keyblock);
73 static int menu_set_keyserver_url (const char *url, KBNODE pub_keyblock);
74 static int menu_set_notation (const char *string, KBNODE pub_keyblock);
75 static int menu_select_uid (KBNODE keyblock, int idx);
76 static int menu_select_uid_namehash (KBNODE keyblock, const char *namehash);
77 static int menu_select_key (KBNODE keyblock, int idx);
78 static int count_uids (KBNODE keyblock);
79 static int count_uids_with_flag (KBNODE keyblock, unsigned flag);
80 static int count_keys_with_flag (KBNODE keyblock, unsigned flag);
81 static int count_selected_uids (KBNODE keyblock);
82 static int real_uids_left (KBNODE keyblock);
83 static int count_selected_keys (KBNODE keyblock);
84 static int menu_revsig (KBNODE keyblock);
85 static int menu_revuid (KBNODE keyblock);
86 static int menu_revkey (KBNODE pub_keyblock);
87 static int menu_revsubkey (KBNODE pub_keyblock);
88 #ifndef NO_TRUST_MODELS
89 static int enable_disable_key (KBNODE keyblock, int disable);
90 #endif /*!NO_TRUST_MODELS*/
91 static void menu_showphoto (KBNODE keyblock);
92
93 static int update_trust = 0;
94
95 #define CONTROL_D ('D' - 'A' + 1)
96
97 #define NODFLG_BADSIG (1<<0)    /* Bad signature.  */
98 #define NODFLG_NOKEY  (1<<1)    /* No public key.  */
99 #define NODFLG_SIGERR (1<<2)    /* Other sig error.  */
100
101 #define NODFLG_MARK_A (1<<4)    /* Temporary mark.  */
102 #define NODFLG_DELSIG (1<<5)    /* To be deleted.  */
103
104 #define NODFLG_SELUID (1<<8)    /* Indicate the selected userid. */
105 #define NODFLG_SELKEY (1<<9)    /* Indicate the selected key.  */
106 #define NODFLG_SELSIG (1<<10)   /* Indicate a selected signature.  */
107
108 struct sign_attrib
109 {
110   int non_exportable, non_revocable;
111   struct revocation_reason_info *reason;
112   byte trust_depth, trust_value;
113   char *trust_regexp;
114 };
115
116
117
118 /* TODO: Fix duplicated code between here and the check-sigs/list-sigs
119    code in keylist.c. */
120 static int
121 print_and_check_one_sig_colon (KBNODE keyblock, KBNODE node,
122                                int *inv_sigs, int *no_key, int *oth_err,
123                                int *is_selfsig, int print_without_key)
124 {
125   PKT_signature *sig = node->pkt->pkt.signature;
126   int rc, sigrc;
127
128   /* TODO: Make sure a cached sig record here still has the pk that
129      issued it.  See also keylist.c:list_keyblock_print */
130
131   rc = check_key_signature (keyblock, node, is_selfsig);
132   switch (gpg_err_code (rc))
133     {
134     case 0:
135       node->flag &= ~(NODFLG_BADSIG | NODFLG_NOKEY | NODFLG_SIGERR);
136       sigrc = '!';
137       break;
138     case GPG_ERR_BAD_SIGNATURE:
139       node->flag = NODFLG_BADSIG;
140       sigrc = '-';
141       if (inv_sigs)
142         ++ * inv_sigs;
143       break;
144     case GPG_ERR_NO_PUBKEY:
145     case GPG_ERR_UNUSABLE_PUBKEY:
146       node->flag = NODFLG_NOKEY;
147       sigrc = '?';
148       if (no_key)
149         ++ * no_key;
150       break;
151     default:
152       node->flag = NODFLG_SIGERR;
153       sigrc = '%';
154       if (oth_err)
155         ++ * oth_err;
156       break;
157     }
158
159   if (sigrc != '?' || print_without_key)
160     {
161       es_printf ("sig:%c::%d:%08lX%08lX:%lu:%lu:",
162                  sigrc, sig->pubkey_algo, (ulong) sig->keyid[0],
163                  (ulong) sig->keyid[1], (ulong) sig->timestamp,
164                  (ulong) sig->expiredate);
165
166       if (sig->trust_depth || sig->trust_value)
167         es_printf ("%d %d", sig->trust_depth, sig->trust_value);
168
169       es_printf (":");
170
171       if (sig->trust_regexp)
172         es_write_sanitized (es_stdout,
173                             sig->trust_regexp, strlen (sig->trust_regexp),
174                             ":", NULL);
175
176       es_printf ("::%02x%c\n", sig->sig_class,
177                  sig->flags.exportable ? 'x' : 'l');
178
179       if (opt.show_subpackets)
180         print_subpackets_colon (sig);
181     }
182
183   return (sigrc == '!');
184 }
185
186
187 /*
188  * Print information about a signature, check it and return true
189  * if the signature is okay. NODE must be a signature packet.
190  */
191 static int
192 print_and_check_one_sig (KBNODE keyblock, KBNODE node,
193                          int *inv_sigs, int *no_key, int *oth_err,
194                          int *is_selfsig, int print_without_key)
195 {
196   PKT_signature *sig = node->pkt->pkt.signature;
197   int rc, sigrc;
198   int is_rev = sig->sig_class == 0x30;
199
200   /* TODO: Make sure a cached sig record here still has the pk that
201      issued it.  See also keylist.c:list_keyblock_print */
202
203   rc = check_key_signature (keyblock, node, is_selfsig);
204   switch (gpg_err_code (rc))
205     {
206     case 0:
207       node->flag &= ~(NODFLG_BADSIG | NODFLG_NOKEY | NODFLG_SIGERR);
208       sigrc = '!';
209       break;
210     case GPG_ERR_BAD_SIGNATURE:
211       node->flag = NODFLG_BADSIG;
212       sigrc = '-';
213       if (inv_sigs)
214         ++ * inv_sigs;
215       break;
216     case GPG_ERR_NO_PUBKEY:
217     case GPG_ERR_UNUSABLE_PUBKEY:
218       node->flag = NODFLG_NOKEY;
219       sigrc = '?';
220       if (no_key)
221         ++ * no_key;
222       break;
223     default:
224       node->flag = NODFLG_SIGERR;
225       sigrc = '%';
226       if (oth_err)
227         ++ * oth_err;
228       break;
229     }
230   if (sigrc != '?' || print_without_key)
231     {
232       tty_printf ("%s%c%c %c%c%c%c%c%c %s %s",
233                   is_rev ? "rev" : "sig", sigrc,
234                   (sig->sig_class - 0x10 > 0 &&
235                    sig->sig_class - 0x10 <
236                    4) ? '0' + sig->sig_class - 0x10 : ' ',
237                   sig->flags.exportable ? ' ' : 'L',
238                   sig->flags.revocable ? ' ' : 'R',
239                   sig->flags.policy_url ? 'P' : ' ',
240                   sig->flags.notation ? 'N' : ' ',
241                   sig->flags.expired ? 'X' : ' ',
242                   (sig->trust_depth > 9) ? 'T' : (sig->trust_depth >
243                                                   0) ? '0' +
244                   sig->trust_depth : ' ', keystr (sig->keyid),
245                   datestr_from_sig (sig));
246       if (opt.list_options & LIST_SHOW_SIG_EXPIRE)
247         tty_printf (" %s", expirestr_from_sig (sig));
248       tty_printf ("  ");
249       if (sigrc == '%')
250         tty_printf ("[%s] ", gpg_strerror (rc));
251       else if (sigrc == '?')
252         ;
253       else if (*is_selfsig)
254         {
255           tty_printf (is_rev ? _("[revocation]") : _("[self-signature]"));
256         }
257       else
258         {
259           size_t n;
260           char *p = get_user_id (sig->keyid, &n);
261           tty_print_utf8_string2 (NULL, p, n,
262                                   opt.screen_columns - keystrlen () - 26 -
263                                   ((opt.
264                                     list_options & LIST_SHOW_SIG_EXPIRE) ? 11
265                                    : 0));
266           xfree (p);
267         }
268       tty_printf ("\n");
269
270       if (sig->flags.policy_url && (opt.list_options & LIST_SHOW_POLICY_URLS))
271         show_policy_url (sig, 3, 0);
272
273       if (sig->flags.notation && (opt.list_options & LIST_SHOW_NOTATIONS))
274         show_notation (sig, 3, 0,
275                        ((opt.
276                          list_options & LIST_SHOW_STD_NOTATIONS) ? 1 : 0) +
277                        ((opt.
278                          list_options & LIST_SHOW_USER_NOTATIONS) ? 2 : 0));
279
280       if (sig->flags.pref_ks && (opt.list_options & LIST_SHOW_KEYSERVER_URLS))
281         show_keyserver_url (sig, 3, 0);
282     }
283
284   return (sigrc == '!');
285 }
286
287
288
289 /*
290  * Check the keysigs and set the flags to indicate errors.
291  * Returns true if error found.
292  */
293 static int
294 check_all_keysigs (KBNODE keyblock, int only_selected)
295 {
296   KBNODE kbctx;
297   KBNODE node;
298   int inv_sigs = 0;
299   int no_key = 0;
300   int oth_err = 0;
301   int has_selfsig = 0;
302   int mis_selfsig = 0;
303   int selected = !only_selected;
304   int anyuid = 0;
305
306   for (kbctx = NULL; (node = walk_kbnode (keyblock, &kbctx, 0));)
307     {
308       if (node->pkt->pkttype == PKT_USER_ID)
309         {
310           PKT_user_id *uid = node->pkt->pkt.user_id;
311
312           if (only_selected)
313             selected = (node->flag & NODFLG_SELUID);
314           if (selected)
315             {
316               tty_printf ("uid  ");
317               tty_print_utf8_string (uid->name, uid->len);
318               tty_printf ("\n");
319               if (anyuid && !has_selfsig)
320                 mis_selfsig++;
321               has_selfsig = 0;
322               anyuid = 1;
323             }
324         }
325       else if (selected && node->pkt->pkttype == PKT_SIGNATURE
326                && ((node->pkt->pkt.signature->sig_class & ~3) == 0x10
327                    || node->pkt->pkt.signature->sig_class == 0x30))
328         {
329           int selfsig;
330
331           if (print_and_check_one_sig (keyblock, node, &inv_sigs,
332                                        &no_key, &oth_err, &selfsig, 0))
333             {
334               if (selfsig)
335                 has_selfsig = 1;
336             }
337           /* Hmmm: should we update the trustdb here? */
338         }
339     }
340   if (!has_selfsig)
341     mis_selfsig++;
342   if (inv_sigs == 1)
343     tty_printf (_("1 bad signature\n"));
344   else if (inv_sigs)
345     tty_printf (_("%d bad signatures\n"), inv_sigs);
346   if (no_key == 1)
347     tty_printf (_("1 signature not checked due to a missing key\n"));
348   else if (no_key)
349     tty_printf (_("%d signatures not checked due to missing keys\n"), no_key);
350   if (oth_err == 1)
351     tty_printf (_("1 signature not checked due to an error\n"));
352   else if (oth_err)
353     tty_printf (_("%d signatures not checked due to errors\n"), oth_err);
354   if (mis_selfsig == 1)
355     tty_printf (_("1 user ID without valid self-signature detected\n"));
356   else if (mis_selfsig)
357     tty_printf (_("%d user IDs without valid self-signatures detected\n"),
358                 mis_selfsig);
359
360   return inv_sigs || no_key || oth_err || mis_selfsig;
361 }
362
363
364 static int
365 sign_mk_attrib (PKT_signature * sig, void *opaque)
366 {
367   struct sign_attrib *attrib = opaque;
368   byte buf[8];
369
370   if (attrib->non_exportable)
371     {
372       buf[0] = 0;               /* not exportable */
373       build_sig_subpkt (sig, SIGSUBPKT_EXPORTABLE, buf, 1);
374     }
375
376   if (attrib->non_revocable)
377     {
378       buf[0] = 0;               /* not revocable */
379       build_sig_subpkt (sig, SIGSUBPKT_REVOCABLE, buf, 1);
380     }
381
382   if (attrib->reason)
383     revocation_reason_build_cb (sig, attrib->reason);
384
385   if (attrib->trust_depth)
386     {
387       /* Not critical.  If someone doesn't understand trust sigs,
388          this can still be a valid regular signature. */
389       buf[0] = attrib->trust_depth;
390       buf[1] = attrib->trust_value;
391       build_sig_subpkt (sig, SIGSUBPKT_TRUST, buf, 2);
392
393       /* Critical.  If someone doesn't understands regexps, this
394          whole sig should be invalid.  Note the +1 for the length -
395          regexps are null terminated. */
396       if (attrib->trust_regexp)
397         build_sig_subpkt (sig, SIGSUBPKT_FLAG_CRITICAL | SIGSUBPKT_REGEXP,
398                           attrib->trust_regexp,
399                           strlen (attrib->trust_regexp) + 1);
400     }
401
402   return 0;
403 }
404
405
406 static void
407 trustsig_prompt (byte * trust_value, byte * trust_depth, char **regexp)
408 {
409   char *p;
410
411   *trust_value = 0;
412   *trust_depth = 0;
413   *regexp = NULL;
414
415   /* Same string as pkclist.c:do_edit_ownertrust */
416   tty_printf (_
417               ("Please decide how far you trust this user to correctly verify"
418                " other users' keys\n(by looking at passports, checking"
419                " fingerprints from different sources, etc.)\n"));
420   tty_printf ("\n");
421   tty_printf (_("  %d = I trust marginally\n"), 1);
422   tty_printf (_("  %d = I trust fully\n"), 2);
423   tty_printf ("\n");
424
425   while (*trust_value == 0)
426     {
427       p = cpr_get ("trustsig_prompt.trust_value", _("Your selection? "));
428       trim_spaces (p);
429       cpr_kill_prompt ();
430       /* 60 and 120 are as per RFC2440 */
431       if (p[0] == '1' && !p[1])
432         *trust_value = 60;
433       else if (p[0] == '2' && !p[1])
434         *trust_value = 120;
435       xfree (p);
436     }
437
438   tty_printf ("\n");
439
440   tty_printf (_("Please enter the depth of this trust signature.\n"
441                 "A depth greater than 1 allows the key you are signing to make\n"
442                 "trust signatures on your behalf.\n"));
443   tty_printf ("\n");
444
445   while (*trust_depth == 0)
446     {
447       p = cpr_get ("trustsig_prompt.trust_depth", _("Your selection? "));
448       trim_spaces (p);
449       cpr_kill_prompt ();
450       *trust_depth = atoi (p);
451       xfree (p);
452     }
453
454   tty_printf ("\n");
455
456   tty_printf (_("Please enter a domain to restrict this signature, "
457                 "or enter for none.\n"));
458
459   tty_printf ("\n");
460
461   p = cpr_get ("trustsig_prompt.trust_regexp", _("Your selection? "));
462   trim_spaces (p);
463   cpr_kill_prompt ();
464
465   if (strlen (p) > 0)
466     {
467       char *q = p;
468       int regexplen = 100, ind;
469
470       *regexp = xmalloc (regexplen);
471
472       /* Now mangle the domain the user entered into a regexp.  To do
473          this, \-escape everything that isn't alphanumeric, and attach
474          "<[^>]+[@.]" to the front, and ">$" to the end. */
475
476       strcpy (*regexp, "<[^>]+[@.]");
477       ind = strlen (*regexp);
478
479       while (*q)
480         {
481           if (!((*q >= 'A' && *q <= 'Z')
482                 || (*q >= 'a' && *q <= 'z') || (*q >= '0' && *q <= '9')))
483             (*regexp)[ind++] = '\\';
484
485           (*regexp)[ind++] = *q;
486
487           if ((regexplen - ind) < 3)
488             {
489               regexplen += 100;
490               *regexp = xrealloc (*regexp, regexplen);
491             }
492
493           q++;
494         }
495
496       (*regexp)[ind] = '\0';
497       strcat (*regexp, ">$");
498     }
499
500   xfree (p);
501   tty_printf ("\n");
502 }
503
504
505 /*
506  * Loop over all LOCUSR and and sign the uids after asking.  If no
507  * user id is marked, all user ids will be signed; if some user_ids
508  * are marked only those will be signed.  If QUICK is true the
509  * function won't ask the user and use sensible defaults.
510  */
511 static int
512 sign_uids (ctrl_t ctrl, 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 (ctrl, 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                   write_status_error ("keysig", rc);
1045                   log_error (_("signing failed: %s\n"), gpg_strerror (rc));
1046                   goto leave;
1047                 }
1048
1049               *ret_modified = 1;        /* We changed the keyblock. */
1050               update_trust = 1;
1051
1052               pkt = xmalloc_clear (sizeof *pkt);
1053               pkt->pkttype = PKT_SIGNATURE;
1054               pkt->pkt.signature = sig;
1055               insert_kbnode (node, new_kbnode (pkt), PKT_SIGNATURE);
1056               goto reloop;
1057             }
1058         }
1059
1060       /* Delete any sigs that got promoted */
1061       for (node = keyblock; node; node = node->next)
1062         if (node->flag & NODFLG_DELSIG)
1063           delete_kbnode (node);
1064     } /* End loop over signators.  */
1065
1066  leave:
1067   release_sk_list (sk_list);
1068   return rc;
1069 }
1070
1071
1072 /*
1073  * Change the passphrase of the primary and all secondary keys.  Note
1074  * that it is common to use only one passphrase for the primary and
1075  * all subkeys.  However, this is now (since GnuPG 2.1) all up to the
1076  * gpg-agent.  Returns 0 on success or an error code.
1077  */
1078 static gpg_error_t
1079 change_passphrase (ctrl_t ctrl, kbnode_t keyblock)
1080 {
1081   gpg_error_t err;
1082   kbnode_t node;
1083   PKT_public_key *pk;
1084   int any;
1085   u32 keyid[2], subid[2];
1086   char *hexgrip = NULL;
1087   char *cache_nonce = NULL;
1088   char *passwd_nonce = NULL;
1089
1090   node = find_kbnode (keyblock, PKT_PUBLIC_KEY);
1091   if (!node)
1092     {
1093       log_error ("Oops; public key missing!\n");
1094       err = gpg_error (GPG_ERR_INTERNAL);
1095       goto leave;
1096     }
1097   pk = node->pkt->pkt.public_key;
1098   keyid_from_pk (pk, keyid);
1099
1100   /* Check whether it is likely that we will be able to change the
1101      passphrase for any subkey.  */
1102   for (any = 0, node = keyblock; node; node = node->next)
1103     {
1104       if (node->pkt->pkttype == PKT_PUBLIC_KEY
1105           || node->pkt->pkttype == PKT_PUBLIC_SUBKEY)
1106         {
1107           char *serialno;
1108
1109           pk = node->pkt->pkt.public_key;
1110           keyid_from_pk (pk, subid);
1111
1112           xfree (hexgrip);
1113           err = hexkeygrip_from_pk (pk, &hexgrip);
1114           if (err)
1115             goto leave;
1116           err = agent_get_keyinfo (ctrl, hexgrip, &serialno);
1117           if (!err && serialno)
1118             ; /* Key on card.  */
1119           else if (gpg_err_code (err) == GPG_ERR_NOT_FOUND)
1120             ; /* Maybe stub key. */
1121           else if (!err)
1122             any = 1; /* Key is known.  */
1123           else
1124             log_error ("key %s: error getting keyinfo from agent: %s\n",
1125                        keystr_with_sub (keyid, subid), gpg_strerror (err));
1126           xfree (serialno);
1127         }
1128     }
1129   err = 0;
1130   if (!any)
1131     {
1132       tty_printf (_("Key has only stub or on-card key items - "
1133                     "no passphrase to change.\n"));
1134       goto leave;
1135     }
1136
1137   /* Change the passphrase for all keys.  */
1138   for (any = 0, node = keyblock; node; node = node->next)
1139     {
1140       if (node->pkt->pkttype == PKT_PUBLIC_KEY
1141           || node->pkt->pkttype == PKT_PUBLIC_SUBKEY)
1142         {
1143           char *desc;
1144
1145           pk = node->pkt->pkt.public_key;
1146           keyid_from_pk (pk, subid);
1147
1148           xfree (hexgrip);
1149           err = hexkeygrip_from_pk (pk, &hexgrip);
1150           if (err)
1151             goto leave;
1152
1153           desc = gpg_format_keydesc (pk, FORMAT_KEYDESC_NORMAL, 1);
1154           err = agent_passwd (ctrl, hexgrip, desc, &cache_nonce, &passwd_nonce);
1155           xfree (desc);
1156
1157           if (err)
1158             log_log ((gpg_err_code (err) == GPG_ERR_CANCELED
1159                       || gpg_err_code (err) == GPG_ERR_FULLY_CANCELED)
1160                      ? GPGRT_LOG_INFO : GPGRT_LOG_ERROR,
1161                      _("key %s: error changing passphrase: %s\n"),
1162                        keystr_with_sub (keyid, subid),
1163                        gpg_strerror (err));
1164           if (gpg_err_code (err) == GPG_ERR_FULLY_CANCELED)
1165             break;
1166         }
1167     }
1168
1169  leave:
1170   xfree (hexgrip);
1171   xfree (cache_nonce);
1172   xfree (passwd_nonce);
1173   return err;
1174 }
1175
1176
1177 \f
1178 /*
1179  * There are some keys out (due to a bug in gnupg), where the sequence
1180  * of the packets is wrong.  This function fixes that.
1181  * Returns: true if the keyblock has been fixed.
1182  *
1183  * Note:  This function does not work if there is more than one user ID.
1184  */
1185 static int
1186 fix_key_signature_order (KBNODE keyblock)
1187 {
1188   KBNODE node, last, subkey;
1189   int fixed = 0;
1190
1191   /* Locate key signatures of class 0x10..0x13 behind sub key packets.  */
1192   for (subkey = last = NULL, node = keyblock; node;
1193        last = node, node = node->next)
1194     {
1195       switch (node->pkt->pkttype)
1196         {
1197         case PKT_PUBLIC_SUBKEY:
1198         case PKT_SECRET_SUBKEY:
1199           if (!subkey)
1200             subkey = last; /* Actually it is the one before the subkey.  */
1201           break;
1202         case PKT_SIGNATURE:
1203           if (subkey)
1204             {
1205               PKT_signature *sig = node->pkt->pkt.signature;
1206               if (sig->sig_class >= 0x10 && sig->sig_class <= 0x13)
1207                 {
1208                   log_info (_("moving a key signature to the correct place\n"));
1209                   last->next = node->next;
1210                   node->next = subkey->next;
1211                   subkey->next = node;
1212                   node = last;
1213                   fixed = 1;
1214                 }
1215             }
1216           break;
1217         default:
1218           break;
1219         }
1220     }
1221
1222   return fixed;
1223 }
1224
1225
1226 /* Fix various problems in the keyblock.  Returns true if the keyblock
1227    was changed.  Note that a pointer to the keyblock must be given and
1228    the function may change it (i.e. replacing the first node).  */
1229 static int
1230 fix_keyblock (kbnode_t *keyblockp)
1231 {
1232   int changed = 0;
1233
1234   if (fix_key_signature_order (*keyblockp))
1235     changed++;
1236   if (collapse_uids (keyblockp))
1237     changed++;
1238   reorder_keyblock (*keyblockp);
1239   /* If we modified the keyblock, make sure the flags are right. */
1240   if (changed)
1241     merge_keys_and_selfsig (*keyblockp);
1242
1243   return changed;
1244 }
1245
1246
1247 static int
1248 parse_sign_type (const char *str, int *localsig, int *nonrevokesig,
1249                  int *trustsig)
1250 {
1251   const char *p = str;
1252
1253   while (*p)
1254     {
1255       if (ascii_strncasecmp (p, "l", 1) == 0)
1256         {
1257           *localsig = 1;
1258           p++;
1259         }
1260       else if (ascii_strncasecmp (p, "nr", 2) == 0)
1261         {
1262           *nonrevokesig = 1;
1263           p += 2;
1264         }
1265       else if (ascii_strncasecmp (p, "t", 1) == 0)
1266         {
1267           *trustsig = 1;
1268           p++;
1269         }
1270       else
1271         return 0;
1272     }
1273
1274   return 1;
1275 }
1276
1277
1278 \f
1279 /*
1280  * Menu driven key editor.  If seckey_check is true, then a secret key
1281  * that matches username will be looked for.  If it is false, not all
1282  * commands will be available.
1283  *
1284  * Note: to keep track of certain selections we use node->mark MARKBIT_xxxx.
1285  */
1286
1287 /* Need an SK for this command */
1288 #define KEYEDIT_NEED_SK 1
1289 /* Cannot be viewing the SK for this command */
1290 #define KEYEDIT_NOT_SK  2
1291 /* Must be viewing the SK for this command */
1292 #define KEYEDIT_ONLY_SK 4
1293 /* Match the tail of the string */
1294 #define KEYEDIT_TAIL_MATCH 8
1295
1296 enum cmdids
1297 {
1298   cmdNONE = 0,
1299   cmdQUIT, cmdHELP, cmdFPR, cmdLIST, cmdSELUID, cmdCHECK, cmdSIGN,
1300   cmdREVSIG, cmdREVKEY, cmdREVUID, cmdDELSIG, cmdPRIMARY, cmdDEBUG,
1301   cmdSAVE, cmdADDUID, cmdADDPHOTO, cmdDELUID, cmdADDKEY, cmdDELKEY,
1302   cmdADDREVOKER, cmdTOGGLE, cmdSELKEY, cmdPASSWD, cmdTRUST, cmdPREF,
1303   cmdEXPIRE, cmdBACKSIGN,
1304 #ifndef NO_TRUST_MODELS
1305   cmdENABLEKEY, cmdDISABLEKEY,
1306 #endif /*!NO_TRUST_MODELS*/
1307   cmdSHOWPREF,
1308   cmdSETPREF, cmdPREFKS, cmdNOTATION, cmdINVCMD, cmdSHOWPHOTO, cmdUPDTRUST,
1309   cmdCHKTRUST, cmdADDCARDKEY, cmdKEYTOCARD, cmdBKUPTOCARD, cmdCHECKBKUPKEY,
1310   cmdCLEAN, cmdMINIMIZE, cmdGRIP, cmdNOP
1311 };
1312
1313 static struct
1314 {
1315   const char *name;
1316   enum cmdids id;
1317   int flags;
1318   const char *desc;
1319 } cmds[] =
1320 {
1321   { "quit", cmdQUIT, 0, N_("quit this menu")},
1322   { "q", cmdQUIT, 0, NULL},
1323   { "save", cmdSAVE, 0, N_("save and quit")},
1324   { "help", cmdHELP, 0, N_("show this help")},
1325   { "?", cmdHELP, 0, NULL},
1326   { "fpr", cmdFPR, 0, N_("show key fingerprint")},
1327   { "grip", cmdGRIP, 0, N_("show the keygrip")},
1328   { "list", cmdLIST, 0, N_("list key and user IDs")},
1329   { "l", cmdLIST, 0, NULL},
1330   { "uid", cmdSELUID, 0, N_("select user ID N")},
1331   { "key", cmdSELKEY, 0, N_("select subkey N")},
1332   { "check", cmdCHECK, 0, N_("check signatures")},
1333   { "c", cmdCHECK, 0, NULL},
1334   { "cross-certify", cmdBACKSIGN, KEYEDIT_NOT_SK | KEYEDIT_NEED_SK, NULL},
1335   { "backsign", cmdBACKSIGN, KEYEDIT_NOT_SK | KEYEDIT_NEED_SK, NULL},
1336   { "sign", cmdSIGN, KEYEDIT_NOT_SK | KEYEDIT_TAIL_MATCH,
1337     N_("sign selected user IDs [* see below for related commands]")},
1338   { "s", cmdSIGN, KEYEDIT_NOT_SK, NULL},
1339     /* "lsign" and friends will never match since "sign" comes first
1340        and it is a tail match.  They are just here so they show up in
1341        the help menu. */
1342   { "lsign", cmdNOP, 0, N_("sign selected user IDs locally")},
1343   { "tsign", cmdNOP, 0, N_("sign selected user IDs with a trust signature")},
1344   { "nrsign", cmdNOP, 0,
1345     N_("sign selected user IDs with a non-revocable signature")},
1346   { "debug", cmdDEBUG, 0, NULL},
1347   { "adduid", cmdADDUID, KEYEDIT_NOT_SK | KEYEDIT_NEED_SK, N_("add a user ID")},
1348   { "addphoto", cmdADDPHOTO, KEYEDIT_NOT_SK | KEYEDIT_NEED_SK,
1349     N_("add a photo ID")},
1350   { "deluid", cmdDELUID, KEYEDIT_NOT_SK, N_("delete selected user IDs")},
1351     /* delphoto is really deluid in disguise */
1352   { "delphoto", cmdDELUID, KEYEDIT_NOT_SK, NULL},
1353   { "addkey", cmdADDKEY, KEYEDIT_NOT_SK | KEYEDIT_NEED_SK, N_("add a subkey")},
1354 #ifdef ENABLE_CARD_SUPPORT
1355   { "addcardkey", cmdADDCARDKEY, KEYEDIT_NOT_SK | KEYEDIT_NEED_SK,
1356     N_("add a key to a smartcard")},
1357   { "keytocard", cmdKEYTOCARD, KEYEDIT_NEED_SK | KEYEDIT_ONLY_SK,
1358     N_("move a key to a smartcard")},
1359   { "bkuptocard", cmdBKUPTOCARD, KEYEDIT_NEED_SK | KEYEDIT_ONLY_SK,
1360     N_("move a backup key to a smartcard")},
1361   { "checkbkupkey", cmdCHECKBKUPKEY, KEYEDIT_NEED_SK | KEYEDIT_ONLY_SK, NULL},
1362 #endif /*ENABLE_CARD_SUPPORT */
1363   { "delkey", cmdDELKEY, KEYEDIT_NOT_SK, N_("delete selected subkeys")},
1364   { "addrevoker", cmdADDREVOKER, KEYEDIT_NOT_SK | KEYEDIT_NEED_SK,
1365     N_("add a revocation key")},
1366   { "delsig", cmdDELSIG, KEYEDIT_NOT_SK,
1367     N_("delete signatures from the selected user IDs")},
1368   { "expire", cmdEXPIRE, KEYEDIT_NOT_SK | KEYEDIT_NEED_SK,
1369     N_("change the expiration date for the key or selected subkeys")},
1370   { "primary", cmdPRIMARY, KEYEDIT_NOT_SK | KEYEDIT_NEED_SK,
1371     N_("flag the selected user ID as primary")},
1372   { "toggle", cmdTOGGLE, KEYEDIT_NEED_SK, NULL},  /* Dummy command.  */
1373   { "t", cmdTOGGLE, KEYEDIT_NEED_SK, NULL},
1374   { "pref", cmdPREF, KEYEDIT_NOT_SK, N_("list preferences (expert)")},
1375   { "showpref", cmdSHOWPREF, KEYEDIT_NOT_SK, N_("list preferences (verbose)")},
1376   { "setpref", cmdSETPREF, KEYEDIT_NOT_SK | KEYEDIT_NEED_SK,
1377     N_("set preference list for the selected user IDs")},
1378   { "updpref", cmdSETPREF, KEYEDIT_NOT_SK | KEYEDIT_NEED_SK, NULL},
1379   { "keyserver", cmdPREFKS, KEYEDIT_NOT_SK | KEYEDIT_NEED_SK,
1380     N_("set the preferred keyserver URL for the selected user IDs")},
1381   { "notation", cmdNOTATION, KEYEDIT_NOT_SK | KEYEDIT_NEED_SK,
1382     N_("set a notation for the selected user IDs")},
1383   { "passwd", cmdPASSWD, KEYEDIT_NOT_SK | KEYEDIT_NEED_SK,
1384     N_("change the passphrase")},
1385   { "password", cmdPASSWD, KEYEDIT_NOT_SK | KEYEDIT_NEED_SK, NULL},
1386 #ifndef NO_TRUST_MODELS
1387   { "trust", cmdTRUST, KEYEDIT_NOT_SK, N_("change the ownertrust")},
1388 #endif /*!NO_TRUST_MODELS*/
1389   { "revsig", cmdREVSIG, KEYEDIT_NOT_SK,
1390     N_("revoke signatures on the selected user IDs")},
1391   { "revuid", cmdREVUID, KEYEDIT_NOT_SK | KEYEDIT_NEED_SK,
1392     N_("revoke selected user IDs")},
1393   { "revphoto", cmdREVUID, KEYEDIT_NOT_SK | KEYEDIT_NEED_SK, NULL},
1394   { "revkey", cmdREVKEY, KEYEDIT_NOT_SK | KEYEDIT_NEED_SK,
1395     N_("revoke key or selected subkeys")},
1396 #ifndef NO_TRUST_MODELS
1397   { "enable", cmdENABLEKEY, KEYEDIT_NOT_SK, N_("enable key")},
1398   { "disable", cmdDISABLEKEY, KEYEDIT_NOT_SK, N_("disable key")},
1399 #endif /*!NO_TRUST_MODELS*/
1400   { "showphoto", cmdSHOWPHOTO, 0, N_("show selected photo IDs")},
1401   { "clean", cmdCLEAN, KEYEDIT_NOT_SK,
1402     N_("compact unusable user IDs and remove unusable signatures from key")},
1403   { "minimize", cmdMINIMIZE, KEYEDIT_NOT_SK,
1404     N_("compact unusable user IDs and remove all signatures from key")},
1405
1406   { NULL, cmdNONE, 0, NULL}
1407 };
1408
1409
1410 \f
1411 #ifdef HAVE_LIBREADLINE
1412
1413 /*
1414    These two functions are used by readline for command completion.
1415  */
1416
1417 static char *
1418 command_generator (const char *text, int state)
1419 {
1420   static int list_index, len;
1421   const char *name;
1422
1423   /* If this is a new word to complete, initialize now.  This includes
1424      saving the length of TEXT for efficiency, and initializing the
1425      index variable to 0. */
1426   if (!state)
1427     {
1428       list_index = 0;
1429       len = strlen (text);
1430     }
1431
1432   /* Return the next partial match */
1433   while ((name = cmds[list_index].name))
1434     {
1435       /* Only complete commands that have help text */
1436       if (cmds[list_index++].desc && strncmp (name, text, len) == 0)
1437         return strdup (name);
1438     }
1439
1440   return NULL;
1441 }
1442
1443 static char **
1444 keyedit_completion (const char *text, int start, int end)
1445 {
1446   /* If we are at the start of a line, we try and command-complete.
1447      If not, just do nothing for now. */
1448
1449   (void) end;
1450
1451   if (start == 0)
1452     return rl_completion_matches (text, command_generator);
1453
1454   rl_attempted_completion_over = 1;
1455
1456   return NULL;
1457 }
1458 #endif /* HAVE_LIBREADLINE */
1459
1460
1461 \f
1462 /* Main function of the menu driven key editor.  */
1463 void
1464 keyedit_menu (ctrl_t ctrl, const char *username, strlist_t locusr,
1465               strlist_t commands, int quiet, int seckey_check)
1466 {
1467   enum cmdids cmd = 0;
1468   gpg_error_t err = 0;
1469   KBNODE keyblock = NULL;
1470   KEYDB_HANDLE kdbhd = NULL;
1471   int have_seckey = 0;
1472   char *answer = NULL;
1473   int redisplay = 1;
1474   int modified = 0;
1475   int sec_shadowing = 0;
1476   int run_subkey_warnings = 0;
1477   int have_commands = !!commands;
1478
1479   if (opt.command_fd != -1)
1480     ;
1481   else if (opt.batch && !have_commands)
1482     {
1483       log_error (_("can't do this in batch mode\n"));
1484       goto leave;
1485     }
1486
1487 #ifdef HAVE_W32_SYSTEM
1488   /* Due to Windows peculiarities we need to make sure that the
1489      trustdb stale check is done before we open another file
1490      (i.e. by searching for a key).  In theory we could make sure
1491      that the files are closed after use but the open/close caches
1492      inhibits that and flushing the cache right before the stale
1493      check is not easy to implement.  Thus we take the easy way out
1494      and run the stale check as early as possible.  Note, that for
1495      non- W32 platforms it is run indirectly trough a call to
1496      get_validity ().  */
1497   check_trustdb_stale ();
1498 #endif
1499
1500   /* Get the public key */
1501   err = get_pubkey_byname (ctrl, NULL, NULL, username, &keyblock, &kdbhd, 1, 1);
1502   if (err)
1503     {
1504       log_error (_("key \"%s\" not found: %s\n"), username, gpg_strerror (err));
1505       goto leave;
1506     }
1507
1508   if (fix_keyblock (&keyblock))
1509     modified++;
1510
1511   /* See whether we have a matching secret key.  */
1512   if (seckey_check)
1513     {
1514       have_seckey = !agent_probe_any_secret_key (ctrl, keyblock);
1515       if (have_seckey && !quiet)
1516         tty_printf (_("Secret key is available.\n"));
1517     }
1518
1519   /* Main command loop.  */
1520   for (;;)
1521     {
1522       int i, arg_number, photo;
1523       const char *arg_string = "";
1524       char *p;
1525       PKT_public_key *pk = keyblock->pkt->pkt.public_key;
1526
1527       tty_printf ("\n");
1528
1529       if (redisplay && !quiet)
1530         {
1531           /* Show using flags: with_revoker, with_subkeys.  */
1532           show_key_with_all_names (ctrl, NULL, keyblock, 0, 1, 0, 1, 0, 0);
1533           tty_printf ("\n");
1534           redisplay = 0;
1535         }
1536
1537       if (run_subkey_warnings)
1538         {
1539           run_subkey_warnings = 0;
1540           if (!count_selected_keys (keyblock))
1541             subkey_expire_warning (keyblock);
1542         }
1543
1544       do
1545         {
1546           xfree (answer);
1547           if (have_commands)
1548             {
1549               if (commands)
1550                 {
1551                   answer = xstrdup (commands->d);
1552                   commands = commands->next;
1553                 }
1554               else if (opt.batch)
1555                 {
1556                   answer = xstrdup ("quit");
1557                 }
1558               else
1559                 have_commands = 0;
1560             }
1561           if (!have_commands)
1562             {
1563 #ifdef HAVE_LIBREADLINE
1564               tty_enable_completion (keyedit_completion);
1565 #endif
1566               answer = cpr_get_no_help ("keyedit.prompt", GPG_NAME "> ");
1567               cpr_kill_prompt ();
1568               tty_disable_completion ();
1569             }
1570           trim_spaces (answer);
1571         }
1572       while (*answer == '#');
1573
1574       arg_number = 0; /* Here is the init which egcc complains about.  */
1575       photo = 0;      /* Same here. */
1576       if (!*answer)
1577         cmd = cmdLIST;
1578       else if (*answer == CONTROL_D)
1579         cmd = cmdQUIT;
1580       else if (digitp (answer))
1581         {
1582           cmd = cmdSELUID;
1583           arg_number = atoi (answer);
1584         }
1585       else
1586         {
1587           if ((p = strchr (answer, ' ')))
1588             {
1589               *p++ = 0;
1590               trim_spaces (answer);
1591               trim_spaces (p);
1592               arg_number = atoi (p);
1593               arg_string = p;
1594             }
1595
1596           for (i = 0; cmds[i].name; i++)
1597             {
1598               if (cmds[i].flags & KEYEDIT_TAIL_MATCH)
1599                 {
1600                   size_t l = strlen (cmds[i].name);
1601                   size_t a = strlen (answer);
1602                   if (a >= l)
1603                     {
1604                       if (!ascii_strcasecmp (&answer[a - l], cmds[i].name))
1605                         {
1606                           answer[a - l] = '\0';
1607                           break;
1608                         }
1609                     }
1610                 }
1611               else if (!ascii_strcasecmp (answer, cmds[i].name))
1612                 break;
1613             }
1614           if ((cmds[i].flags & KEYEDIT_NEED_SK) && !have_seckey)
1615             {
1616               tty_printf (_("Need the secret key to do this.\n"));
1617               cmd = cmdNOP;
1618             }
1619           else
1620             cmd = cmds[i].id;
1621         }
1622
1623       /* Dispatch the command.  */
1624       switch (cmd)
1625         {
1626         case cmdHELP:
1627           for (i = 0; cmds[i].name; i++)
1628             {
1629               if ((cmds[i].flags & KEYEDIT_NEED_SK) && !have_seckey)
1630                 ; /* Skip those item if we do not have the secret key.  */
1631               else if (cmds[i].desc)
1632                 tty_printf ("%-11s %s\n", cmds[i].name, _(cmds[i].desc));
1633             }
1634
1635           tty_printf ("\n");
1636           tty_printf
1637             (_("* The 'sign' command may be prefixed with an 'l' for local "
1638                "signatures (lsign),\n"
1639                "  a 't' for trust signatures (tsign), an 'nr' for "
1640                "non-revocable signatures\n"
1641                "  (nrsign), or any combination thereof (ltsign, "
1642                "tnrsign, etc.).\n"));
1643           break;
1644
1645         case cmdLIST:
1646           redisplay = 1;
1647           break;
1648
1649         case cmdFPR:
1650           show_key_and_fingerprint
1651             (keyblock, (*arg_string == '*'
1652                         && (!arg_string[1] || spacep (arg_string + 1))));
1653           break;
1654
1655         case cmdGRIP:
1656           show_key_and_grip (keyblock);
1657           break;
1658
1659         case cmdSELUID:
1660           if (strlen (arg_string) == NAMEHASH_LEN * 2)
1661             redisplay = menu_select_uid_namehash (keyblock, arg_string);
1662           else
1663             {
1664               if (*arg_string == '*'
1665                   && (!arg_string[1] || spacep (arg_string + 1)))
1666                 arg_number = -1;        /* Select all. */
1667               redisplay = menu_select_uid (keyblock, arg_number);
1668             }
1669           break;
1670
1671         case cmdSELKEY:
1672           {
1673             if (*arg_string == '*'
1674                 && (!arg_string[1] || spacep (arg_string + 1)))
1675               arg_number = -1;  /* Select all. */
1676             if (menu_select_key (keyblock, arg_number))
1677               redisplay = 1;
1678           }
1679           break;
1680
1681         case cmdCHECK:
1682           check_all_keysigs (keyblock, count_selected_uids (keyblock));
1683           break;
1684
1685         case cmdSIGN:
1686           {
1687             int localsig = 0, nonrevokesig = 0, trustsig = 0, interactive = 0;
1688
1689             if (pk->flags.revoked)
1690               {
1691                 tty_printf (_("Key is revoked."));
1692
1693                 if (opt.expert)
1694                   {
1695                     tty_printf ("  ");
1696                     if (!cpr_get_answer_is_yes
1697                         ("keyedit.sign_revoked.okay",
1698                          _("Are you sure you still want to sign it? (y/N) ")))
1699                       break;
1700                   }
1701                 else
1702                   {
1703                     tty_printf (_("  Unable to sign.\n"));
1704                     break;
1705                   }
1706               }
1707
1708             if (count_uids (keyblock) > 1 && !count_selected_uids (keyblock)
1709                 && !cpr_get_answer_is_yes ("keyedit.sign_all.okay",
1710                                            _("Really sign all user IDs?"
1711                                              " (y/N) ")))
1712               {
1713                 if (opt.interactive)
1714                   interactive = 1;
1715                 else
1716                   {
1717                     tty_printf (_("Hint: Select the user IDs to sign\n"));
1718                     have_commands = 0;
1719                     break;
1720                   }
1721
1722               }
1723             /* What sort of signing are we doing? */
1724             if (!parse_sign_type
1725                 (answer, &localsig, &nonrevokesig, &trustsig))
1726               {
1727                 tty_printf (_("Unknown signature type '%s'\n"), answer);
1728                 break;
1729               }
1730
1731             sign_uids (ctrl, NULL, keyblock, locusr, &modified,
1732                        localsig, nonrevokesig, trustsig, interactive, 0);
1733           }
1734           break;
1735
1736         case cmdDEBUG:
1737           dump_kbnode (keyblock);
1738           break;
1739
1740         case cmdTOGGLE:
1741           /* The toggle command is a leftover from old gpg versions
1742              where we worked with a secret and a public keyring.  It
1743              is not necessary anymore but we keep this command for the
1744              sake of scripts using it.  */
1745           redisplay = 1;
1746           break;
1747
1748         case cmdADDPHOTO:
1749           if (RFC2440)
1750             {
1751               tty_printf (_("This command is not allowed while in %s mode.\n"),
1752                           compliance_option_string ());
1753               break;
1754             }
1755           photo = 1;
1756           /* fall through */
1757         case cmdADDUID:
1758           if (menu_adduid (keyblock, photo, arg_string, NULL))
1759             {
1760               update_trust = 1;
1761               redisplay = 1;
1762               modified = 1;
1763               merge_keys_and_selfsig (keyblock);
1764             }
1765           break;
1766
1767         case cmdDELUID:
1768           {
1769             int n1;
1770
1771             if (!(n1 = count_selected_uids (keyblock)))
1772               {
1773                 tty_printf (_("You must select at least one user ID.\n"));
1774                 if (!opt.expert)
1775                   tty_printf (_("(Use the '%s' command.)\n"), "uid");
1776               }
1777             else if (real_uids_left (keyblock) < 1)
1778               tty_printf (_("You can't delete the last user ID!\n"));
1779             else if (cpr_get_answer_is_yes
1780                      ("keyedit.remove.uid.okay",
1781                       n1 > 1 ? _("Really remove all selected user IDs? (y/N) ")
1782                       :        _("Really remove this user ID? (y/N) ")))
1783               {
1784                 menu_deluid (keyblock);
1785                 redisplay = 1;
1786                 modified = 1;
1787               }
1788           }
1789           break;
1790
1791         case cmdDELSIG:
1792           {
1793             int n1;
1794
1795             if (!(n1 = count_selected_uids (keyblock)))
1796               {
1797                 tty_printf (_("You must select at least one user ID.\n"));
1798                 if (!opt.expert)
1799                   tty_printf (_("(Use the '%s' command.)\n"), "uid");
1800               }
1801             else if (menu_delsig (keyblock))
1802               {
1803                 /* No redisplay here, because it may scroll away some
1804                  * of the status output of this command.  */
1805                 modified = 1;
1806               }
1807           }
1808           break;
1809
1810         case cmdADDKEY:
1811           if (!generate_subkeypair (ctrl, keyblock))
1812             {
1813               redisplay = 1;
1814               modified = 1;
1815               merge_keys_and_selfsig (keyblock);
1816             }
1817           break;
1818
1819 #ifdef ENABLE_CARD_SUPPORT
1820         case cmdADDCARDKEY:
1821           if (!card_generate_subkey (keyblock))
1822             {
1823               redisplay = 1;
1824               modified = 1;
1825               merge_keys_and_selfsig (keyblock);
1826             }
1827           break;
1828
1829         case cmdKEYTOCARD:
1830           {
1831             KBNODE node = NULL;
1832             switch (count_selected_keys (keyblock))
1833               {
1834               case 0:
1835                 if (cpr_get_answer_is_yes
1836                     ("keyedit.keytocard.use_primary",
1837                      /* TRANSLATORS: Please take care: This is about
1838                         moving the key and not about removing it.  */
1839                      _("Really move the primary key? (y/N) ")))
1840                   node = keyblock;
1841                 break;
1842               case 1:
1843                 for (node = keyblock; node; node = node->next)
1844                   {
1845                     if (node->pkt->pkttype == PKT_PUBLIC_SUBKEY
1846                         && node->flag & NODFLG_SELKEY)
1847                       break;
1848                   }
1849                 break;
1850               default:
1851                 tty_printf (_("You must select exactly one key.\n"));
1852                 break;
1853               }
1854             if (node)
1855               {
1856                 PKT_public_key *xxpk = node->pkt->pkt.public_key;
1857                 if (card_store_subkey (node, xxpk ? xxpk->pubkey_usage : 0))
1858                   {
1859                     redisplay = 1;
1860                     sec_shadowing = 1;
1861                   }
1862               }
1863           }
1864           break;
1865
1866         case cmdBKUPTOCARD:
1867         case cmdCHECKBKUPKEY:
1868           log_debug ("FIXME: This needs to be changed\n");
1869           {
1870             /* Ask for a filename, check whether this is really a
1871                backup key as generated by the card generation, parse
1872                that key and store it on card. */
1873             KBNODE node;
1874             const char *fname;
1875             PACKET *pkt;
1876             IOBUF a;
1877
1878             fname = arg_string;
1879             if (!*fname)
1880               {
1881                 tty_printf (_("Command expects a filename argument\n"));
1882                 break;
1883               }
1884
1885             /* Open that file.  */
1886             a = iobuf_open (fname);
1887             if (a && is_secured_file (iobuf_get_fd (a)))
1888               {
1889                 iobuf_close (a);
1890                 a = NULL;
1891                 gpg_err_set_errno (EPERM);
1892               }
1893             if (!a)
1894               {
1895                 tty_printf (_("Can't open '%s': %s\n"),
1896                             fname, strerror (errno));
1897                 break;
1898               }
1899
1900             /* Parse and check that file.  */
1901             pkt = xmalloc (sizeof *pkt);
1902             init_packet (pkt);
1903             err = parse_packet (a, pkt);
1904             iobuf_close (a);
1905             iobuf_ioctl (NULL, IOBUF_IOCTL_INVALIDATE_CACHE, 0, (char *) fname);
1906             if (!err && pkt->pkttype != PKT_SECRET_KEY
1907                 && pkt->pkttype != PKT_SECRET_SUBKEY)
1908               err = GPG_ERR_NO_SECKEY;
1909             if (err)
1910               {
1911                 tty_printf (_("Error reading backup key from '%s': %s\n"),
1912                             fname, gpg_strerror (err));
1913                 free_packet (pkt);
1914                 xfree (pkt);
1915                 break;
1916               }
1917             node = new_kbnode (pkt);
1918
1919             if (cmd == cmdCHECKBKUPKEY)
1920               {
1921                 /* PKT_public_key *sk = node->pkt->pkt.secret_key; */
1922                 /* switch (is_secret_key_protected (sk)) */
1923                 /*   { */
1924                 /*   case 0:    /\* Not protected. *\/ */
1925                 /*     tty_printf (_("This key is not protected.\n")); */
1926                 /*     break; */
1927                 /*   case -1: */
1928                 /*     log_error (_("unknown key protection algorithm\n")); */
1929                 /*     break; */
1930                 /*   default: */
1931                 /*     if (sk->protect.s2k.mode == 1001) */
1932                 /*       tty_printf (_("Secret parts of key" */
1933                 /*                  " are not available.\n")); */
1934                 /*     if (sk->protect.s2k.mode == 1002) */
1935                 /*       tty_printf (_("Secret parts of key" */
1936                 /*                  " are stored on-card.\n")); */
1937                     /* else */
1938                     /*   check_secret_key (sk, 0); */
1939                   /* } */
1940               }
1941             else                /* Store it.  */
1942               {
1943                 if (card_store_subkey (node, 0))
1944                   {
1945                     redisplay = 1;
1946                     sec_shadowing = 1;
1947                   }
1948               }
1949             release_kbnode (node);
1950           }
1951           break;
1952
1953 #endif /* ENABLE_CARD_SUPPORT */
1954
1955         case cmdDELKEY:
1956           {
1957             int n1;
1958
1959             if (!(n1 = count_selected_keys (keyblock)))
1960               {
1961                 tty_printf (_("You must select at least one key.\n"));
1962                 if (!opt.expert)
1963                   tty_printf (_("(Use the '%s' command.)\n"), "key");
1964               }
1965             else if (!cpr_get_answer_is_yes
1966                      ("keyedit.remove.subkey.okay",
1967                       n1 > 1 ? _("Do you really want to delete the "
1968                                  "selected keys? (y/N) ")
1969                       :  _("Do you really want to delete this key? (y/N) ")))
1970               ;
1971             else
1972               {
1973                 menu_delkey (keyblock);
1974                 redisplay = 1;
1975                 modified = 1;
1976               }
1977           }
1978           break;
1979
1980         case cmdADDREVOKER:
1981           {
1982             int sensitive = 0;
1983
1984             if (ascii_strcasecmp (arg_string, "sensitive") == 0)
1985               sensitive = 1;
1986             if (menu_addrevoker (ctrl, keyblock, sensitive))
1987               {
1988                 redisplay = 1;
1989                 modified = 1;
1990                 merge_keys_and_selfsig (keyblock);
1991               }
1992           }
1993           break;
1994
1995         case cmdREVUID:
1996           {
1997             int n1;
1998
1999             if (!(n1 = count_selected_uids (keyblock)))
2000               {
2001                 tty_printf (_("You must select at least one user ID.\n"));
2002                 if (!opt.expert)
2003                   tty_printf (_("(Use the '%s' command.)\n"), "uid");
2004               }
2005             else if (cpr_get_answer_is_yes
2006                      ("keyedit.revoke.uid.okay",
2007                       n1 > 1 ? _("Really revoke all selected user IDs? (y/N) ")
2008                       :        _("Really revoke this user ID? (y/N) ")))
2009               {
2010                 if (menu_revuid (keyblock))
2011                   {
2012                     modified = 1;
2013                     redisplay = 1;
2014                   }
2015               }
2016           }
2017           break;
2018
2019         case cmdREVKEY:
2020           {
2021             int n1;
2022
2023             if (!(n1 = count_selected_keys (keyblock)))
2024               {
2025                 if (cpr_get_answer_is_yes ("keyedit.revoke.subkey.okay",
2026                                            _("Do you really want to revoke"
2027                                              " the entire key? (y/N) ")))
2028                   {
2029                     if (menu_revkey (keyblock))
2030                       modified = 1;
2031
2032                     redisplay = 1;
2033                   }
2034               }
2035             else if (cpr_get_answer_is_yes ("keyedit.revoke.subkey.okay",
2036                                             n1 > 1 ?
2037                                             _("Do you really want to revoke"
2038                                               " the selected subkeys? (y/N) ")
2039                                             : _("Do you really want to revoke"
2040                                                 " this subkey? (y/N) ")))
2041               {
2042                 if (menu_revsubkey (keyblock))
2043                   modified = 1;
2044
2045                 redisplay = 1;
2046               }
2047
2048             if (modified)
2049               merge_keys_and_selfsig (keyblock);
2050           }
2051           break;
2052
2053         case cmdEXPIRE:
2054           if (menu_expire (keyblock))
2055             {
2056               merge_keys_and_selfsig (keyblock);
2057               run_subkey_warnings = 1;
2058               modified = 1;
2059               redisplay = 1;
2060             }
2061           break;
2062
2063         case cmdBACKSIGN:
2064           if (menu_backsign (keyblock))
2065             {
2066               modified = 1;
2067               redisplay = 1;
2068             }
2069           break;
2070
2071         case cmdPRIMARY:
2072           if (menu_set_primary_uid (keyblock))
2073             {
2074               merge_keys_and_selfsig (keyblock);
2075               modified = 1;
2076               redisplay = 1;
2077             }
2078           break;
2079
2080         case cmdPASSWD:
2081           change_passphrase (ctrl, keyblock);
2082           break;
2083
2084 #ifndef NO_TRUST_MODELS
2085         case cmdTRUST:
2086           if (opt.trust_model == TM_EXTERNAL)
2087             {
2088               tty_printf (_("Owner trust may not be set while "
2089                             "using a user provided trust database\n"));
2090               break;
2091             }
2092
2093           show_key_with_all_names (ctrl, NULL, keyblock, 0, 0, 0, 1, 0, 0);
2094           tty_printf ("\n");
2095           if (edit_ownertrust (find_kbnode (keyblock,
2096                                             PKT_PUBLIC_KEY)->pkt->pkt.
2097                                public_key, 1))
2098             {
2099               redisplay = 1;
2100               /* No real need to set update_trust here as
2101                  edit_ownertrust() calls revalidation_mark()
2102                  anyway. */
2103               update_trust = 1;
2104             }
2105           break;
2106 #endif /*!NO_TRUST_MODELS*/
2107
2108         case cmdPREF:
2109           {
2110             int count = count_selected_uids (keyblock);
2111             assert (keyblock->pkt->pkttype == PKT_PUBLIC_KEY);
2112             show_names (NULL, keyblock, keyblock->pkt->pkt.public_key,
2113                         count ? NODFLG_SELUID : 0, 1);
2114           }
2115           break;
2116
2117         case cmdSHOWPREF:
2118           {
2119             int count = count_selected_uids (keyblock);
2120             assert (keyblock->pkt->pkttype == PKT_PUBLIC_KEY);
2121             show_names (NULL, keyblock, keyblock->pkt->pkt.public_key,
2122                         count ? NODFLG_SELUID : 0, 2);
2123           }
2124           break;
2125
2126         case cmdSETPREF:
2127           {
2128             PKT_user_id *tempuid;
2129
2130             keygen_set_std_prefs (!*arg_string ? "default" : arg_string, 0);
2131
2132             tempuid = keygen_get_std_prefs ();
2133             tty_printf (_("Set preference list to:\n"));
2134             show_prefs (tempuid, NULL, 1);
2135             free_user_id (tempuid);
2136
2137             if (cpr_get_answer_is_yes
2138                 ("keyedit.setpref.okay",
2139                  count_selected_uids (keyblock) ?
2140                  _("Really update the preferences"
2141                    " for the selected user IDs? (y/N) ")
2142                  : _("Really update the preferences? (y/N) ")))
2143               {
2144                 if (menu_set_preferences (keyblock))
2145                   {
2146                     merge_keys_and_selfsig (keyblock);
2147                     modified = 1;
2148                     redisplay = 1;
2149                   }
2150               }
2151           }
2152           break;
2153
2154         case cmdPREFKS:
2155           if (menu_set_keyserver_url (*arg_string ? arg_string : NULL,
2156                                       keyblock))
2157             {
2158               merge_keys_and_selfsig (keyblock);
2159               modified = 1;
2160               redisplay = 1;
2161             }
2162           break;
2163
2164         case cmdNOTATION:
2165           if (menu_set_notation (*arg_string ? arg_string : NULL,
2166                                  keyblock))
2167             {
2168               merge_keys_and_selfsig (keyblock);
2169               modified = 1;
2170               redisplay = 1;
2171             }
2172           break;
2173
2174         case cmdNOP:
2175           break;
2176
2177         case cmdREVSIG:
2178           if (menu_revsig (keyblock))
2179             {
2180               redisplay = 1;
2181               modified = 1;
2182             }
2183           break;
2184
2185 #ifndef NO_TRUST_MODELS
2186         case cmdENABLEKEY:
2187         case cmdDISABLEKEY:
2188           if (enable_disable_key (keyblock, cmd == cmdDISABLEKEY))
2189             {
2190               redisplay = 1;
2191               modified = 1;
2192             }
2193           break;
2194 #endif /*!NO_TRUST_MODELS*/
2195
2196         case cmdSHOWPHOTO:
2197           menu_showphoto (keyblock);
2198           break;
2199
2200         case cmdCLEAN:
2201           if (menu_clean (keyblock, 0))
2202             redisplay = modified = 1;
2203           break;
2204
2205         case cmdMINIMIZE:
2206           if (menu_clean (keyblock, 1))
2207             redisplay = modified = 1;
2208           break;
2209
2210         case cmdQUIT:
2211           if (have_commands)
2212             goto leave;
2213           if (!modified && !sec_shadowing)
2214             goto leave;
2215           if (!cpr_get_answer_is_yes ("keyedit.save.okay",
2216                                       _("Save changes? (y/N) ")))
2217             {
2218               if (cpr_enabled ()
2219                   || cpr_get_answer_is_yes ("keyedit.cancel.okay",
2220                                             _("Quit without saving? (y/N) ")))
2221                 goto leave;
2222               break;
2223             }
2224           /* fall thru */
2225         case cmdSAVE:
2226           if (modified)
2227             {
2228               err = keydb_update_keyblock (kdbhd, keyblock);
2229               if (err)
2230                 {
2231                   log_error (_("update failed: %s\n"), gpg_strerror (err));
2232                   break;
2233                 }
2234             }
2235
2236           if (sec_shadowing)
2237             {
2238               err = agent_scd_learn (NULL, 1);
2239               if (err)
2240                 {
2241                   log_error (_("update failed: %s\n"), gpg_strerror (err));
2242                   break;
2243                 }
2244             }
2245
2246           if (!modified && !sec_shadowing)
2247             tty_printf (_("Key not changed so no update needed.\n"));
2248
2249           if (update_trust)
2250             {
2251               revalidation_mark ();
2252               update_trust = 0;
2253             }
2254           goto leave;
2255
2256         case cmdINVCMD:
2257         default:
2258           tty_printf ("\n");
2259           tty_printf (_("Invalid command  (try \"help\")\n"));
2260           break;
2261         }
2262     } /* End of the main command loop.  */
2263
2264  leave:
2265   release_kbnode (keyblock);
2266   keydb_release (kdbhd);
2267   xfree (answer);
2268 }
2269
2270
2271 /* Change the passphrase of the secret key identified by USERNAME.  */
2272 void
2273 keyedit_passwd (ctrl_t ctrl, const char *username)
2274 {
2275   gpg_error_t err;
2276   PKT_public_key *pk;
2277   kbnode_t keyblock = NULL;
2278
2279   pk = xtrycalloc (1, sizeof *pk);
2280   if (!pk)
2281     {
2282       err = gpg_error_from_syserror ();
2283       goto leave;
2284     }
2285   err = getkey_byname (NULL, pk, username, 1, &keyblock);
2286   if (err)
2287     goto leave;
2288
2289   err = change_passphrase (ctrl, keyblock);
2290
2291 leave:
2292   release_kbnode (keyblock);
2293   free_public_key (pk);
2294   if (err)
2295     {
2296       log_info ("error changing the passphrase for '%s': %s\n",
2297                 username, gpg_strerror (err));
2298       write_status_error ("keyedit.passwd", err);
2299     }
2300   else
2301     write_status_text (STATUS_SUCCESS, "keyedit.passwd");
2302 }
2303
2304
2305 /* Unattended adding of a new keyid.  USERNAME specifies the
2306    key. NEWUID is the new user id to add to the key.  */
2307 void
2308 keyedit_quick_adduid (ctrl_t ctrl, const char *username, const char *newuid)
2309 {
2310   gpg_error_t err;
2311   KEYDB_HANDLE kdbhd = NULL;
2312   KEYDB_SEARCH_DESC desc;
2313   kbnode_t keyblock = NULL;
2314   kbnode_t node;
2315   char *uidstring = NULL;
2316
2317   uidstring = xstrdup (newuid);
2318   trim_spaces (uidstring);
2319   if (!*uidstring)
2320     {
2321       log_error ("%s\n", gpg_strerror (GPG_ERR_INV_USER_ID));
2322       goto leave;
2323     }
2324
2325 #ifdef HAVE_W32_SYSTEM
2326   /* See keyedit_menu for why we need this.  */
2327   check_trustdb_stale ();
2328 #endif
2329
2330   /* Search the key; we don't want the whole getkey stuff here.  */
2331   kdbhd = keydb_new ();
2332   err = classify_user_id (username, &desc, 1);
2333   if (!err)
2334     err = keydb_search (kdbhd, &desc, 1, NULL);
2335   if (!err)
2336     {
2337       err = keydb_get_keyblock (kdbhd, &keyblock);
2338       if (err)
2339         {
2340           log_error (_("error reading keyblock: %s\n"), gpg_strerror (err));
2341           goto leave;
2342         }
2343       /* Now with the keyblock retrieved, search again to detect an
2344          ambiguous specification.  We need to save the found state so
2345          that we can do an update later.  */
2346       keydb_push_found_state (kdbhd);
2347       err = keydb_search (kdbhd, &desc, 1, NULL);
2348       if (!err)
2349         err = gpg_error (GPG_ERR_AMBIGUOUS_NAME);
2350       else if (gpg_err_code (err) == GPG_ERR_NOT_FOUND)
2351         err = 0;
2352       keydb_pop_found_state (kdbhd);
2353
2354       if (!err)
2355         {
2356           /* We require the secret primary key to add a UID.  */
2357           node = find_kbnode (keyblock, PKT_PUBLIC_KEY);
2358           if (!node)
2359             BUG ();
2360           err = agent_probe_secret_key (ctrl, node->pkt->pkt.public_key);
2361         }
2362     }
2363   if (err)
2364     {
2365       log_error (_("secret key \"%s\" not found: %s\n"),
2366                  username, gpg_strerror (err));
2367       goto leave;
2368     }
2369
2370   fix_keyblock (&keyblock);
2371
2372   if (menu_adduid (keyblock, 0, NULL, uidstring))
2373     {
2374       err = keydb_update_keyblock (kdbhd, keyblock);
2375       if (err)
2376         {
2377           log_error (_("update failed: %s\n"), gpg_strerror (err));
2378           goto leave;
2379         }
2380
2381       if (update_trust)
2382         revalidation_mark ();
2383     }
2384
2385  leave:
2386   xfree (uidstring);
2387   release_kbnode (keyblock);
2388   keydb_release (kdbhd);
2389 }
2390
2391
2392 /* Unattended key signing function.  If the key specifified by FPR is
2393    availabale and FPR is the primary fingerprint all user ids of the
2394    user ids of the key are signed using the default signing key.  If
2395    UIDS is an empty list all usable UIDs are signed, if it is not
2396    empty, only those user ids matching one of the entries of the loist
2397    are signed.  With LOCAL being true kthe signatures are marked as
2398    non-exportable.  */
2399 void
2400 keyedit_quick_sign (ctrl_t ctrl, const char *fpr, strlist_t uids,
2401                     strlist_t locusr, int local)
2402 {
2403   gpg_error_t err;
2404   kbnode_t keyblock = NULL;
2405   KEYDB_HANDLE kdbhd = NULL;
2406   int modified = 0;
2407   KEYDB_SEARCH_DESC desc;
2408   PKT_public_key *pk;
2409   kbnode_t node;
2410   strlist_t sl;
2411   int any;
2412
2413 #ifdef HAVE_W32_SYSTEM
2414   /* See keyedit_menu for why we need this.  */
2415   check_trustdb_stale ();
2416 #endif
2417
2418   /* We require a fingerprint because only this uniquely identifies a
2419      key and may thus be used to select a key for unattended key
2420      signing.  */
2421   if (classify_user_id (fpr, &desc, 1)
2422       || !(desc.mode == KEYDB_SEARCH_MODE_FPR
2423            || desc.mode == KEYDB_SEARCH_MODE_FPR16
2424            || desc.mode == KEYDB_SEARCH_MODE_FPR20))
2425     {
2426       log_error (_("\"%s\" is not a fingerprint\n"), fpr);
2427       goto leave;
2428     }
2429   err = get_pubkey_byname (ctrl, NULL, NULL, fpr, &keyblock, &kdbhd, 1, 1);
2430   if (err)
2431     {
2432       log_error (_("key \"%s\" not found: %s\n"), fpr, gpg_strerror (err));
2433       goto leave;
2434     }
2435
2436   /* Check that the primary fingerprint has been given. */
2437   {
2438     byte fprbin[MAX_FINGERPRINT_LEN];
2439     size_t fprlen;
2440
2441     fingerprint_from_pk (keyblock->pkt->pkt.public_key, fprbin, &fprlen);
2442     if (fprlen == 16 && desc.mode == KEYDB_SEARCH_MODE_FPR16
2443         && !memcmp (fprbin, desc.u.fpr, 16))
2444       ;
2445     else if (fprlen == 16 && desc.mode == KEYDB_SEARCH_MODE_FPR
2446              && !memcmp (fprbin, desc.u.fpr, 16)
2447              && !desc.u.fpr[16]
2448              && !desc.u.fpr[17]
2449              && !desc.u.fpr[18]
2450              && !desc.u.fpr[19])
2451       ;
2452     else if (fprlen == 20 && (desc.mode == KEYDB_SEARCH_MODE_FPR20
2453                               || desc.mode == KEYDB_SEARCH_MODE_FPR)
2454              && !memcmp (fprbin, desc.u.fpr, 20))
2455       ;
2456     else
2457       {
2458         log_error (_("\"%s\" is not the primary fingerprint\n"), fpr);
2459         goto leave;
2460       }
2461   }
2462
2463   if (fix_keyblock (&keyblock))
2464     modified++;
2465
2466   /* Give some info in verbose.  */
2467   if (opt.verbose)
2468     {
2469       show_key_with_all_names (ctrl, es_stdout, keyblock, 0,
2470                                1/*with_revoker*/, 1/*with_fingerprint*/,
2471                                0, 0, 1);
2472       es_fflush (es_stdout);
2473     }
2474
2475   pk = keyblock->pkt->pkt.public_key;
2476   if (pk->flags.revoked)
2477     {
2478       if (!opt.verbose)
2479         show_key_with_all_names (ctrl, es_stdout, keyblock, 0, 0, 0, 0, 0, 1);
2480       log_error ("%s%s", _("Key is revoked."), _("  Unable to sign.\n"));
2481       goto leave;
2482     }
2483
2484   /* Set the flags according to the UIDS list.  Fixme: We may want to
2485      use classify_user_id along with dedicated compare functions so
2486      that we match the same way as in the key lookup. */
2487   any = 0;
2488   menu_select_uid (keyblock, 0);   /* Better clear the flags first. */
2489   for (sl=uids; sl; sl = sl->next)
2490     {
2491       for (node = keyblock; node; node = node->next)
2492         {
2493           if (node->pkt->pkttype == PKT_USER_ID)
2494             {
2495               PKT_user_id *uid = node->pkt->pkt.user_id;
2496
2497               if (!uid->attrib_data
2498                   && ascii_memistr (uid->name, uid->len, sl->d))
2499                 {
2500                   node->flag |= NODFLG_SELUID;
2501                   any = 1;
2502                 }
2503             }
2504         }
2505     }
2506
2507   if (uids && !any)
2508     {
2509       if (!opt.verbose)
2510         show_key_with_all_names (ctrl, es_stdout, keyblock, 0, 0, 0, 0, 0, 1);
2511       es_fflush (es_stdout);
2512       log_error ("%s  %s", _("No matching user IDs."), _("Nothing to sign.\n"));
2513       goto leave;
2514     }
2515
2516   /* Sign. */
2517   sign_uids (ctrl, es_stdout, keyblock, locusr, &modified, local, 0, 0, 0, 1);
2518   es_fflush (es_stdout);
2519
2520   if (modified)
2521     {
2522       err = keydb_update_keyblock (kdbhd, keyblock);
2523       if (err)
2524         {
2525           log_error (_("update failed: %s\n"), gpg_strerror (err));
2526           goto leave;
2527         }
2528     }
2529   else
2530     log_info (_("Key not changed so no update needed.\n"));
2531
2532   if (update_trust)
2533     revalidation_mark ();
2534
2535
2536  leave:
2537   release_kbnode (keyblock);
2538   keydb_release (kdbhd);
2539 }
2540
2541
2542 \f
2543 static void
2544 tty_print_notations (int indent, PKT_signature * sig)
2545 {
2546   int first = 1;
2547   struct notation *notation, *nd;
2548
2549   if (indent < 0)
2550     {
2551       first = 0;
2552       indent = -indent;
2553     }
2554
2555   notation = sig_to_notation (sig);
2556
2557   for (nd = notation; nd; nd = nd->next)
2558     {
2559       if (!first)
2560         tty_printf ("%*s", indent, "");
2561       else
2562         first = 0;
2563
2564       tty_print_utf8_string (nd->name, strlen (nd->name));
2565       tty_printf ("=");
2566       tty_print_utf8_string (nd->value, strlen (nd->value));
2567       tty_printf ("\n");
2568     }
2569
2570   free_notation (notation);
2571 }
2572
2573
2574 /*
2575  * Show preferences of a public keyblock.
2576  */
2577 static void
2578 show_prefs (PKT_user_id * uid, PKT_signature * selfsig, int verbose)
2579 {
2580   const prefitem_t fake = { 0, 0 };
2581   const prefitem_t *prefs;
2582   int i;
2583
2584   if (!uid)
2585     return;
2586
2587   if (uid->prefs)
2588     prefs = uid->prefs;
2589   else if (verbose)
2590     prefs = &fake;
2591   else
2592     return;
2593
2594   if (verbose)
2595     {
2596       int any, des_seen = 0, sha1_seen = 0, uncomp_seen = 0;
2597
2598       tty_printf ("     ");
2599       tty_printf (_("Cipher: "));
2600       for (i = any = 0; prefs[i].type; i++)
2601         {
2602           if (prefs[i].type == PREFTYPE_SYM)
2603             {
2604               if (any)
2605                 tty_printf (", ");
2606               any = 1;
2607               /* We don't want to display strings for experimental algos */
2608               if (!openpgp_cipher_test_algo (prefs[i].value)
2609                   && prefs[i].value < 100)
2610                 tty_printf ("%s", openpgp_cipher_algo_name (prefs[i].value));
2611               else
2612                 tty_printf ("[%d]", prefs[i].value);
2613               if (prefs[i].value == CIPHER_ALGO_3DES)
2614                 des_seen = 1;
2615             }
2616         }
2617       if (!des_seen)
2618         {
2619           if (any)
2620             tty_printf (", ");
2621           tty_printf ("%s", openpgp_cipher_algo_name (CIPHER_ALGO_3DES));
2622         }
2623       tty_printf ("\n     ");
2624       tty_printf (_("Digest: "));
2625       for (i = any = 0; prefs[i].type; i++)
2626         {
2627           if (prefs[i].type == PREFTYPE_HASH)
2628             {
2629               if (any)
2630                 tty_printf (", ");
2631               any = 1;
2632               /* We don't want to display strings for experimental algos */
2633               if (!gcry_md_test_algo (prefs[i].value) && prefs[i].value < 100)
2634                 tty_printf ("%s", gcry_md_algo_name (prefs[i].value));
2635               else
2636                 tty_printf ("[%d]", prefs[i].value);
2637               if (prefs[i].value == DIGEST_ALGO_SHA1)
2638                 sha1_seen = 1;
2639             }
2640         }
2641       if (!sha1_seen)
2642         {
2643           if (any)
2644             tty_printf (", ");
2645           tty_printf ("%s", gcry_md_algo_name (DIGEST_ALGO_SHA1));
2646         }
2647       tty_printf ("\n     ");
2648       tty_printf (_("Compression: "));
2649       for (i = any = 0; prefs[i].type; i++)
2650         {
2651           if (prefs[i].type == PREFTYPE_ZIP)
2652             {
2653               const char *s = compress_algo_to_string (prefs[i].value);
2654
2655               if (any)
2656                 tty_printf (", ");
2657               any = 1;
2658               /* We don't want to display strings for experimental algos */
2659               if (s && prefs[i].value < 100)
2660                 tty_printf ("%s", s);
2661               else
2662                 tty_printf ("[%d]", prefs[i].value);
2663               if (prefs[i].value == COMPRESS_ALGO_NONE)
2664                 uncomp_seen = 1;
2665             }
2666         }
2667       if (!uncomp_seen)
2668         {
2669           if (any)
2670             tty_printf (", ");
2671           else
2672             {
2673               tty_printf ("%s", compress_algo_to_string (COMPRESS_ALGO_ZIP));
2674               tty_printf (", ");
2675             }
2676           tty_printf ("%s", compress_algo_to_string (COMPRESS_ALGO_NONE));
2677         }
2678       if (uid->flags.mdc || !uid->flags.ks_modify)
2679         {
2680           tty_printf ("\n     ");
2681           tty_printf (_("Features: "));
2682           any = 0;
2683           if (uid->flags.mdc)
2684             {
2685               tty_printf ("MDC");
2686               any = 1;
2687             }
2688           if (!uid->flags.ks_modify)
2689             {
2690               if (any)
2691                 tty_printf (", ");
2692               tty_printf (_("Keyserver no-modify"));
2693             }
2694         }
2695       tty_printf ("\n");
2696
2697       if (selfsig)
2698         {
2699           const byte *pref_ks;
2700           size_t pref_ks_len;
2701
2702           pref_ks = parse_sig_subpkt (selfsig->hashed,
2703                                       SIGSUBPKT_PREF_KS, &pref_ks_len);
2704           if (pref_ks && pref_ks_len)
2705             {
2706               tty_printf ("     ");
2707               tty_printf (_("Preferred keyserver: "));
2708               tty_print_utf8_string (pref_ks, pref_ks_len);
2709               tty_printf ("\n");
2710             }
2711
2712           if (selfsig->flags.notation)
2713             {
2714               tty_printf ("     ");
2715               tty_printf (_("Notations: "));
2716               tty_print_notations (5 + strlen (_("Notations: ")), selfsig);
2717             }
2718         }
2719     }
2720   else
2721     {
2722       tty_printf ("    ");
2723       for (i = 0; prefs[i].type; i++)
2724         {
2725           tty_printf (" %c%d", prefs[i].type == PREFTYPE_SYM ? 'S' :
2726                       prefs[i].type == PREFTYPE_HASH ? 'H' :
2727                       prefs[i].type == PREFTYPE_ZIP ? 'Z' : '?',
2728                       prefs[i].value);
2729         }
2730       if (uid->flags.mdc)
2731         tty_printf (" [mdc]");
2732       if (!uid->flags.ks_modify)
2733         tty_printf (" [no-ks-modify]");
2734       tty_printf ("\n");
2735     }
2736 }
2737
2738
2739 /* This is the version of show_key_with_all_names used when
2740    opt.with_colons is used.  It prints all available data in a easy to
2741    parse format and does not translate utf8 */
2742 static void
2743 show_key_with_all_names_colon (ctrl_t ctrl, estream_t fp, kbnode_t keyblock)
2744 {
2745   KBNODE node;
2746   int i, j, ulti_hack = 0;
2747   byte pk_version = 0;
2748   PKT_public_key *primary = NULL;
2749   int have_seckey;
2750
2751   if (!fp)
2752     fp = es_stdout;
2753
2754   /* the keys */
2755   for (node = keyblock; node; node = node->next)
2756     {
2757       if (node->pkt->pkttype == PKT_PUBLIC_KEY
2758           || (node->pkt->pkttype == PKT_PUBLIC_SUBKEY))
2759         {
2760           PKT_public_key *pk = node->pkt->pkt.public_key;
2761           u32 keyid[2];
2762
2763           if (node->pkt->pkttype == PKT_PUBLIC_KEY)
2764             {
2765               pk_version = pk->version;
2766               primary = pk;
2767             }
2768
2769           keyid_from_pk (pk, keyid);
2770           have_seckey = !agent_probe_secret_key (ctrl, pk);
2771
2772           if (node->pkt->pkttype == PKT_PUBLIC_KEY)
2773             es_fputs (have_seckey? "sec:" : "pub:", fp);
2774           else
2775             es_fputs (have_seckey? "ssb:" : "sub:", fp);
2776
2777           if (!pk->flags.valid)
2778             es_putc ('i', fp);
2779           else if (pk->flags.revoked)
2780             es_putc ('r', fp);
2781           else if (pk->has_expired)
2782             es_putc ('e', fp);
2783           else if (!(opt.fast_list_mode || opt.no_expensive_trust_checks))
2784             {
2785               int trust = get_validity_info (pk, NULL);
2786               if (trust == 'u')
2787                 ulti_hack = 1;
2788               es_putc (trust, fp);
2789             }
2790
2791           es_fprintf (fp, ":%u:%d:%08lX%08lX:%lu:%lu::",
2792                       nbits_from_pk (pk),
2793                       pk->pubkey_algo,
2794                       (ulong) keyid[0], (ulong) keyid[1],
2795                       (ulong) pk->timestamp, (ulong) pk->expiredate);
2796           if (node->pkt->pkttype == PKT_PUBLIC_KEY
2797               && !(opt.fast_list_mode || opt.no_expensive_trust_checks))
2798             es_putc (get_ownertrust_info (pk), fp);
2799           es_putc (':', fp);
2800           es_putc (':', fp);
2801           es_putc (':', fp);
2802           /* Print capabilities.  */
2803           if ((pk->pubkey_usage & PUBKEY_USAGE_ENC))
2804             es_putc ('e', fp);
2805           if ((pk->pubkey_usage & PUBKEY_USAGE_SIG))
2806             es_putc ('s', fp);
2807           if ((pk->pubkey_usage & PUBKEY_USAGE_CERT))
2808             es_putc ('c', fp);
2809           if ((pk->pubkey_usage & PUBKEY_USAGE_AUTH))
2810             es_putc ('a', fp);
2811           es_putc ('\n', fp);
2812
2813           print_fingerprint (fp, pk, 0);
2814           print_revokers (fp, pk);
2815         }
2816     }
2817
2818   /* the user ids */
2819   i = 0;
2820   for (node = keyblock; node; node = node->next)
2821     {
2822       if (node->pkt->pkttype == PKT_USER_ID)
2823         {
2824           PKT_user_id *uid = node->pkt->pkt.user_id;
2825
2826           ++i;
2827
2828           if (uid->attrib_data)
2829             es_fputs ("uat:", fp);
2830           else
2831             es_fputs ("uid:", fp);
2832
2833           if (uid->is_revoked)
2834             es_fputs ("r::::::::", fp);
2835           else if (uid->is_expired)
2836             es_fputs ("e::::::::", fp);
2837           else if (opt.fast_list_mode || opt.no_expensive_trust_checks)
2838             es_fputs ("::::::::", fp);
2839           else
2840             {
2841               int uid_validity;
2842
2843               if (primary && !ulti_hack)
2844                 uid_validity = get_validity_info (primary, uid);
2845               else
2846                 uid_validity = 'u';
2847               es_fprintf (fp, "%c::::::::", uid_validity);
2848             }
2849
2850           if (uid->attrib_data)
2851             es_fprintf (fp, "%u %lu", uid->numattribs, uid->attrib_len);
2852           else
2853             es_write_sanitized (fp, uid->name, uid->len, ":", NULL);
2854
2855           es_putc (':', fp);
2856           /* signature class */
2857           es_putc (':', fp);
2858           /* capabilities */
2859           es_putc (':', fp);
2860           /* preferences */
2861           if (pk_version > 3 || uid->selfsigversion > 3)
2862             {
2863               const prefitem_t *prefs = uid->prefs;
2864
2865               for (j = 0; prefs && prefs[j].type; j++)
2866                 {
2867                   if (j)
2868                     es_putc (' ', fp);
2869                   es_fprintf (fp,
2870                               "%c%d", prefs[j].type == PREFTYPE_SYM ? 'S' :
2871                               prefs[j].type == PREFTYPE_HASH ? 'H' :
2872                               prefs[j].type == PREFTYPE_ZIP ? 'Z' : '?',
2873                               prefs[j].value);
2874                 }
2875               if (uid->flags.mdc)
2876                 es_fputs (",mdc", fp);
2877               if (!uid->flags.ks_modify)
2878                 es_fputs (",no-ks-modify", fp);
2879             }
2880           es_putc (':', fp);
2881           /* flags */
2882           es_fprintf (fp, "%d,", i);
2883           if (uid->is_primary)
2884             es_putc ('p', fp);
2885           if (uid->is_revoked)
2886             es_putc ('r', fp);
2887           if (uid->is_expired)
2888             es_putc ('e', fp);
2889           if ((node->flag & NODFLG_SELUID))
2890             es_putc ('s', fp);
2891           if ((node->flag & NODFLG_MARK_A))
2892             es_putc ('m', fp);
2893           es_putc (':', fp);
2894           es_putc ('\n', fp);
2895         }
2896     }
2897 }
2898
2899
2900 static void
2901 show_names (estream_t fp,
2902             KBNODE keyblock, PKT_public_key * pk, unsigned int flag,
2903             int with_prefs)
2904 {
2905   KBNODE node;
2906   int i = 0;
2907
2908   for (node = keyblock; node; node = node->next)
2909     {
2910       if (node->pkt->pkttype == PKT_USER_ID && !is_deleted_kbnode (node))
2911         {
2912           PKT_user_id *uid = node->pkt->pkt.user_id;
2913           ++i;
2914           if (!flag || (flag && (node->flag & flag)))
2915             {
2916               if (!(flag & NODFLG_MARK_A) && pk)
2917                 tty_fprintf (fp, "%s ", uid_trust_string_fixed (pk, uid));
2918
2919               if (flag & NODFLG_MARK_A)
2920                 tty_fprintf (fp, "     ");
2921               else if (node->flag & NODFLG_SELUID)
2922                 tty_fprintf (fp, "(%d)* ", i);
2923               else if (uid->is_primary)
2924                 tty_fprintf (fp, "(%d). ", i);
2925               else
2926                 tty_fprintf (fp, "(%d)  ", i);
2927               tty_print_utf8_string2 (fp, uid->name, uid->len, 0);
2928               tty_fprintf (fp, "\n");
2929               if (with_prefs && pk)
2930                 {
2931                   if (pk->version > 3 || uid->selfsigversion > 3)
2932                     {
2933                       PKT_signature *selfsig = NULL;
2934                       KBNODE signode;
2935
2936                       for (signode = node->next;
2937                            signode && signode->pkt->pkttype == PKT_SIGNATURE;
2938                            signode = signode->next)
2939                         {
2940                           if (signode->pkt->pkt.signature->
2941                               flags.chosen_selfsig)
2942                             {
2943                               selfsig = signode->pkt->pkt.signature;
2944                               break;
2945                             }
2946                         }
2947
2948                       show_prefs (uid, selfsig, with_prefs == 2);
2949                     }
2950                   else
2951                     tty_fprintf (fp, _("There are no preferences on a"
2952                                        " PGP 2.x-style user ID.\n"));
2953                 }
2954             }
2955         }
2956     }
2957 }
2958
2959
2960 /*
2961  * Display the key a the user ids, if only_marked is true, do only so
2962  * for user ids with mark A flag set and do not display the index
2963  * number.  If FP is not NULL print to the given stream and not to the
2964  * tty (ignored in with-colons mode).
2965  */
2966 static void
2967 show_key_with_all_names (ctrl_t ctrl, estream_t fp,
2968                          KBNODE keyblock, int only_marked, int with_revoker,
2969                          int with_fpr, int with_subkeys, int with_prefs,
2970                          int nowarn)
2971 {
2972   gpg_error_t err;
2973   kbnode_t node;
2974   int i;
2975   int do_warn = 0;
2976   int have_seckey = 0;
2977   char *serialno = NULL;
2978   PKT_public_key *primary = NULL;
2979   char pkstrbuf[PUBKEY_STRING_SIZE];
2980
2981   if (opt.with_colons)
2982     {
2983       show_key_with_all_names_colon (ctrl, fp, keyblock);
2984       return;
2985     }
2986
2987   /* the keys */
2988   for (node = keyblock; node; node = node->next)
2989     {
2990       if (node->pkt->pkttype == PKT_PUBLIC_KEY
2991           || (with_subkeys && node->pkt->pkttype == PKT_PUBLIC_SUBKEY
2992               && !is_deleted_kbnode (node)))
2993         {
2994           PKT_public_key *pk = node->pkt->pkt.public_key;
2995           const char *otrust = "err";
2996           const char *trust = "err";
2997
2998           if (node->pkt->pkttype == PKT_PUBLIC_KEY)
2999             {
3000               /* do it here, so that debug messages don't clutter the
3001                * output */
3002               static int did_warn = 0;
3003
3004               trust = get_validity_string (pk, NULL);
3005               otrust = get_ownertrust_string (pk);
3006
3007               /* Show a warning once */
3008               if (!did_warn
3009                   && (get_validity (pk, NULL) & TRUST_FLAG_PENDING_CHECK))
3010                 {
3011                   did_warn = 1;
3012                   do_warn = 1;
3013                 }
3014
3015               primary = pk;
3016             }
3017
3018           if (pk->flags.revoked)
3019             {
3020               char *user = get_user_id_string_native (pk->revoked.keyid);
3021               tty_fprintf (fp,
3022                            _("The following key was revoked on"
3023                             " %s by %s key %s\n"),
3024                           revokestr_from_pk (pk),
3025                           gcry_pk_algo_name (pk->revoked.algo), user);
3026               xfree (user);
3027             }
3028
3029           if (with_revoker)
3030             {
3031               if (!pk->revkey && pk->numrevkeys)
3032                 BUG ();
3033               else
3034                 for (i = 0; i < pk->numrevkeys; i++)
3035                   {
3036                     u32 r_keyid[2];
3037                     char *user;
3038                     const char *algo;
3039
3040                     algo = gcry_pk_algo_name (pk->revkey[i].algid);
3041                     keyid_from_fingerprint (pk->revkey[i].fpr,
3042                                             MAX_FINGERPRINT_LEN, r_keyid);
3043
3044                     user = get_user_id_string_native (r_keyid);
3045                     tty_fprintf (fp,
3046                                  _("This key may be revoked by %s key %s"),
3047                                  algo ? algo : "?", user);
3048
3049                     if (pk->revkey[i].class & 0x40)
3050                       {
3051                         tty_fprintf (fp, " ");
3052                         tty_fprintf (fp, _("(sensitive)"));
3053                       }
3054
3055                     tty_fprintf (fp, "\n");
3056                     xfree (user);
3057                   }
3058             }
3059
3060           keyid_from_pk (pk, NULL);
3061
3062           xfree (serialno);
3063           serialno = NULL;
3064           {
3065             char *hexgrip;
3066
3067             err = hexkeygrip_from_pk (pk, &hexgrip);
3068             if (err)
3069               {
3070                 log_error ("error computing a keygrip: %s\n",
3071                            gpg_strerror (err));
3072                 have_seckey = 0;
3073               }
3074             else
3075               have_seckey = !agent_get_keyinfo (ctrl, hexgrip, &serialno);
3076             xfree (hexgrip);
3077           }
3078
3079           tty_fprintf
3080             (fp, "%s%c %s/%s",
3081              node->pkt->pkttype == PKT_PUBLIC_KEY && have_seckey? "sec" :
3082              node->pkt->pkttype == PKT_PUBLIC_KEY ?               "pub" :
3083              have_seckey ?                                        "ssb" :
3084                                                                   "sub",
3085              (node->flag & NODFLG_SELKEY) ? '*' : ' ',
3086              pubkey_string (pk, pkstrbuf, sizeof pkstrbuf),
3087              keystr (pk->keyid));
3088
3089           if (opt.legacy_list_mode)
3090             tty_fprintf (fp, "  ");
3091           else
3092             tty_fprintf (fp, "\n     ");
3093
3094           tty_fprintf (fp, _("created: %s"), datestr_from_pk (pk));
3095           tty_fprintf (fp, "  ");
3096           if (pk->flags.revoked)
3097             tty_fprintf (fp, _("revoked: %s"), revokestr_from_pk (pk));
3098           else if (pk->has_expired)
3099             tty_fprintf (fp, _("expired: %s"), expirestr_from_pk (pk));
3100           else
3101             tty_fprintf (fp, _("expires: %s"), expirestr_from_pk (pk));
3102           tty_fprintf (fp, "  ");
3103           tty_fprintf (fp, _("usage: %s"), usagestr_from_pk (pk, 1));
3104           tty_fprintf (fp, "\n");
3105
3106           if (serialno)
3107             {
3108               /* The agent told us that a secret key is available and
3109                  that it has been stored on a card.  */
3110               tty_fprintf (fp, "%*s%s", opt.legacy_list_mode? 21:5, "",
3111                            _("card-no: "));
3112               if (strlen (serialno) == 32
3113                   && !strncmp (serialno, "D27600012401", 12))
3114                 {
3115                   /* This is an OpenPGP card.  Print the relevant part.  */
3116                   /* Example: D2760001240101010001000003470000 */
3117                   /*                          xxxxyyyyyyyy     */
3118                   tty_fprintf (fp, "%.*s %.*s\n",
3119                                4, serialno+16, 8, serialno+20);
3120                 }
3121               else
3122                 tty_fprintf (fp, "%s\n", serialno);
3123
3124             }
3125           else if (pk->seckey_info
3126               && pk->seckey_info->is_protected
3127               && pk->seckey_info->s2k.mode == 1002)
3128             {
3129               /* FIXME: Check wether this code path is still used.  */
3130               tty_fprintf (fp, "%*s%s", opt.legacy_list_mode? 21:5, "",
3131                            _("card-no: "));
3132               if (pk->seckey_info->ivlen == 16
3133                   && !memcmp (pk->seckey_info->iv,
3134                               "\xD2\x76\x00\x01\x24\x01", 6))
3135                 {
3136                   /* This is an OpenPGP card. */
3137                   for (i = 8; i < 14; i++)
3138                     {
3139                       if (i == 10)
3140                         tty_fprintf (fp, " ");
3141                       tty_fprintf (fp, "%02X", pk->seckey_info->iv[i]);
3142                     }
3143                 }
3144               else
3145                 {
3146                   /* Unknown card: Print all. */
3147                   for (i = 0; i < pk->seckey_info->ivlen; i++)
3148                     tty_fprintf (fp, "%02X", pk->seckey_info->iv[i]);
3149                 }
3150               tty_fprintf (fp, "\n");
3151             }
3152
3153           if (node->pkt->pkttype == PKT_PUBLIC_KEY
3154               || node->pkt->pkttype == PKT_SECRET_KEY)
3155             {
3156               if (opt.trust_model != TM_ALWAYS)
3157                 {
3158                   tty_fprintf (fp, "%*s",
3159                                opt.legacy_list_mode?
3160                                ((int) keystrlen () + 13):5, "");
3161                   /* Ownertrust is only meaningful for the PGP or
3162                      classic trust models */
3163                   if (opt.trust_model == TM_PGP
3164                       || opt.trust_model == TM_CLASSIC)
3165                     {
3166                       int width = 14 - strlen (otrust);
3167                       if (width <= 0)
3168                         width = 1;
3169                       tty_fprintf (fp, _("trust: %s"), otrust);
3170                       tty_fprintf (fp, "%*s", width, "");
3171                     }
3172
3173                   tty_fprintf (fp, _("validity: %s"), trust);
3174                   tty_fprintf (fp, "\n");
3175                 }
3176               if (node->pkt->pkttype == PKT_PUBLIC_KEY
3177                   && (get_ownertrust (pk) & TRUST_FLAG_DISABLED))
3178                 {
3179                   tty_fprintf (fp, "*** ");
3180                   tty_fprintf (fp, _("This key has been disabled"));
3181                   tty_fprintf (fp, "\n");
3182                 }
3183             }
3184
3185           if ((node->pkt->pkttype == PKT_PUBLIC_KEY
3186                || node->pkt->pkttype == PKT_SECRET_KEY) && with_fpr)
3187             {
3188               print_fingerprint (fp, pk, 2);
3189               tty_fprintf (fp, "\n");
3190             }
3191         }
3192     }
3193
3194   show_names (fp,
3195               keyblock, primary, only_marked ? NODFLG_MARK_A : 0, with_prefs);
3196
3197   if (do_warn && !nowarn)
3198     tty_fprintf (fp, _("Please note that the shown key validity"
3199                        " is not necessarily correct\n"
3200                        "unless you restart the program.\n"));
3201
3202   xfree (serialno);
3203 }
3204
3205
3206 /* Display basic key information.  This function is suitable to show
3207    information on the key without any dependencies on the trustdb or
3208    any other internal GnuPG stuff.  KEYBLOCK may either be a public or
3209    a secret key.  This function may be called with KEYBLOCK containing
3210    secret keys and thus the printing of "pub" vs. "sec" does only
3211    depend on the packet type and not by checking with gpg-agent.  */
3212 void
3213 show_basic_key_info (KBNODE keyblock)
3214 {
3215   KBNODE node;
3216   int i;
3217   char pkstrbuf[PUBKEY_STRING_SIZE];
3218
3219   /* The primary key */
3220   for (node = keyblock; node; node = node->next)
3221     {
3222       if (node->pkt->pkttype == PKT_PUBLIC_KEY
3223           || node->pkt->pkttype == PKT_SECRET_KEY)
3224         {
3225           PKT_public_key *pk = node->pkt->pkt.public_key;
3226
3227           /* Note, we use the same format string as in other show
3228              functions to make the translation job easier. */
3229           tty_printf ("%s  %s/%s  ",
3230                       node->pkt->pkttype == PKT_PUBLIC_KEY ? "pub" :
3231                       node->pkt->pkttype == PKT_PUBLIC_SUBKEY ? "sub" :
3232                       node->pkt->pkttype == PKT_SECRET_KEY ? "sec" :"ssb",
3233                       pubkey_string (pk, pkstrbuf, sizeof pkstrbuf),
3234                       keystr_from_pk (pk));
3235           tty_printf (_("created: %s"), datestr_from_pk (pk));
3236           tty_printf ("  ");
3237           tty_printf (_("expires: %s"), expirestr_from_pk (pk));
3238           tty_printf ("\n");
3239           print_fingerprint (NULL, pk, 3);
3240           tty_printf ("\n");
3241         }
3242     }
3243
3244   /* The user IDs. */
3245   for (i = 0, node = keyblock; node; node = node->next)
3246     {
3247       if (node->pkt->pkttype == PKT_USER_ID)
3248         {
3249           PKT_user_id *uid = node->pkt->pkt.user_id;
3250           ++i;
3251
3252           tty_printf ("     ");
3253           if (uid->is_revoked)
3254             tty_printf ("[%s] ", _("revoked"));
3255           else if (uid->is_expired)
3256             tty_printf ("[%s] ", _("expired"));
3257           tty_print_utf8_string (uid->name, uid->len);
3258           tty_printf ("\n");
3259         }
3260     }
3261 }
3262
3263
3264 static void
3265 show_key_and_fingerprint (kbnode_t keyblock, int with_subkeys)
3266 {
3267   kbnode_t node;
3268   PKT_public_key *pk = NULL;
3269   char pkstrbuf[PUBKEY_STRING_SIZE];
3270
3271   for (node = keyblock; node; node = node->next)
3272     {
3273       if (node->pkt->pkttype == PKT_PUBLIC_KEY)
3274         {
3275           pk = node->pkt->pkt.public_key;
3276           tty_printf ("pub   %s/%s %s ",
3277                       pubkey_string (pk, pkstrbuf, sizeof pkstrbuf),
3278                       keystr_from_pk(pk),
3279                       datestr_from_pk (pk));
3280         }
3281       else if (node->pkt->pkttype == PKT_USER_ID)
3282         {
3283           PKT_user_id *uid = node->pkt->pkt.user_id;
3284           tty_print_utf8_string (uid->name, uid->len);
3285           break;
3286         }
3287     }
3288   tty_printf ("\n");
3289   if (pk)
3290     print_fingerprint (NULL, pk, 2);
3291   if (with_subkeys)
3292     {
3293       for (node = keyblock; node; node = node->next)
3294         {
3295           if (node->pkt->pkttype == PKT_PUBLIC_SUBKEY)
3296             {
3297               pk = node->pkt->pkt.public_key;
3298               tty_printf ("sub   %s/%s %s [%s]\n",
3299                           pubkey_string (pk, pkstrbuf, sizeof pkstrbuf),
3300                           keystr_from_pk(pk),
3301                           datestr_from_pk (pk),
3302                           usagestr_from_pk (pk, 0));
3303
3304               print_fingerprint (NULL, pk, 4);
3305             }
3306         }
3307     }
3308 }
3309
3310
3311 /* Show a listing of the primary and its subkeys along with their
3312    keygrips.  */
3313 static void
3314 show_key_and_grip (kbnode_t keyblock)
3315 {
3316   kbnode_t node;
3317   PKT_public_key *pk = NULL;
3318   char pkstrbuf[PUBKEY_STRING_SIZE];
3319   char *hexgrip;
3320
3321   for (node = keyblock; node; node = node->next)
3322     {
3323       if (node->pkt->pkttype == PKT_PUBLIC_KEY
3324           || node->pkt->pkttype == PKT_PUBLIC_SUBKEY)
3325         {
3326           pk = node->pkt->pkt.public_key;
3327           tty_printf ("%s   %s/%s %s [%s]\n",
3328                       node->pkt->pkttype == PKT_PUBLIC_KEY? "pub":"sub",
3329                       pubkey_string (pk, pkstrbuf, sizeof pkstrbuf),
3330                       keystr_from_pk(pk),
3331                       datestr_from_pk (pk),
3332                       usagestr_from_pk (pk, 0));
3333
3334           if (!hexkeygrip_from_pk (pk, &hexgrip))
3335             {
3336               tty_printf ("      Keygrip: %s\n", hexgrip);
3337               xfree (hexgrip);
3338             }
3339         }
3340     }
3341 }
3342
3343
3344 /* Show a warning if no uids on the key have the primary uid flag
3345    set. */
3346 static void
3347 no_primary_warning (KBNODE keyblock)
3348 {
3349   KBNODE node;
3350   int have_primary = 0, uid_count = 0;
3351
3352   /* TODO: if we ever start behaving differently with a primary or
3353      non-primary attribute ID, we will need to check for attributes
3354      here as well. */
3355
3356   for (node = keyblock; node; node = node->next)
3357     {
3358       if (node->pkt->pkttype == PKT_USER_ID
3359           && node->pkt->pkt.user_id->attrib_data == NULL)
3360         {
3361           uid_count++;
3362
3363           if (node->pkt->pkt.user_id->is_primary == 2)
3364             {
3365               have_primary = 1;
3366               break;
3367             }
3368         }
3369     }
3370
3371   if (uid_count > 1 && !have_primary)
3372     log_info (_
3373               ("WARNING: no user ID has been marked as primary.  This command"
3374                " may\n              cause a different user ID to become"
3375                " the assumed primary.\n"));
3376 }
3377
3378
3379 /* Print a warning if the latest encryption subkey expires soon.  This
3380    function is called after the expire data of the primary key has
3381    been changed.  */
3382 static void
3383 subkey_expire_warning (kbnode_t keyblock)
3384 {
3385   u32 curtime = make_timestamp ();
3386   kbnode_t node;
3387   PKT_public_key *pk;
3388   /* u32 mainexpire = 0; */
3389   u32 subexpire = 0;
3390   u32 latest_date = 0;
3391
3392   for (node = keyblock; node; node = node->next)
3393     {
3394       /* if (node->pkt->pkttype == PKT_PUBLIC_KEY) */
3395       /*   { */
3396       /*     pk = node->pkt->pkt.public_key; */
3397       /*     mainexpire = pk->expiredate; */
3398       /*   } */
3399
3400       if (node->pkt->pkttype != PKT_PUBLIC_SUBKEY)
3401         continue;
3402       pk = node->pkt->pkt.public_key;
3403
3404       if (!pk->flags.valid)
3405         continue;
3406       if (pk->flags.revoked)
3407         continue;
3408       if (pk->timestamp > curtime)
3409         continue; /* Ignore future keys.  */
3410       if (!(pk->pubkey_usage & PUBKEY_USAGE_ENC))
3411         continue; /* Not an encryption key.  */
3412
3413       if (pk->timestamp > latest_date || (!pk->timestamp && !latest_date))
3414         {
3415           latest_date = pk->timestamp;
3416           subexpire = pk->expiredate;
3417         }
3418     }
3419
3420   if (!subexpire)
3421     return;  /* No valid subkey with an expiration time.  */
3422
3423   if (curtime + (10*86400) > subexpire)
3424     {
3425       log_info (_("WARNING: Your encryption subkey expires soon.\n"));
3426       log_info (_("You may want to change its expiration date too.\n"));
3427     }
3428 }
3429
3430
3431 /*
3432  * Ask for a new user id, add the self-signature, and update the
3433  * keyblock.  If UIDSTRING is not NULL the user ID is generated
3434  * unattended using that string.  UIDSTRING is expected to be utf-8
3435  * encoded and white space trimmed.  Returns true if there is a new
3436  * user id.
3437  */
3438 static int
3439 menu_adduid (kbnode_t pub_keyblock, int photo, const char *photo_name,
3440              const char *uidstring)
3441 {
3442   PKT_user_id *uid;
3443   PKT_public_key *pk = NULL;
3444   PKT_signature *sig = NULL;
3445   PACKET *pkt;
3446   KBNODE node;
3447   KBNODE pub_where = NULL;
3448   gpg_error_t err;
3449
3450   if (photo && uidstring)
3451     return 0;  /* Not allowed.  */
3452
3453   for (node = pub_keyblock; node; pub_where = node, node = node->next)
3454     {
3455       if (node->pkt->pkttype == PKT_PUBLIC_KEY)
3456         pk = node->pkt->pkt.public_key;
3457       else if (node->pkt->pkttype == PKT_PUBLIC_SUBKEY)
3458         break;
3459     }
3460   if (!node) /* No subkey.  */
3461     pub_where = NULL;
3462   assert (pk);
3463
3464   if (photo)
3465     {
3466       int hasattrib = 0;
3467
3468       for (node = pub_keyblock; node; node = node->next)
3469         if (node->pkt->pkttype == PKT_USER_ID &&
3470             node->pkt->pkt.user_id->attrib_data != NULL)
3471           {
3472             hasattrib = 1;
3473             break;
3474           }
3475
3476       /* It is legal but bad for compatibility to add a photo ID to a
3477          v3 key as it means that PGP2 will not be able to use that key
3478          anymore.  Also, PGP may not expect a photo on a v3 key.
3479          Don't bother to ask this if the key already has a photo - any
3480          damage has already been done at that point. -dms */
3481       if (pk->version == 3 && !hasattrib)
3482         {
3483           if (opt.expert)
3484             {
3485               tty_printf (_("WARNING: This is a PGP2-style key.  "
3486                             "Adding a photo ID may cause some versions\n"
3487                             "         of PGP to reject this key.\n"));
3488
3489               if (!cpr_get_answer_is_yes ("keyedit.v3_photo.okay",
3490                                           _("Are you sure you still want "
3491                                             "to add it? (y/N) ")))
3492                 return 0;
3493             }
3494           else
3495             {
3496               tty_printf (_("You may not add a photo ID to "
3497                             "a PGP2-style key.\n"));
3498               return 0;
3499             }
3500         }
3501
3502       uid = generate_photo_id (pk, photo_name);
3503     }
3504   else
3505     uid = generate_user_id (pub_keyblock, uidstring);
3506   if (!uid)
3507     {
3508       if (uidstring)
3509         log_error ("%s", _("Such a user ID already exists on this key!\n"));
3510       return 0;
3511     }
3512
3513   err = make_keysig_packet (&sig, pk, uid, NULL, pk, 0x13, 0, 0, 0,
3514                             keygen_add_std_prefs, pk, NULL);
3515   if (err)
3516     {
3517       write_status_error ("keysig", err);
3518       log_error ("signing failed: %s\n", gpg_strerror (err));
3519       free_user_id (uid);
3520       return 0;
3521     }
3522
3523   /* Insert/append to public keyblock */
3524   pkt = xmalloc_clear (sizeof *pkt);
3525   pkt->pkttype = PKT_USER_ID;
3526   pkt->pkt.user_id = uid;
3527   node = new_kbnode (pkt);
3528   if (pub_where)
3529     insert_kbnode (pub_where, node, 0);
3530   else
3531     add_kbnode (pub_keyblock, node);
3532   pkt = xmalloc_clear (sizeof *pkt);
3533   pkt->pkttype = PKT_SIGNATURE;
3534   pkt->pkt.signature = copy_signature (NULL, sig);
3535   if (pub_where)
3536     insert_kbnode (node, new_kbnode (pkt), 0);
3537   else
3538     add_kbnode (pub_keyblock, new_kbnode (pkt));
3539   return 1;
3540 }
3541
3542
3543 /*
3544  * Remove all selected userids from the keyring
3545  */
3546 static void
3547 menu_deluid (KBNODE pub_keyblock)
3548 {
3549   KBNODE node;
3550   int selected = 0;
3551
3552   for (node = pub_keyblock; node; node = node->next)
3553     {
3554       if (node->pkt->pkttype == PKT_USER_ID)
3555         {
3556           selected = node->flag & NODFLG_SELUID;
3557           if (selected)
3558             {
3559               /* Only cause a trust update if we delete a
3560                  non-revoked user id */
3561               if (!node->pkt->pkt.user_id->is_revoked)
3562                 update_trust = 1;
3563               delete_kbnode (node);
3564             }
3565         }
3566       else if (selected && node->pkt->pkttype == PKT_SIGNATURE)
3567         delete_kbnode (node);
3568       else if (node->pkt->pkttype == PKT_PUBLIC_SUBKEY)
3569         selected = 0;
3570     }
3571   commit_kbnode (&pub_keyblock);
3572 }
3573
3574
3575 static int
3576 menu_delsig (KBNODE pub_keyblock)
3577 {
3578   KBNODE node;
3579   PKT_user_id *uid = NULL;
3580   int changed = 0;
3581
3582   for (node = pub_keyblock; node; node = node->next)
3583     {
3584       if (node->pkt->pkttype == PKT_USER_ID)
3585         {
3586           uid = (node->flag & NODFLG_SELUID) ? node->pkt->pkt.user_id : NULL;
3587         }
3588       else if (uid && node->pkt->pkttype == PKT_SIGNATURE)
3589         {
3590           int okay, valid, selfsig, inv_sig, no_key, other_err;
3591
3592           tty_printf ("uid  ");
3593           tty_print_utf8_string (uid->name, uid->len);
3594           tty_printf ("\n");
3595
3596           okay = inv_sig = no_key = other_err = 0;
3597           if (opt.with_colons)
3598             valid = print_and_check_one_sig_colon (pub_keyblock, node,
3599                                                    &inv_sig, &no_key,
3600                                                    &other_err, &selfsig, 1);
3601           else
3602             valid = print_and_check_one_sig (pub_keyblock, node,
3603                                              &inv_sig, &no_key, &other_err,
3604                                              &selfsig, 1);
3605
3606           if (valid)
3607             {
3608               okay = cpr_get_answer_yes_no_quit
3609                 ("keyedit.delsig.valid",
3610                  _("Delete this good signature? (y/N/q)"));
3611
3612               /* Only update trust if we delete a good signature.
3613                  The other two cases do not affect trust. */
3614               if (okay)
3615                 update_trust = 1;
3616             }
3617           else if (inv_sig || other_err)
3618             okay = cpr_get_answer_yes_no_quit
3619               ("keyedit.delsig.invalid",
3620                _("Delete this invalid signature? (y/N/q)"));
3621           else if (no_key)
3622             okay = cpr_get_answer_yes_no_quit
3623               ("keyedit.delsig.unknown",
3624                _("Delete this unknown signature? (y/N/q)"));
3625
3626           if (okay == -1)
3627             break;
3628           if (okay && selfsig
3629               && !cpr_get_answer_is_yes
3630               ("keyedit.delsig.selfsig",
3631                _("Really delete this self-signature? (y/N)")))
3632             okay = 0;
3633           if (okay)
3634             {
3635               delete_kbnode (node);
3636               changed++;
3637             }
3638
3639         }
3640       else if (node->pkt->pkttype == PKT_PUBLIC_SUBKEY)
3641         uid = NULL;
3642     }
3643
3644   if (changed)
3645     {
3646       commit_kbnode (&pub_keyblock);
3647       tty_printf (changed == 1 ? _("Deleted %d signature.\n")
3648                   : _("Deleted %d signatures.\n"), changed);
3649     }
3650   else
3651     tty_printf (_("Nothing deleted.\n"));
3652
3653   return changed;
3654 }
3655
3656
3657 static int
3658 menu_clean (KBNODE keyblock, int self_only)
3659 {
3660   KBNODE uidnode;
3661   int modified = 0, select_all = !count_selected_uids (keyblock);
3662
3663   for (uidnode = keyblock->next;
3664        uidnode && uidnode->pkt->pkttype != PKT_PUBLIC_SUBKEY;
3665        uidnode = uidnode->next)
3666     {
3667       if (uidnode->pkt->pkttype == PKT_USER_ID
3668           && (uidnode->flag & NODFLG_SELUID || select_all))
3669         {
3670           int uids = 0, sigs = 0;
3671           char *user = utf8_to_native (uidnode->pkt->pkt.user_id->name,
3672                                        uidnode->pkt->pkt.user_id->len,
3673                                        0);
3674
3675           clean_one_uid (keyblock, uidnode, opt.verbose, self_only, &uids,
3676                          &sigs);
3677           if (uids)
3678             {
3679               const char *reason;
3680
3681               if (uidnode->pkt->pkt.user_id->is_revoked)
3682                 reason = _("revoked");
3683               else if (uidnode->pkt->pkt.user_id->is_expired)
3684                 reason = _("expired");
3685               else
3686                 reason = _("invalid");
3687
3688               tty_printf (_("User ID \"%s\" compacted: %s\n"), user, reason);
3689
3690               modified = 1;
3691             }
3692           else if (sigs)
3693             {
3694               tty_printf (sigs == 1 ?
3695                           _("User ID \"%s\": %d signature removed\n") :
3696                           _("User ID \"%s\": %d signatures removed\n"),
3697                           user, sigs);
3698
3699               modified = 1;
3700             }
3701           else
3702             {
3703               tty_printf (self_only == 1 ?
3704                           _("User ID \"%s\": already minimized\n") :
3705                           _("User ID \"%s\": already clean\n"), user);
3706             }
3707
3708           xfree (user);
3709         }
3710     }
3711
3712   return modified;
3713 }
3714
3715
3716 /*
3717  * Remove some of the secondary keys
3718  */
3719 static void
3720 menu_delkey (KBNODE pub_keyblock)
3721 {
3722   KBNODE node;
3723   int selected = 0;
3724
3725   for (node = pub_keyblock; node; node = node->next)
3726     {
3727       if (node->pkt->pkttype == PKT_PUBLIC_SUBKEY)
3728         {
3729           selected = node->flag & NODFLG_SELKEY;
3730           if (selected)
3731             delete_kbnode (node);
3732         }
3733       else if (selected && node->pkt->pkttype == PKT_SIGNATURE)
3734         delete_kbnode (node);
3735       else
3736         selected = 0;
3737     }
3738   commit_kbnode (&pub_keyblock);
3739
3740   /* No need to set update_trust here since signing keys are no
3741      longer used to certify other keys, so there is no change in
3742      trust when revoking/removing them.   */
3743 }
3744
3745
3746 /*
3747  * Ask for a new revoker, create the self-signature and put it into
3748  * the keyblock.  Returns true if there is a new revoker.
3749  */
3750 static int
3751 menu_addrevoker (ctrl_t ctrl, kbnode_t pub_keyblock, int sensitive)
3752 {
3753   PKT_public_key *pk = NULL;
3754   PKT_public_key *revoker_pk = NULL;
3755   PKT_signature *sig = NULL;
3756   PACKET *pkt;
3757   struct revocation_key revkey;
3758   size_t fprlen;
3759   int rc;
3760
3761   assert (pub_keyblock->pkt->pkttype == PKT_PUBLIC_KEY);
3762
3763   pk = pub_keyblock->pkt->pkt.public_key;
3764
3765   if (pk->numrevkeys == 0 && pk->version == 3)
3766     {
3767       /* It is legal but bad for compatibility to add a revoker to a
3768          v3 key as it means that PGP2 will not be able to use that key
3769          anymore.  Also, PGP may not expect a revoker on a v3 key.
3770          Don't bother to ask this if the key already has a revoker -
3771          any damage has already been done at that point. -dms */
3772       if (opt.expert)
3773         {
3774           tty_printf (_("WARNING: This is a PGP 2.x-style key.  "
3775                         "Adding a designated revoker may cause\n"
3776                         "         some versions of PGP to reject this key.\n"));
3777
3778           if (!cpr_get_answer_is_yes ("keyedit.v3_revoker.okay",
3779                                       _("Are you sure you still want "
3780                                         "to add it? (y/N) ")))
3781             return 0;
3782         }
3783       else
3784         {
3785           tty_printf (_("You may not add a designated revoker to "
3786                         "a PGP 2.x-style key.\n"));
3787           return 0;
3788         }
3789     }
3790
3791   for (;;)
3792     {
3793       char *answer;
3794
3795       free_public_key (revoker_pk);
3796       revoker_pk = xmalloc_clear (sizeof (*revoker_pk));
3797
3798       tty_printf ("\n");
3799
3800       answer = cpr_get_utf8
3801         ("keyedit.add_revoker",
3802          _("Enter the user ID of the designated revoker: "));
3803       if (answer[0] == '\0' || answer[0] == CONTROL_D)
3804         {
3805           xfree (answer);
3806           goto fail;
3807         }
3808
3809       /* Note that I'm requesting CERT here, which usually implies
3810          primary keys only, but some casual testing shows that PGP and
3811          GnuPG both can handle a designated revocation from a subkey. */
3812       revoker_pk->req_usage = PUBKEY_USAGE_CERT;
3813       rc = get_pubkey_byname (ctrl, NULL, revoker_pk, answer, NULL, NULL, 1, 1);
3814       if (rc)
3815         {
3816           log_error (_("key \"%s\" not found: %s\n"), answer,
3817                      gpg_strerror (rc));
3818           xfree (answer);
3819           continue;
3820         }
3821
3822       xfree (answer);
3823
3824       fingerprint_from_pk (revoker_pk, revkey.fpr, &fprlen);
3825       if (fprlen != 20)
3826         {
3827           log_error (_("cannot appoint a PGP 2.x style key as a "
3828                        "designated revoker\n"));
3829           continue;
3830         }
3831
3832       revkey.class = 0x80;
3833       if (sensitive)
3834         revkey.class |= 0x40;
3835       revkey.algid = revoker_pk->pubkey_algo;
3836
3837       if (cmp_public_keys (revoker_pk, pk) == 0)
3838         {
3839           /* This actually causes no harm (after all, a key that
3840              designates itself as a revoker is the same as a
3841              regular key), but it's easy enough to check. */
3842           log_error (_("you cannot appoint a key as its own "
3843                        "designated revoker\n"));
3844
3845           continue;
3846         }
3847
3848       keyid_from_pk (pk, NULL);
3849
3850       /* Does this revkey already exist? */
3851       if (!pk->revkey && pk->numrevkeys)
3852         BUG ();
3853       else
3854         {
3855           int i;
3856
3857           for (i = 0; i < pk->numrevkeys; i++)
3858             {
3859               if (memcmp (&pk->revkey[i], &revkey,
3860                           sizeof (struct revocation_key)) == 0)
3861                 {
3862                   char buf[50];
3863
3864                   log_error (_("this key has already been designated "
3865                                "as a revoker\n"));
3866
3867                   sprintf (buf, "%08lX%08lX",
3868                            (ulong) pk->keyid[0], (ulong) pk->keyid[1]);
3869                   write_status_text (STATUS_ALREADY_SIGNED, buf);
3870
3871                   break;
3872                 }
3873             }
3874
3875           if (i < pk->numrevkeys)
3876             continue;
3877         }
3878
3879       print_pubkey_info (NULL, revoker_pk);
3880       print_fingerprint (NULL, revoker_pk, 2);
3881       tty_printf ("\n");
3882
3883       tty_printf (_("WARNING: appointing a key as a designated revoker "
3884                     "cannot be undone!\n"));
3885
3886       tty_printf ("\n");
3887
3888       if (!cpr_get_answer_is_yes ("keyedit.add_revoker.okay",
3889                                   _("Are you sure you want to appoint this "
3890                                     "key as a designated revoker? (y/N) ")))
3891         continue;
3892
3893       free_public_key (revoker_pk);
3894       revoker_pk = NULL;
3895       break;
3896     }
3897
3898   rc = make_keysig_packet (&sig, pk, NULL, NULL, pk, 0x1F, 0, 0, 0,
3899                            keygen_add_revkey, &revkey, NULL);
3900   if (rc)
3901     {
3902       write_status_error ("keysig", rc);
3903       log_error ("signing failed: %s\n", gpg_strerror (rc));
3904       goto fail;
3905     }
3906
3907   /* Insert into public keyblock.  */
3908   pkt = xmalloc_clear (sizeof *pkt);
3909   pkt->pkttype = PKT_SIGNATURE;
3910   pkt->pkt.signature = sig;
3911   insert_kbnode (pub_keyblock, new_kbnode (pkt), PKT_SIGNATURE);
3912
3913   return 1;
3914
3915 fail:
3916   if (sig)
3917     free_seckey_enc (sig);
3918   free_public_key (revoker_pk);