g10: Improve error message.
[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               tty_printf (_("You must select at least one user ID (use the 'uid' command).\n"));
1773             else if (real_uids_left (keyblock) < 1)
1774               tty_printf (_("You can't delete the last user ID!\n"));
1775             else if (cpr_get_answer_is_yes
1776                      ("keyedit.remove.uid.okay",
1777                       n1 > 1 ? _("Really remove all selected user IDs? (y/N) ")
1778                       :        _("Really remove this user ID? (y/N) ")))
1779               {
1780                 menu_deluid (keyblock);
1781                 redisplay = 1;
1782                 modified = 1;
1783               }
1784           }
1785           break;
1786
1787         case cmdDELSIG:
1788           {
1789             int n1;
1790
1791             if (!(n1 = count_selected_uids (keyblock)))
1792               tty_printf (_("You must select at least one user ID (use the 'uid' command).\n"));
1793             else if (menu_delsig (keyblock))
1794               {
1795                 /* No redisplay here, because it may scroll away some
1796                  * of the status output of this command.  */
1797                 modified = 1;
1798               }
1799           }
1800           break;
1801
1802         case cmdADDKEY:
1803           if (!generate_subkeypair (ctrl, keyblock))
1804             {
1805               redisplay = 1;
1806               modified = 1;
1807               merge_keys_and_selfsig (keyblock);
1808             }
1809           break;
1810
1811 #ifdef ENABLE_CARD_SUPPORT
1812         case cmdADDCARDKEY:
1813           if (!card_generate_subkey (keyblock))
1814             {
1815               redisplay = 1;
1816               modified = 1;
1817               merge_keys_and_selfsig (keyblock);
1818             }
1819           break;
1820
1821         case cmdKEYTOCARD:
1822           {
1823             KBNODE node = NULL;
1824             switch (count_selected_keys (keyblock))
1825               {
1826               case 0:
1827                 if (cpr_get_answer_is_yes
1828                     ("keyedit.keytocard.use_primary",
1829                      /* TRANSLATORS: Please take care: This is about
1830                         moving the key and not about removing it.  */
1831                      _("Really move the primary key? (y/N) ")))
1832                   node = keyblock;
1833                 break;
1834               case 1:
1835                 for (node = keyblock; node; node = node->next)
1836                   {
1837                     if (node->pkt->pkttype == PKT_PUBLIC_SUBKEY
1838                         && node->flag & NODFLG_SELKEY)
1839                       break;
1840                   }
1841                 break;
1842               default:
1843                 tty_printf (_("You must select exactly one key.\n"));
1844                 break;
1845               }
1846             if (node)
1847               {
1848                 PKT_public_key *xxpk = node->pkt->pkt.public_key;
1849                 if (card_store_subkey (node, xxpk ? xxpk->pubkey_usage : 0))
1850                   {
1851                     redisplay = 1;
1852                     sec_shadowing = 1;
1853                   }
1854               }
1855           }
1856           break;
1857
1858         case cmdBKUPTOCARD:
1859         case cmdCHECKBKUPKEY:
1860           log_debug ("FIXME: This needs to be changed\n");
1861           {
1862             /* Ask for a filename, check whether this is really a
1863                backup key as generated by the card generation, parse
1864                that key and store it on card. */
1865             KBNODE node;
1866             const char *fname;
1867             PACKET *pkt;
1868             IOBUF a;
1869
1870             fname = arg_string;
1871             if (!*fname)
1872               {
1873                 tty_printf (_("Command expects a filename argument\n"));
1874                 break;
1875               }
1876
1877             /* Open that file.  */
1878             a = iobuf_open (fname);
1879             if (a && is_secured_file (iobuf_get_fd (a)))
1880               {
1881                 iobuf_close (a);
1882                 a = NULL;
1883                 gpg_err_set_errno (EPERM);
1884               }
1885             if (!a)
1886               {
1887                 tty_printf (_("Can't open '%s': %s\n"),
1888                             fname, strerror (errno));
1889                 break;
1890               }
1891
1892             /* Parse and check that file.  */
1893             pkt = xmalloc (sizeof *pkt);
1894             init_packet (pkt);
1895             err = parse_packet (a, pkt);
1896             iobuf_close (a);
1897             iobuf_ioctl (NULL, IOBUF_IOCTL_INVALIDATE_CACHE, 0, (char *) fname);
1898             if (!err && pkt->pkttype != PKT_SECRET_KEY
1899                 && pkt->pkttype != PKT_SECRET_SUBKEY)
1900               err = GPG_ERR_NO_SECKEY;
1901             if (err)
1902               {
1903                 tty_printf (_("Error reading backup key from '%s': %s\n"),
1904                             fname, gpg_strerror (err));
1905                 free_packet (pkt);
1906                 xfree (pkt);
1907                 break;
1908               }
1909             node = new_kbnode (pkt);
1910
1911             if (cmd == cmdCHECKBKUPKEY)
1912               {
1913                 /* PKT_public_key *sk = node->pkt->pkt.secret_key; */
1914                 /* switch (is_secret_key_protected (sk)) */
1915                 /*   { */
1916                 /*   case 0:    /\* Not protected. *\/ */
1917                 /*     tty_printf (_("This key is not protected.\n")); */
1918                 /*     break; */
1919                 /*   case -1: */
1920                 /*     log_error (_("unknown key protection algorithm\n")); */
1921                 /*     break; */
1922                 /*   default: */
1923                 /*     if (sk->protect.s2k.mode == 1001) */
1924                 /*       tty_printf (_("Secret parts of key" */
1925                 /*                  " are not available.\n")); */
1926                 /*     if (sk->protect.s2k.mode == 1002) */
1927                 /*       tty_printf (_("Secret parts of key" */
1928                 /*                  " are stored on-card.\n")); */
1929                     /* else */
1930                     /*   check_secret_key (sk, 0); */
1931                   /* } */
1932               }
1933             else                /* Store it.  */
1934               {
1935                 if (card_store_subkey (node, 0))
1936                   {
1937                     redisplay = 1;
1938                     sec_shadowing = 1;
1939                   }
1940               }
1941             release_kbnode (node);
1942           }
1943           break;
1944
1945 #endif /* ENABLE_CARD_SUPPORT */
1946
1947         case cmdDELKEY:
1948           {
1949             int n1;
1950
1951             if (!(n1 = count_selected_keys (keyblock)))
1952               tty_printf (_("You must select at least one key (use the 'key' command).\n"));
1953             else if (!cpr_get_answer_is_yes
1954                      ("keyedit.remove.subkey.okay",
1955                       n1 > 1 ? _("Do you really want to delete the "
1956                                  "selected keys? (y/N) ")
1957                       :  _("Do you really want to delete this key? (y/N) ")))
1958               ;
1959             else
1960               {
1961                 menu_delkey (keyblock);
1962                 redisplay = 1;
1963                 modified = 1;
1964               }
1965           }
1966           break;
1967
1968         case cmdADDREVOKER:
1969           {
1970             int sensitive = 0;
1971
1972             if (ascii_strcasecmp (arg_string, "sensitive") == 0)
1973               sensitive = 1;
1974             if (menu_addrevoker (ctrl, keyblock, sensitive))
1975               {
1976                 redisplay = 1;
1977                 modified = 1;
1978                 merge_keys_and_selfsig (keyblock);
1979               }
1980           }
1981           break;
1982
1983         case cmdREVUID:
1984           {
1985             int n1;
1986
1987             if (!(n1 = count_selected_uids (keyblock)))
1988               tty_printf (_("You must select at least one user ID (use the 'uid' command).\n"));
1989             else if (cpr_get_answer_is_yes
1990                      ("keyedit.revoke.uid.okay",
1991                       n1 > 1 ? _("Really revoke all selected user IDs? (y/N) ")
1992                       :        _("Really revoke this user ID? (y/N) ")))
1993               {
1994                 if (menu_revuid (keyblock))
1995                   {
1996                     modified = 1;
1997                     redisplay = 1;
1998                   }
1999               }
2000           }
2001           break;
2002
2003         case cmdREVKEY:
2004           {
2005             int n1;
2006
2007             if (!(n1 = count_selected_keys (keyblock)))
2008               {
2009                 if (cpr_get_answer_is_yes ("keyedit.revoke.subkey.okay",
2010                                            _("Do you really want to revoke"
2011                                              " the entire key? (y/N) ")))
2012                   {
2013                     if (menu_revkey (keyblock))
2014                       modified = 1;
2015
2016                     redisplay = 1;
2017                   }
2018               }
2019             else if (cpr_get_answer_is_yes ("keyedit.revoke.subkey.okay",
2020                                             n1 > 1 ?
2021                                             _("Do you really want to revoke"
2022                                               " the selected subkeys? (y/N) ")
2023                                             : _("Do you really want to revoke"
2024                                                 " this subkey? (y/N) ")))
2025               {
2026                 if (menu_revsubkey (keyblock))
2027                   modified = 1;
2028
2029                 redisplay = 1;
2030               }
2031
2032             if (modified)
2033               merge_keys_and_selfsig (keyblock);
2034           }
2035           break;
2036
2037         case cmdEXPIRE:
2038           if (menu_expire (keyblock))
2039             {
2040               merge_keys_and_selfsig (keyblock);
2041               run_subkey_warnings = 1;
2042               modified = 1;
2043               redisplay = 1;
2044             }
2045           break;
2046
2047         case cmdBACKSIGN:
2048           if (menu_backsign (keyblock))
2049             {
2050               modified = 1;
2051               redisplay = 1;
2052             }
2053           break;
2054
2055         case cmdPRIMARY:
2056           if (menu_set_primary_uid (keyblock))
2057             {
2058               merge_keys_and_selfsig (keyblock);
2059               modified = 1;
2060               redisplay = 1;
2061             }
2062           break;
2063
2064         case cmdPASSWD:
2065           change_passphrase (ctrl, keyblock);
2066           break;
2067
2068 #ifndef NO_TRUST_MODELS
2069         case cmdTRUST:
2070           if (opt.trust_model == TM_EXTERNAL)
2071             {
2072               tty_printf (_("Owner trust may not be set while "
2073                             "using a user provided trust database\n"));
2074               break;
2075             }
2076
2077           show_key_with_all_names (ctrl, NULL, keyblock, 0, 0, 0, 1, 0, 0);
2078           tty_printf ("\n");
2079           if (edit_ownertrust (find_kbnode (keyblock,
2080                                             PKT_PUBLIC_KEY)->pkt->pkt.
2081                                public_key, 1))
2082             {
2083               redisplay = 1;
2084               /* No real need to set update_trust here as
2085                  edit_ownertrust() calls revalidation_mark()
2086                  anyway. */
2087               update_trust = 1;
2088             }
2089           break;
2090 #endif /*!NO_TRUST_MODELS*/
2091
2092         case cmdPREF:
2093           {
2094             int count = count_selected_uids (keyblock);
2095             assert (keyblock->pkt->pkttype == PKT_PUBLIC_KEY);
2096             show_names (NULL, keyblock, keyblock->pkt->pkt.public_key,
2097                         count ? NODFLG_SELUID : 0, 1);
2098           }
2099           break;
2100
2101         case cmdSHOWPREF:
2102           {
2103             int count = count_selected_uids (keyblock);
2104             assert (keyblock->pkt->pkttype == PKT_PUBLIC_KEY);
2105             show_names (NULL, keyblock, keyblock->pkt->pkt.public_key,
2106                         count ? NODFLG_SELUID : 0, 2);
2107           }
2108           break;
2109
2110         case cmdSETPREF:
2111           {
2112             PKT_user_id *tempuid;
2113
2114             keygen_set_std_prefs (!*arg_string ? "default" : arg_string, 0);
2115
2116             tempuid = keygen_get_std_prefs ();
2117             tty_printf (_("Set preference list to:\n"));
2118             show_prefs (tempuid, NULL, 1);
2119             free_user_id (tempuid);
2120
2121             if (cpr_get_answer_is_yes
2122                 ("keyedit.setpref.okay",
2123                  count_selected_uids (keyblock) ?
2124                  _("Really update the preferences"
2125                    " for the selected user IDs? (y/N) ")
2126                  : _("Really update the preferences? (y/N) ")))
2127               {
2128                 if (menu_set_preferences (keyblock))
2129                   {
2130                     merge_keys_and_selfsig (keyblock);
2131                     modified = 1;
2132                     redisplay = 1;
2133                   }
2134               }
2135           }
2136           break;
2137
2138         case cmdPREFKS:
2139           if (menu_set_keyserver_url (*arg_string ? arg_string : NULL,
2140                                       keyblock))
2141             {
2142               merge_keys_and_selfsig (keyblock);
2143               modified = 1;
2144               redisplay = 1;
2145             }
2146           break;
2147
2148         case cmdNOTATION:
2149           if (menu_set_notation (*arg_string ? arg_string : NULL,
2150                                  keyblock))
2151             {
2152               merge_keys_and_selfsig (keyblock);
2153               modified = 1;
2154               redisplay = 1;
2155             }
2156           break;
2157
2158         case cmdNOP:
2159           break;
2160
2161         case cmdREVSIG:
2162           if (menu_revsig (keyblock))
2163             {
2164               redisplay = 1;
2165               modified = 1;
2166             }
2167           break;
2168
2169 #ifndef NO_TRUST_MODELS
2170         case cmdENABLEKEY:
2171         case cmdDISABLEKEY:
2172           if (enable_disable_key (keyblock, cmd == cmdDISABLEKEY))
2173             {
2174               redisplay = 1;
2175               modified = 1;
2176             }
2177           break;
2178 #endif /*!NO_TRUST_MODELS*/
2179
2180         case cmdSHOWPHOTO:
2181           menu_showphoto (keyblock);
2182           break;
2183
2184         case cmdCLEAN:
2185           if (menu_clean (keyblock, 0))
2186             redisplay = modified = 1;
2187           break;
2188
2189         case cmdMINIMIZE:
2190           if (menu_clean (keyblock, 1))
2191             redisplay = modified = 1;
2192           break;
2193
2194         case cmdQUIT:
2195           if (have_commands)
2196             goto leave;
2197           if (!modified && !sec_shadowing)
2198             goto leave;
2199           if (!cpr_get_answer_is_yes ("keyedit.save.okay",
2200                                       _("Save changes? (y/N) ")))
2201             {
2202               if (cpr_enabled ()
2203                   || cpr_get_answer_is_yes ("keyedit.cancel.okay",
2204                                             _("Quit without saving? (y/N) ")))
2205                 goto leave;
2206               break;
2207             }
2208           /* fall thru */
2209         case cmdSAVE:
2210           if (modified)
2211             {
2212               err = keydb_update_keyblock (kdbhd, keyblock);
2213               if (err)
2214                 {
2215                   log_error (_("update failed: %s\n"), gpg_strerror (err));
2216                   break;
2217                 }
2218             }
2219
2220           if (sec_shadowing)
2221             {
2222               err = agent_scd_learn (NULL, 1);
2223               if (err)
2224                 {
2225                   log_error (_("update failed: %s\n"), gpg_strerror (err));
2226                   break;
2227                 }
2228             }
2229
2230           if (!modified && !sec_shadowing)
2231             tty_printf (_("Key not changed so no update needed.\n"));
2232
2233           if (update_trust)
2234             {
2235               revalidation_mark ();
2236               update_trust = 0;
2237             }
2238           goto leave;
2239
2240         case cmdINVCMD:
2241         default:
2242           tty_printf ("\n");
2243           tty_printf (_("Invalid command  (try \"help\")\n"));
2244           break;
2245         }
2246     } /* End of the main command loop.  */
2247
2248  leave:
2249   release_kbnode (keyblock);
2250   keydb_release (kdbhd);
2251   xfree (answer);
2252 }
2253
2254
2255 /* Change the passphrase of the secret key identified by USERNAME.  */
2256 void
2257 keyedit_passwd (ctrl_t ctrl, const char *username)
2258 {
2259   gpg_error_t err;
2260   PKT_public_key *pk;
2261   kbnode_t keyblock = NULL;
2262
2263   pk = xtrycalloc (1, sizeof *pk);
2264   if (!pk)
2265     {
2266       err = gpg_error_from_syserror ();
2267       goto leave;
2268     }
2269   err = getkey_byname (NULL, pk, username, 1, &keyblock);
2270   if (err)
2271     goto leave;
2272
2273   err = change_passphrase (ctrl, keyblock);
2274
2275 leave:
2276   release_kbnode (keyblock);
2277   free_public_key (pk);
2278   if (err)
2279     {
2280       log_info ("error changing the passphrase for '%s': %s\n",
2281                 username, gpg_strerror (err));
2282       write_status_error ("keyedit.passwd", err);
2283     }
2284   else
2285     write_status_text (STATUS_SUCCESS, "keyedit.passwd");
2286 }
2287
2288
2289 /* Unattended adding of a new keyid.  USERNAME specifies the
2290    key. NEWUID is the new user id to add to the key.  */
2291 void
2292 keyedit_quick_adduid (ctrl_t ctrl, const char *username, const char *newuid)
2293 {
2294   gpg_error_t err;
2295   KEYDB_HANDLE kdbhd = NULL;
2296   KEYDB_SEARCH_DESC desc;
2297   kbnode_t keyblock = NULL;
2298   kbnode_t node;
2299   char *uidstring = NULL;
2300
2301   uidstring = xstrdup (newuid);
2302   trim_spaces (uidstring);
2303   if (!*uidstring)
2304     {
2305       log_error ("%s\n", gpg_strerror (GPG_ERR_INV_USER_ID));
2306       goto leave;
2307     }
2308
2309 #ifdef HAVE_W32_SYSTEM
2310   /* See keyedit_menu for why we need this.  */
2311   check_trustdb_stale ();
2312 #endif
2313
2314   /* Search the key; we don't want the whole getkey stuff here.  */
2315   kdbhd = keydb_new ();
2316   err = classify_user_id (username, &desc, 1);
2317   if (!err)
2318     err = keydb_search (kdbhd, &desc, 1, NULL);
2319   if (!err)
2320     {
2321       err = keydb_get_keyblock (kdbhd, &keyblock);
2322       if (err)
2323         {
2324           log_error (_("error reading keyblock: %s\n"), gpg_strerror (err));
2325           goto leave;
2326         }
2327       /* Now with the keyblock retrieved, search again to detect an
2328          ambiguous specification.  We need to save the found state so
2329          that we can do an update later.  */
2330       keydb_push_found_state (kdbhd);
2331       err = keydb_search (kdbhd, &desc, 1, NULL);
2332       if (!err)
2333         err = gpg_error (GPG_ERR_AMBIGUOUS_NAME);
2334       else if (gpg_err_code (err) == GPG_ERR_NOT_FOUND)
2335         err = 0;
2336       keydb_pop_found_state (kdbhd);
2337
2338       if (!err)
2339         {
2340           /* We require the secret primary key to add a UID.  */
2341           node = find_kbnode (keyblock, PKT_PUBLIC_KEY);
2342           if (!node)
2343             BUG ();
2344           err = agent_probe_secret_key (ctrl, node->pkt->pkt.public_key);
2345         }
2346     }
2347   if (err)
2348     {
2349       log_error (_("secret key \"%s\" not found: %s\n"),
2350                  username, gpg_strerror (err));
2351       goto leave;
2352     }
2353
2354   fix_keyblock (&keyblock);
2355
2356   if (menu_adduid (keyblock, 0, NULL, uidstring))
2357     {
2358       err = keydb_update_keyblock (kdbhd, keyblock);
2359       if (err)
2360         {
2361           log_error (_("update failed: %s\n"), gpg_strerror (err));
2362           goto leave;
2363         }
2364
2365       if (update_trust)
2366         revalidation_mark ();
2367     }
2368
2369  leave:
2370   xfree (uidstring);
2371   release_kbnode (keyblock);
2372   keydb_release (kdbhd);
2373 }
2374
2375
2376 /* Unattended key signing function.  If the key specifified by FPR is
2377    availabale and FPR is the primary fingerprint all user ids of the
2378    user ids of the key are signed using the default signing key.  If
2379    UIDS is an empty list all usable UIDs are signed, if it is not
2380    empty, only those user ids matching one of the entries of the loist
2381    are signed.  With LOCAL being true kthe signatures are marked as
2382    non-exportable.  */
2383 void
2384 keyedit_quick_sign (ctrl_t ctrl, const char *fpr, strlist_t uids,
2385                     strlist_t locusr, int local)
2386 {
2387   gpg_error_t err;
2388   kbnode_t keyblock = NULL;
2389   KEYDB_HANDLE kdbhd = NULL;
2390   int modified = 0;
2391   KEYDB_SEARCH_DESC desc;
2392   PKT_public_key *pk;
2393   kbnode_t node;
2394   strlist_t sl;
2395   int any;
2396
2397 #ifdef HAVE_W32_SYSTEM
2398   /* See keyedit_menu for why we need this.  */
2399   check_trustdb_stale ();
2400 #endif
2401
2402   /* We require a fingerprint because only this uniquely identifies a
2403      key and may thus be used to select a key for unattended key
2404      signing.  */
2405   if (classify_user_id (fpr, &desc, 1)
2406       || !(desc.mode == KEYDB_SEARCH_MODE_FPR
2407            || desc.mode == KEYDB_SEARCH_MODE_FPR16
2408            || desc.mode == KEYDB_SEARCH_MODE_FPR20))
2409     {
2410       log_error (_("\"%s\" is not a fingerprint\n"), fpr);
2411       goto leave;
2412     }
2413   err = get_pubkey_byname (ctrl, NULL, NULL, fpr, &keyblock, &kdbhd, 1, 1);
2414   if (err)
2415     {
2416       log_error (_("key \"%s\" not found: %s\n"), fpr, gpg_strerror (err));
2417       goto leave;
2418     }
2419
2420   /* Check that the primary fingerprint has been given. */
2421   {
2422     byte fprbin[MAX_FINGERPRINT_LEN];
2423     size_t fprlen;
2424
2425     fingerprint_from_pk (keyblock->pkt->pkt.public_key, fprbin, &fprlen);
2426     if (fprlen == 16 && desc.mode == KEYDB_SEARCH_MODE_FPR16
2427         && !memcmp (fprbin, desc.u.fpr, 16))
2428       ;
2429     else if (fprlen == 16 && desc.mode == KEYDB_SEARCH_MODE_FPR
2430              && !memcmp (fprbin, desc.u.fpr, 16)
2431              && !desc.u.fpr[16]
2432              && !desc.u.fpr[17]
2433              && !desc.u.fpr[18]
2434              && !desc.u.fpr[19])
2435       ;
2436     else if (fprlen == 20 && (desc.mode == KEYDB_SEARCH_MODE_FPR20
2437                               || desc.mode == KEYDB_SEARCH_MODE_FPR)
2438              && !memcmp (fprbin, desc.u.fpr, 20))
2439       ;
2440     else
2441       {
2442         log_error (_("\"%s\" is not the primary fingerprint\n"), fpr);
2443         goto leave;
2444       }
2445   }
2446
2447   if (fix_keyblock (&keyblock))
2448     modified++;
2449
2450   /* Give some info in verbose.  */
2451   if (opt.verbose)
2452     {
2453       show_key_with_all_names (ctrl, es_stdout, keyblock, 0,
2454                                1/*with_revoker*/, 1/*with_fingerprint*/,
2455                                0, 0, 1);
2456       es_fflush (es_stdout);
2457     }
2458
2459   pk = keyblock->pkt->pkt.public_key;
2460   if (pk->flags.revoked)
2461     {
2462       if (!opt.verbose)
2463         show_key_with_all_names (ctrl, es_stdout, keyblock, 0, 0, 0, 0, 0, 1);
2464       log_error ("%s%s", _("Key is revoked."), _("  Unable to sign.\n"));
2465       goto leave;
2466     }
2467
2468   /* Set the flags according to the UIDS list.  Fixme: We may want to
2469      use classify_user_id along with dedicated compare functions so
2470      that we match the same way as in the key lookup. */
2471   any = 0;
2472   menu_select_uid (keyblock, 0);   /* Better clear the flags first. */
2473   for (sl=uids; sl; sl = sl->next)
2474     {
2475       for (node = keyblock; node; node = node->next)
2476         {
2477           if (node->pkt->pkttype == PKT_USER_ID)
2478             {
2479               PKT_user_id *uid = node->pkt->pkt.user_id;
2480
2481               if (!uid->attrib_data
2482                   && ascii_memistr (uid->name, uid->len, sl->d))
2483                 {
2484                   node->flag |= NODFLG_SELUID;
2485                   any = 1;
2486                 }
2487             }
2488         }
2489     }
2490
2491   if (uids && !any)
2492     {
2493       if (!opt.verbose)
2494         show_key_with_all_names (ctrl, es_stdout, keyblock, 0, 0, 0, 0, 0, 1);
2495       es_fflush (es_stdout);
2496       log_error ("%s  %s", _("No matching user IDs."), _("Nothing to sign.\n"));
2497       goto leave;
2498     }
2499
2500   /* Sign. */
2501   sign_uids (ctrl, es_stdout, keyblock, locusr, &modified, local, 0, 0, 0, 1);
2502   es_fflush (es_stdout);
2503
2504   if (modified)
2505     {
2506       err = keydb_update_keyblock (kdbhd, keyblock);
2507       if (err)
2508         {
2509           log_error (_("update failed: %s\n"), gpg_strerror (err));
2510           goto leave;
2511         }
2512     }
2513   else
2514     log_info (_("Key not changed so no update needed.\n"));
2515
2516   if (update_trust)
2517     revalidation_mark ();
2518
2519
2520  leave:
2521   release_kbnode (keyblock);
2522   keydb_release (kdbhd);
2523 }
2524
2525
2526 \f
2527 static void
2528 tty_print_notations (int indent, PKT_signature * sig)
2529 {
2530   int first = 1;
2531   struct notation *notation, *nd;
2532
2533   if (indent < 0)
2534     {
2535       first = 0;
2536       indent = -indent;
2537     }
2538
2539   notation = sig_to_notation (sig);
2540
2541   for (nd = notation; nd; nd = nd->next)
2542     {
2543       if (!first)
2544         tty_printf ("%*s", indent, "");
2545       else
2546         first = 0;
2547
2548       tty_print_utf8_string (nd->name, strlen (nd->name));
2549       tty_printf ("=");
2550       tty_print_utf8_string (nd->value, strlen (nd->value));
2551       tty_printf ("\n");
2552     }
2553
2554   free_notation (notation);
2555 }
2556
2557
2558 /*
2559  * Show preferences of a public keyblock.
2560  */
2561 static void
2562 show_prefs (PKT_user_id * uid, PKT_signature * selfsig, int verbose)
2563 {
2564   const prefitem_t fake = { 0, 0 };
2565   const prefitem_t *prefs;
2566   int i;
2567
2568   if (!uid)
2569     return;
2570
2571   if (uid->prefs)
2572     prefs = uid->prefs;
2573   else if (verbose)
2574     prefs = &fake;
2575   else
2576     return;
2577
2578   if (verbose)
2579     {
2580       int any, des_seen = 0, sha1_seen = 0, uncomp_seen = 0;
2581
2582       tty_printf ("     ");
2583       tty_printf (_("Cipher: "));
2584       for (i = any = 0; prefs[i].type; i++)
2585         {
2586           if (prefs[i].type == PREFTYPE_SYM)
2587             {
2588               if (any)
2589                 tty_printf (", ");
2590               any = 1;
2591               /* We don't want to display strings for experimental algos */
2592               if (!openpgp_cipher_test_algo (prefs[i].value)
2593                   && prefs[i].value < 100)
2594                 tty_printf ("%s", openpgp_cipher_algo_name (prefs[i].value));
2595               else
2596                 tty_printf ("[%d]", prefs[i].value);
2597               if (prefs[i].value == CIPHER_ALGO_3DES)
2598                 des_seen = 1;
2599             }
2600         }
2601       if (!des_seen)
2602         {
2603           if (any)
2604             tty_printf (", ");
2605           tty_printf ("%s", openpgp_cipher_algo_name (CIPHER_ALGO_3DES));
2606         }
2607       tty_printf ("\n     ");
2608       tty_printf (_("Digest: "));
2609       for (i = any = 0; prefs[i].type; i++)
2610         {
2611           if (prefs[i].type == PREFTYPE_HASH)
2612             {
2613               if (any)
2614                 tty_printf (", ");
2615               any = 1;
2616               /* We don't want to display strings for experimental algos */
2617               if (!gcry_md_test_algo (prefs[i].value) && prefs[i].value < 100)
2618                 tty_printf ("%s", gcry_md_algo_name (prefs[i].value));
2619               else
2620                 tty_printf ("[%d]", prefs[i].value);
2621               if (prefs[i].value == DIGEST_ALGO_SHA1)
2622                 sha1_seen = 1;
2623             }
2624         }
2625       if (!sha1_seen)
2626         {
2627           if (any)
2628             tty_printf (", ");
2629           tty_printf ("%s", gcry_md_algo_name (DIGEST_ALGO_SHA1));
2630         }
2631       tty_printf ("\n     ");
2632       tty_printf (_("Compression: "));
2633       for (i = any = 0; prefs[i].type; i++)
2634         {
2635           if (prefs[i].type == PREFTYPE_ZIP)
2636             {
2637               const char *s = compress_algo_to_string (prefs[i].value);
2638
2639               if (any)
2640                 tty_printf (", ");
2641               any = 1;
2642               /* We don't want to display strings for experimental algos */
2643               if (s && prefs[i].value < 100)
2644                 tty_printf ("%s", s);
2645               else
2646                 tty_printf ("[%d]", prefs[i].value);
2647               if (prefs[i].value == COMPRESS_ALGO_NONE)
2648                 uncomp_seen = 1;
2649             }
2650         }
2651       if (!uncomp_seen)
2652         {
2653           if (any)
2654             tty_printf (", ");
2655           else
2656             {
2657               tty_printf ("%s", compress_algo_to_string (COMPRESS_ALGO_ZIP));
2658               tty_printf (", ");
2659             }
2660           tty_printf ("%s", compress_algo_to_string (COMPRESS_ALGO_NONE));
2661         }
2662       if (uid->flags.mdc || !uid->flags.ks_modify)
2663         {
2664           tty_printf ("\n     ");
2665           tty_printf (_("Features: "));
2666           any = 0;
2667           if (uid->flags.mdc)
2668             {
2669               tty_printf ("MDC");
2670               any = 1;
2671             }
2672           if (!uid->flags.ks_modify)
2673             {
2674               if (any)
2675                 tty_printf (", ");
2676               tty_printf (_("Keyserver no-modify"));
2677             }
2678         }
2679       tty_printf ("\n");
2680
2681       if (selfsig)
2682         {
2683           const byte *pref_ks;
2684           size_t pref_ks_len;
2685
2686           pref_ks = parse_sig_subpkt (selfsig->hashed,
2687                                       SIGSUBPKT_PREF_KS, &pref_ks_len);
2688           if (pref_ks && pref_ks_len)
2689             {
2690               tty_printf ("     ");
2691               tty_printf (_("Preferred keyserver: "));
2692               tty_print_utf8_string (pref_ks, pref_ks_len);
2693               tty_printf ("\n");
2694             }
2695
2696           if (selfsig->flags.notation)
2697             {
2698               tty_printf ("     ");
2699               tty_printf (_("Notations: "));
2700               tty_print_notations (5 + strlen (_("Notations: ")), selfsig);
2701             }
2702         }
2703     }
2704   else
2705     {
2706       tty_printf ("    ");
2707       for (i = 0; prefs[i].type; i++)
2708         {
2709           tty_printf (" %c%d", prefs[i].type == PREFTYPE_SYM ? 'S' :
2710                       prefs[i].type == PREFTYPE_HASH ? 'H' :
2711                       prefs[i].type == PREFTYPE_ZIP ? 'Z' : '?',
2712                       prefs[i].value);
2713         }
2714       if (uid->flags.mdc)
2715         tty_printf (" [mdc]");
2716       if (!uid->flags.ks_modify)
2717         tty_printf (" [no-ks-modify]");
2718       tty_printf ("\n");
2719     }
2720 }
2721
2722
2723 /* This is the version of show_key_with_all_names used when
2724    opt.with_colons is used.  It prints all available data in a easy to
2725    parse format and does not translate utf8 */
2726 static void
2727 show_key_with_all_names_colon (ctrl_t ctrl, estream_t fp, kbnode_t keyblock)
2728 {
2729   KBNODE node;
2730   int i, j, ulti_hack = 0;
2731   byte pk_version = 0;
2732   PKT_public_key *primary = NULL;
2733   int have_seckey;
2734
2735   if (!fp)
2736     fp = es_stdout;
2737
2738   /* the keys */
2739   for (node = keyblock; node; node = node->next)
2740     {
2741       if (node->pkt->pkttype == PKT_PUBLIC_KEY
2742           || (node->pkt->pkttype == PKT_PUBLIC_SUBKEY))
2743         {
2744           PKT_public_key *pk = node->pkt->pkt.public_key;
2745           u32 keyid[2];
2746
2747           if (node->pkt->pkttype == PKT_PUBLIC_KEY)
2748             {
2749               pk_version = pk->version;
2750               primary = pk;
2751             }
2752
2753           keyid_from_pk (pk, keyid);
2754           have_seckey = !agent_probe_secret_key (ctrl, pk);
2755
2756           if (node->pkt->pkttype == PKT_PUBLIC_KEY)
2757             es_fputs (have_seckey? "sec:" : "pub:", fp);
2758           else
2759             es_fputs (have_seckey? "ssb:" : "sub:", fp);
2760
2761           if (!pk->flags.valid)
2762             es_putc ('i', fp);
2763           else if (pk->flags.revoked)
2764             es_putc ('r', fp);
2765           else if (pk->has_expired)
2766             es_putc ('e', fp);
2767           else if (!(opt.fast_list_mode || opt.no_expensive_trust_checks))
2768             {
2769               int trust = get_validity_info (pk, NULL);
2770               if (trust == 'u')
2771                 ulti_hack = 1;
2772               es_putc (trust, fp);
2773             }
2774
2775           es_fprintf (fp, ":%u:%d:%08lX%08lX:%lu:%lu::",
2776                       nbits_from_pk (pk),
2777                       pk->pubkey_algo,
2778                       (ulong) keyid[0], (ulong) keyid[1],
2779                       (ulong) pk->timestamp, (ulong) pk->expiredate);
2780           if (node->pkt->pkttype == PKT_PUBLIC_KEY
2781               && !(opt.fast_list_mode || opt.no_expensive_trust_checks))
2782             es_putc (get_ownertrust_info (pk), fp);
2783           es_putc (':', fp);
2784           es_putc (':', fp);
2785           es_putc (':', fp);
2786           /* Print capabilities.  */
2787           if ((pk->pubkey_usage & PUBKEY_USAGE_ENC))
2788             es_putc ('e', fp);
2789           if ((pk->pubkey_usage & PUBKEY_USAGE_SIG))
2790             es_putc ('s', fp);
2791           if ((pk->pubkey_usage & PUBKEY_USAGE_CERT))
2792             es_putc ('c', fp);
2793           if ((pk->pubkey_usage & PUBKEY_USAGE_AUTH))
2794             es_putc ('a', fp);
2795           es_putc ('\n', fp);
2796
2797           print_fingerprint (fp, pk, 0);
2798           print_revokers (fp, pk);
2799         }
2800     }
2801
2802   /* the user ids */
2803   i = 0;
2804   for (node = keyblock; node; node = node->next)
2805     {
2806       if (node->pkt->pkttype == PKT_USER_ID)
2807         {
2808           PKT_user_id *uid = node->pkt->pkt.user_id;
2809
2810           ++i;
2811
2812           if (uid->attrib_data)
2813             es_fputs ("uat:", fp);
2814           else
2815             es_fputs ("uid:", fp);
2816
2817           if (uid->is_revoked)
2818             es_fputs ("r::::::::", fp);
2819           else if (uid->is_expired)
2820             es_fputs ("e::::::::", fp);
2821           else if (opt.fast_list_mode || opt.no_expensive_trust_checks)
2822             es_fputs ("::::::::", fp);
2823           else
2824             {
2825               int uid_validity;
2826
2827               if (primary && !ulti_hack)
2828                 uid_validity = get_validity_info (primary, uid);
2829               else
2830                 uid_validity = 'u';
2831               es_fprintf (fp, "%c::::::::", uid_validity);
2832             }
2833
2834           if (uid->attrib_data)
2835             es_fprintf (fp, "%u %lu", uid->numattribs, uid->attrib_len);
2836           else
2837             es_write_sanitized (fp, uid->name, uid->len, ":", NULL);
2838
2839           es_putc (':', fp);
2840           /* signature class */
2841           es_putc (':', fp);
2842           /* capabilities */
2843           es_putc (':', fp);
2844           /* preferences */
2845           if (pk_version > 3 || uid->selfsigversion > 3)
2846             {
2847               const prefitem_t *prefs = uid->prefs;
2848
2849               for (j = 0; prefs && prefs[j].type; j++)
2850                 {
2851                   if (j)
2852                     es_putc (' ', fp);
2853                   es_fprintf (fp,
2854                               "%c%d", prefs[j].type == PREFTYPE_SYM ? 'S' :
2855                               prefs[j].type == PREFTYPE_HASH ? 'H' :
2856                               prefs[j].type == PREFTYPE_ZIP ? 'Z' : '?',
2857                               prefs[j].value);
2858                 }
2859               if (uid->flags.mdc)
2860                 es_fputs (",mdc", fp);
2861               if (!uid->flags.ks_modify)
2862                 es_fputs (",no-ks-modify", fp);
2863             }
2864           es_putc (':', fp);
2865           /* flags */
2866           es_fprintf (fp, "%d,", i);
2867           if (uid->is_primary)
2868             es_putc ('p', fp);
2869           if (uid->is_revoked)
2870             es_putc ('r', fp);
2871           if (uid->is_expired)
2872             es_putc ('e', fp);
2873           if ((node->flag & NODFLG_SELUID))
2874             es_putc ('s', fp);
2875           if ((node->flag & NODFLG_MARK_A))
2876             es_putc ('m', fp);
2877           es_putc (':', fp);
2878           es_putc ('\n', fp);
2879         }
2880     }
2881 }
2882
2883
2884 static void
2885 show_names (estream_t fp,
2886             KBNODE keyblock, PKT_public_key * pk, unsigned int flag,
2887             int with_prefs)
2888 {
2889   KBNODE node;
2890   int i = 0;
2891
2892   for (node = keyblock; node; node = node->next)
2893     {
2894       if (node->pkt->pkttype == PKT_USER_ID && !is_deleted_kbnode (node))
2895         {
2896           PKT_user_id *uid = node->pkt->pkt.user_id;
2897           ++i;
2898           if (!flag || (flag && (node->flag & flag)))
2899             {
2900               if (!(flag & NODFLG_MARK_A) && pk)
2901                 tty_fprintf (fp, "%s ", uid_trust_string_fixed (pk, uid));
2902
2903               if (flag & NODFLG_MARK_A)
2904                 tty_fprintf (fp, "     ");
2905               else if (node->flag & NODFLG_SELUID)
2906                 tty_fprintf (fp, "(%d)* ", i);
2907               else if (uid->is_primary)
2908                 tty_fprintf (fp, "(%d). ", i);
2909               else
2910                 tty_fprintf (fp, "(%d)  ", i);
2911               tty_print_utf8_string2 (fp, uid->name, uid->len, 0);
2912               tty_fprintf (fp, "\n");
2913               if (with_prefs && pk)
2914                 {
2915                   if (pk->version > 3 || uid->selfsigversion > 3)
2916                     {
2917                       PKT_signature *selfsig = NULL;
2918                       KBNODE signode;
2919
2920                       for (signode = node->next;
2921                            signode && signode->pkt->pkttype == PKT_SIGNATURE;
2922                            signode = signode->next)
2923                         {
2924                           if (signode->pkt->pkt.signature->
2925                               flags.chosen_selfsig)
2926                             {
2927                               selfsig = signode->pkt->pkt.signature;
2928                               break;
2929                             }
2930                         }
2931
2932                       show_prefs (uid, selfsig, with_prefs == 2);
2933                     }
2934                   else
2935                     tty_fprintf (fp, _("There are no preferences on a"
2936                                        " PGP 2.x-style user ID.\n"));
2937                 }
2938             }
2939         }
2940     }
2941 }
2942
2943
2944 /*
2945  * Display the key a the user ids, if only_marked is true, do only so
2946  * for user ids with mark A flag set and do not display the index
2947  * number.  If FP is not NULL print to the given stream and not to the
2948  * tty (ignored in with-colons mode).
2949  */
2950 static void
2951 show_key_with_all_names (ctrl_t ctrl, estream_t fp,
2952                          KBNODE keyblock, int only_marked, int with_revoker,
2953                          int with_fpr, int with_subkeys, int with_prefs,
2954                          int nowarn)
2955 {
2956   gpg_error_t err;
2957   kbnode_t node;
2958   int i;
2959   int do_warn = 0;
2960   int have_seckey = 0;
2961   char *serialno = NULL;
2962   PKT_public_key *primary = NULL;
2963   char pkstrbuf[PUBKEY_STRING_SIZE];
2964
2965   if (opt.with_colons)
2966     {
2967       show_key_with_all_names_colon (ctrl, fp, keyblock);
2968       return;
2969     }
2970
2971   /* the keys */
2972   for (node = keyblock; node; node = node->next)
2973     {
2974       if (node->pkt->pkttype == PKT_PUBLIC_KEY
2975           || (with_subkeys && node->pkt->pkttype == PKT_PUBLIC_SUBKEY
2976               && !is_deleted_kbnode (node)))
2977         {
2978           PKT_public_key *pk = node->pkt->pkt.public_key;
2979           const char *otrust = "err";
2980           const char *trust = "err";
2981
2982           if (node->pkt->pkttype == PKT_PUBLIC_KEY)
2983             {
2984               /* do it here, so that debug messages don't clutter the
2985                * output */
2986               static int did_warn = 0;
2987
2988               trust = get_validity_string (pk, NULL);
2989               otrust = get_ownertrust_string (pk);
2990
2991               /* Show a warning once */
2992               if (!did_warn
2993                   && (get_validity (pk, NULL) & TRUST_FLAG_PENDING_CHECK))
2994                 {
2995                   did_warn = 1;
2996                   do_warn = 1;
2997                 }
2998
2999               primary = pk;
3000             }
3001
3002           if (pk->flags.revoked)
3003             {
3004               char *user = get_user_id_string_native (pk->revoked.keyid);
3005               tty_fprintf (fp,
3006                            _("The following key was revoked on"
3007                             " %s by %s key %s\n"),
3008                           revokestr_from_pk (pk),
3009                           gcry_pk_algo_name (pk->revoked.algo), user);
3010               xfree (user);
3011             }
3012
3013           if (with_revoker)
3014             {
3015               if (!pk->revkey && pk->numrevkeys)
3016                 BUG ();
3017               else
3018                 for (i = 0; i < pk->numrevkeys; i++)
3019                   {
3020                     u32 r_keyid[2];
3021                     char *user;
3022                     const char *algo;
3023
3024                     algo = gcry_pk_algo_name (pk->revkey[i].algid);
3025                     keyid_from_fingerprint (pk->revkey[i].fpr,
3026                                             MAX_FINGERPRINT_LEN, r_keyid);
3027
3028                     user = get_user_id_string_native (r_keyid);
3029                     tty_fprintf (fp,
3030                                  _("This key may be revoked by %s key %s"),
3031                                  algo ? algo : "?", user);
3032
3033                     if (pk->revkey[i].class & 0x40)
3034                       {
3035                         tty_fprintf (fp, " ");
3036                         tty_fprintf (fp, _("(sensitive)"));
3037                       }
3038
3039                     tty_fprintf (fp, "\n");
3040                     xfree (user);
3041                   }
3042             }
3043
3044           keyid_from_pk (pk, NULL);
3045
3046           xfree (serialno);
3047           serialno = NULL;
3048           {
3049             char *hexgrip;
3050
3051             err = hexkeygrip_from_pk (pk, &hexgrip);
3052             if (err)
3053               {
3054                 log_error ("error computing a keygrip: %s\n",
3055                            gpg_strerror (err));
3056                 have_seckey = 0;
3057               }
3058             else
3059               have_seckey = !agent_get_keyinfo (ctrl, hexgrip, &serialno);
3060             xfree (hexgrip);
3061           }
3062
3063           tty_fprintf
3064             (fp, "%s%c %s/%s",
3065              node->pkt->pkttype == PKT_PUBLIC_KEY && have_seckey? "sec" :
3066              node->pkt->pkttype == PKT_PUBLIC_KEY ?               "pub" :
3067              have_seckey ?                                        "ssb" :
3068                                                                   "sub",
3069              (node->flag & NODFLG_SELKEY) ? '*' : ' ',
3070              pubkey_string (pk, pkstrbuf, sizeof pkstrbuf),
3071              keystr (pk->keyid));
3072
3073           if (opt.legacy_list_mode)
3074             tty_fprintf (fp, "  ");
3075           else
3076             tty_fprintf (fp, "\n     ");
3077
3078           tty_fprintf (fp, _("created: %s"), datestr_from_pk (pk));
3079           tty_fprintf (fp, "  ");
3080           if (pk->flags.revoked)
3081             tty_fprintf (fp, _("revoked: %s"), revokestr_from_pk (pk));
3082           else if (pk->has_expired)
3083             tty_fprintf (fp, _("expired: %s"), expirestr_from_pk (pk));
3084           else
3085             tty_fprintf (fp, _("expires: %s"), expirestr_from_pk (pk));
3086           tty_fprintf (fp, "  ");
3087           tty_fprintf (fp, _("usage: %s"), usagestr_from_pk (pk, 1));
3088           tty_fprintf (fp, "\n");
3089
3090           if (serialno)
3091             {
3092               /* The agent told us that a secret key is available and
3093                  that it has been stored on a card.  */
3094               tty_fprintf (fp, "%*s%s", opt.legacy_list_mode? 21:5, "",
3095                            _("card-no: "));
3096               if (strlen (serialno) == 32
3097                   && !strncmp (serialno, "D27600012401", 12))
3098                 {
3099                   /* This is an OpenPGP card.  Print the relevant part.  */
3100                   /* Example: D2760001240101010001000003470000 */
3101                   /*                          xxxxyyyyyyyy     */
3102                   tty_fprintf (fp, "%.*s %.*s\n",
3103                                4, serialno+16, 8, serialno+20);
3104                 }
3105               else
3106                 tty_fprintf (fp, "%s\n", serialno);
3107
3108             }
3109           else if (pk->seckey_info
3110               && pk->seckey_info->is_protected
3111               && pk->seckey_info->s2k.mode == 1002)
3112             {
3113               /* FIXME: Check wether this code path is still used.  */
3114               tty_fprintf (fp, "%*s%s", opt.legacy_list_mode? 21:5, "",
3115                            _("card-no: "));
3116               if (pk->seckey_info->ivlen == 16
3117                   && !memcmp (pk->seckey_info->iv,
3118                               "\xD2\x76\x00\x01\x24\x01", 6))
3119                 {
3120                   /* This is an OpenPGP card. */
3121                   for (i = 8; i < 14; i++)
3122                     {
3123                       if (i == 10)
3124                         tty_fprintf (fp, " ");
3125                       tty_fprintf (fp, "%02X", pk->seckey_info->iv[i]);
3126                     }
3127                 }
3128               else
3129                 {
3130                   /* Unknown card: Print all. */
3131                   for (i = 0; i < pk->seckey_info->ivlen; i++)
3132                     tty_fprintf (fp, "%02X", pk->seckey_info->iv[i]);
3133                 }
3134               tty_fprintf (fp, "\n");
3135             }
3136
3137           if (node->pkt->pkttype == PKT_PUBLIC_KEY
3138               || node->pkt->pkttype == PKT_SECRET_KEY)
3139             {
3140               if (opt.trust_model != TM_ALWAYS)
3141                 {
3142                   tty_fprintf (fp, "%*s",
3143                                opt.legacy_list_mode?
3144                                ((int) keystrlen () + 13):5, "");
3145                   /* Ownertrust is only meaningful for the PGP or
3146                      classic trust models */
3147                   if (opt.trust_model == TM_PGP
3148                       || opt.trust_model == TM_CLASSIC)
3149                     {
3150                       int width = 14 - strlen (otrust);
3151                       if (width <= 0)
3152                         width = 1;
3153                       tty_fprintf (fp, _("trust: %s"), otrust);
3154                       tty_fprintf (fp, "%*s", width, "");
3155                     }
3156
3157                   tty_fprintf (fp, _("validity: %s"), trust);
3158                   tty_fprintf (fp, "\n");
3159                 }
3160               if (node->pkt->pkttype == PKT_PUBLIC_KEY
3161                   && (get_ownertrust (pk) & TRUST_FLAG_DISABLED))
3162                 {
3163                   tty_fprintf (fp, "*** ");
3164                   tty_fprintf (fp, _("This key has been disabled"));
3165                   tty_fprintf (fp, "\n");
3166                 }
3167             }
3168
3169           if ((node->pkt->pkttype == PKT_PUBLIC_KEY
3170                || node->pkt->pkttype == PKT_SECRET_KEY) && with_fpr)
3171             {
3172               print_fingerprint (fp, pk, 2);
3173               tty_fprintf (fp, "\n");
3174             }
3175         }
3176     }
3177
3178   show_names (fp,
3179               keyblock, primary, only_marked ? NODFLG_MARK_A : 0, with_prefs);
3180
3181   if (do_warn && !nowarn)
3182     tty_fprintf (fp, _("Please note that the shown key validity"
3183                        " is not necessarily correct\n"
3184                        "unless you restart the program.\n"));
3185
3186   xfree (serialno);
3187 }
3188
3189
3190 /* Display basic key information.  This function is suitable to show
3191    information on the key without any dependencies on the trustdb or
3192    any other internal GnuPG stuff.  KEYBLOCK may either be a public or
3193    a secret key.  This function may be called with KEYBLOCK containing
3194    secret keys and thus the printing of "pub" vs. "sec" does only
3195    depend on the packet type and not by checking with gpg-agent.  */
3196 void
3197 show_basic_key_info (KBNODE keyblock)
3198 {
3199   KBNODE node;
3200   int i;
3201   char pkstrbuf[PUBKEY_STRING_SIZE];
3202
3203   /* The primary key */
3204   for (node = keyblock; node; node = node->next)
3205     {
3206       if (node->pkt->pkttype == PKT_PUBLIC_KEY
3207           || node->pkt->pkttype == PKT_SECRET_KEY)
3208         {
3209           PKT_public_key *pk = node->pkt->pkt.public_key;
3210
3211           /* Note, we use the same format string as in other show
3212              functions to make the translation job easier. */
3213           tty_printf ("%s  %s/%s  ",
3214                       node->pkt->pkttype == PKT_PUBLIC_KEY ? "pub" :
3215                       node->pkt->pkttype == PKT_PUBLIC_SUBKEY ? "sub" :
3216                       node->pkt->pkttype == PKT_SECRET_KEY ? "sec" :"ssb",
3217                       pubkey_string (pk, pkstrbuf, sizeof pkstrbuf),
3218                       keystr_from_pk (pk));
3219           tty_printf (_("created: %s"), datestr_from_pk (pk));
3220           tty_printf ("  ");
3221           tty_printf (_("expires: %s"), expirestr_from_pk (pk));
3222           tty_printf ("\n");
3223           print_fingerprint (NULL, pk, 3);
3224           tty_printf ("\n");
3225         }
3226     }
3227
3228   /* The user IDs. */
3229   for (i = 0, node = keyblock; node; node = node->next)
3230     {
3231       if (node->pkt->pkttype == PKT_USER_ID)
3232         {
3233           PKT_user_id *uid = node->pkt->pkt.user_id;
3234           ++i;
3235
3236           tty_printf ("     ");
3237           if (uid->is_revoked)
3238             tty_printf ("[%s] ", _("revoked"));
3239           else if (uid->is_expired)
3240             tty_printf ("[%s] ", _("expired"));
3241           tty_print_utf8_string (uid->name, uid->len);
3242           tty_printf ("\n");
3243         }
3244     }
3245 }
3246
3247
3248 static void
3249 show_key_and_fingerprint (kbnode_t keyblock, int with_subkeys)
3250 {
3251   kbnode_t node;
3252   PKT_public_key *pk = NULL;
3253   char pkstrbuf[PUBKEY_STRING_SIZE];
3254
3255   for (node = keyblock; node; node = node->next)
3256     {
3257       if (node->pkt->pkttype == PKT_PUBLIC_KEY)
3258         {
3259           pk = node->pkt->pkt.public_key;
3260           tty_printf ("pub   %s/%s %s ",
3261                       pubkey_string (pk, pkstrbuf, sizeof pkstrbuf),
3262                       keystr_from_pk(pk),
3263                       datestr_from_pk (pk));
3264         }
3265       else if (node->pkt->pkttype == PKT_USER_ID)
3266         {
3267           PKT_user_id *uid = node->pkt->pkt.user_id;
3268           tty_print_utf8_string (uid->name, uid->len);
3269           break;
3270         }
3271     }
3272   tty_printf ("\n");
3273   if (pk)
3274     print_fingerprint (NULL, pk, 2);
3275   if (with_subkeys)
3276     {
3277       for (node = keyblock; node; node = node->next)
3278         {
3279           if (node->pkt->pkttype == PKT_PUBLIC_SUBKEY)
3280             {
3281               pk = node->pkt->pkt.public_key;
3282               tty_printf ("sub   %s/%s %s [%s]\n",
3283                           pubkey_string (pk, pkstrbuf, sizeof pkstrbuf),
3284                           keystr_from_pk(pk),
3285                           datestr_from_pk (pk),
3286                           usagestr_from_pk (pk, 0));
3287
3288               print_fingerprint (NULL, pk, 4);
3289             }
3290         }
3291     }
3292 }
3293
3294
3295 /* Show a listing of the primary and its subkeys along with their
3296    keygrips.  */
3297 static void
3298 show_key_and_grip (kbnode_t keyblock)
3299 {
3300   kbnode_t node;
3301   PKT_public_key *pk = NULL;
3302   char pkstrbuf[PUBKEY_STRING_SIZE];
3303   char *hexgrip;
3304
3305   for (node = keyblock; node; node = node->next)
3306     {
3307       if (node->pkt->pkttype == PKT_PUBLIC_KEY
3308           || node->pkt->pkttype == PKT_PUBLIC_SUBKEY)
3309         {
3310           pk = node->pkt->pkt.public_key;
3311           tty_printf ("%s   %s/%s %s [%s]\n",
3312                       node->pkt->pkttype == PKT_PUBLIC_KEY? "pub":"sub",
3313                       pubkey_string (pk, pkstrbuf, sizeof pkstrbuf),
3314                       keystr_from_pk(pk),
3315                       datestr_from_pk (pk),
3316                       usagestr_from_pk (pk, 0));
3317
3318           if (!hexkeygrip_from_pk (pk, &hexgrip))
3319             {
3320               tty_printf ("      Keygrip: %s\n", hexgrip);
3321               xfree (hexgrip);
3322             }
3323         }
3324     }
3325 }
3326
3327
3328 /* Show a warning if no uids on the key have the primary uid flag
3329    set. */
3330 static void
3331 no_primary_warning (KBNODE keyblock)
3332 {
3333   KBNODE node;
3334   int have_primary = 0, uid_count = 0;
3335
3336   /* TODO: if we ever start behaving differently with a primary or
3337      non-primary attribute ID, we will need to check for attributes
3338      here as well. */
3339
3340   for (node = keyblock; node; node = node->next)
3341     {
3342       if (node->pkt->pkttype == PKT_USER_ID
3343           && node->pkt->pkt.user_id->attrib_data == NULL)
3344         {
3345           uid_count++;
3346
3347           if (node->pkt->pkt.user_id->is_primary == 2)
3348             {
3349               have_primary = 1;
3350               break;
3351             }
3352         }
3353     }
3354
3355   if (uid_count > 1 && !have_primary)
3356     log_info (_
3357               ("WARNING: no user ID has been marked as primary.  This command"
3358                " may\n              cause a different user ID to become"
3359                " the assumed primary.\n"));
3360 }
3361
3362
3363 /* Print a warning if the latest encryption subkey expires soon.  This
3364    function is called after the expire data of the primary key has
3365    been changed.  */
3366 static void
3367 subkey_expire_warning (kbnode_t keyblock)
3368 {
3369   u32 curtime = make_timestamp ();
3370   kbnode_t node;
3371   PKT_public_key *pk;
3372   /* u32 mainexpire = 0; */
3373   u32 subexpire = 0;
3374   u32 latest_date = 0;
3375
3376   for (node = keyblock; node; node = node->next)
3377     {
3378       /* if (node->pkt->pkttype == PKT_PUBLIC_KEY) */
3379       /*   { */
3380       /*     pk = node->pkt->pkt.public_key; */
3381       /*     mainexpire = pk->expiredate; */
3382       /*   } */
3383
3384       if (node->pkt->pkttype != PKT_PUBLIC_SUBKEY)
3385         continue;
3386       pk = node->pkt->pkt.public_key;
3387
3388       if (!pk->flags.valid)
3389         continue;
3390       if (pk->flags.revoked)
3391         continue;
3392       if (pk->timestamp > curtime)
3393         continue; /* Ignore future keys.  */
3394       if (!(pk->pubkey_usage & PUBKEY_USAGE_ENC))
3395         continue; /* Not an encryption key.  */
3396
3397       if (pk->timestamp > latest_date || (!pk->timestamp && !latest_date))
3398         {
3399           latest_date = pk->timestamp;
3400           subexpire = pk->expiredate;
3401         }
3402     }
3403
3404   if (!subexpire)
3405     return;  /* No valid subkey with an expiration time.  */
3406
3407   if (curtime + (10*86400) > subexpire)
3408     {
3409       log_info (_("WARNING: Your encryption subkey expires soon.\n"));
3410       log_info (_("You may want to change its expiration date too.\n"));
3411     }
3412 }
3413
3414
3415 /*
3416  * Ask for a new user id, add the self-signature, and update the
3417  * keyblock.  If UIDSTRING is not NULL the user ID is generated
3418  * unattended using that string.  UIDSTRING is expected to be utf-8
3419  * encoded and white space trimmed.  Returns true if there is a new
3420  * user id.
3421  */
3422 static int
3423 menu_adduid (kbnode_t pub_keyblock, int photo, const char *photo_name,
3424              const char *uidstring)
3425 {
3426   PKT_user_id *uid;
3427   PKT_public_key *pk = NULL;
3428   PKT_signature *sig = NULL;
3429   PACKET *pkt;
3430   KBNODE node;
3431   KBNODE pub_where = NULL;
3432   gpg_error_t err;
3433
3434   if (photo && uidstring)
3435     return 0;  /* Not allowed.  */
3436
3437   for (node = pub_keyblock; node; pub_where = node, node = node->next)
3438     {
3439       if (node->pkt->pkttype == PKT_PUBLIC_KEY)
3440         pk = node->pkt->pkt.public_key;
3441       else if (node->pkt->pkttype == PKT_PUBLIC_SUBKEY)
3442         break;
3443     }
3444   if (!node) /* No subkey.  */
3445     pub_where = NULL;
3446   assert (pk);
3447
3448   if (photo)
3449     {
3450       int hasattrib = 0;
3451
3452       for (node = pub_keyblock; node; node = node->next)
3453         if (node->pkt->pkttype == PKT_USER_ID &&
3454             node->pkt->pkt.user_id->attrib_data != NULL)
3455           {
3456             hasattrib = 1;
3457             break;
3458           }
3459
3460       /* It is legal but bad for compatibility to add a photo ID to a
3461          v3 key as it means that PGP2 will not be able to use that key
3462          anymore.  Also, PGP may not expect a photo on a v3 key.
3463          Don't bother to ask this if the key already has a photo - any
3464          damage has already been done at that point. -dms */
3465       if (pk->version == 3 && !hasattrib)
3466         {
3467           if (opt.expert)
3468             {
3469               tty_printf (_("WARNING: This is a PGP2-style key.  "
3470                             "Adding a photo ID may cause some versions\n"
3471                             "         of PGP to reject this key.\n"));
3472
3473               if (!cpr_get_answer_is_yes ("keyedit.v3_photo.okay",
3474                                           _("Are you sure you still want "
3475                                             "to add it? (y/N) ")))
3476                 return 0;
3477             }
3478           else
3479             {
3480               tty_printf (_("You may not add a photo ID to "
3481                             "a PGP2-style key.\n"));
3482               return 0;
3483             }
3484         }
3485
3486       uid = generate_photo_id (pk, photo_name);
3487     }
3488   else
3489     uid = generate_user_id (pub_keyblock, uidstring);
3490   if (!uid)
3491     {
3492       if (uidstring)
3493         log_error ("%s", _("Such a user ID already exists on this key!\n"));
3494       return 0;
3495     }
3496
3497   err = make_keysig_packet (&sig, pk, uid, NULL, pk, 0x13, 0, 0, 0,
3498                             keygen_add_std_prefs, pk, NULL);
3499   if (err)
3500     {
3501       write_status_error ("keysig", err);
3502       log_error ("signing failed: %s\n", gpg_strerror (err));
3503       free_user_id (uid);
3504       return 0;
3505     }
3506
3507   /* Insert/append to public keyblock */
3508   pkt = xmalloc_clear (sizeof *pkt);
3509   pkt->pkttype = PKT_USER_ID;
3510   pkt->pkt.user_id = uid;
3511   node = new_kbnode (pkt);
3512   if (pub_where)
3513     insert_kbnode (pub_where, node, 0);
3514   else
3515     add_kbnode (pub_keyblock, node);
3516   pkt = xmalloc_clear (sizeof *pkt);
3517   pkt->pkttype = PKT_SIGNATURE;
3518   pkt->pkt.signature = copy_signature (NULL, sig);
3519   if (pub_where)
3520     insert_kbnode (node, new_kbnode (pkt), 0);
3521   else
3522     add_kbnode (pub_keyblock, new_kbnode (pkt));
3523   return 1;
3524 }
3525
3526
3527 /*
3528  * Remove all selected userids from the keyring
3529  */
3530 static void
3531 menu_deluid (KBNODE pub_keyblock)
3532 {
3533   KBNODE node;
3534   int selected = 0;
3535
3536   for (node = pub_keyblock; node; node = node->next)
3537     {
3538       if (node->pkt->pkttype == PKT_USER_ID)
3539         {
3540           selected = node->flag & NODFLG_SELUID;
3541           if (selected)
3542             {
3543               /* Only cause a trust update if we delete a
3544                  non-revoked user id */
3545               if (!node->pkt->pkt.user_id->is_revoked)
3546                 update_trust = 1;
3547               delete_kbnode (node);
3548             }
3549         }
3550       else if (selected && node->pkt->pkttype == PKT_SIGNATURE)
3551         delete_kbnode (node);
3552       else if (node->pkt->pkttype == PKT_PUBLIC_SUBKEY)
3553         selected = 0;
3554     }
3555   commit_kbnode (&pub_keyblock);
3556 }
3557
3558
3559 static int
3560 menu_delsig (KBNODE pub_keyblock)
3561 {
3562   KBNODE node;
3563   PKT_user_id *uid = NULL;
3564   int changed = 0;
3565
3566   for (node = pub_keyblock; node; node = node->next)
3567     {
3568       if (node->pkt->pkttype == PKT_USER_ID)
3569         {
3570           uid = (node->flag & NODFLG_SELUID) ? node->pkt->pkt.user_id : NULL;
3571         }
3572       else if (uid && node->pkt->pkttype == PKT_SIGNATURE)
3573         {
3574           int okay, valid, selfsig, inv_sig, no_key, other_err;
3575
3576           tty_printf ("uid  ");
3577           tty_print_utf8_string (uid->name, uid->len);
3578           tty_printf ("\n");
3579
3580           okay = inv_sig = no_key = other_err = 0;
3581           if (opt.with_colons)
3582             valid = print_and_check_one_sig_colon (pub_keyblock, node,
3583                                                    &inv_sig, &no_key,
3584                                                    &other_err, &selfsig, 1);
3585           else
3586             valid = print_and_check_one_sig (pub_keyblock, node,
3587                                              &inv_sig, &no_key, &other_err,
3588                                              &selfsig, 1);
3589
3590           if (valid)
3591             {
3592               okay = cpr_get_answer_yes_no_quit
3593                 ("keyedit.delsig.valid",
3594                  _("Delete this good signature? (y/N/q)"));
3595
3596               /* Only update trust if we delete a good signature.
3597                  The other two cases do not affect trust. */
3598               if (okay)
3599                 update_trust = 1;
3600             }
3601           else if (inv_sig || other_err)
3602             okay = cpr_get_answer_yes_no_quit
3603               ("keyedit.delsig.invalid",
3604                _("Delete this invalid signature? (y/N/q)"));
3605           else if (no_key)
3606             okay = cpr_get_answer_yes_no_quit
3607               ("keyedit.delsig.unknown",
3608                _("Delete this unknown signature? (y/N/q)"));
3609
3610           if (okay == -1)
3611             break;
3612           if (okay && selfsig
3613               && !cpr_get_answer_is_yes
3614               ("keyedit.delsig.selfsig",
3615                _("Really delete this self-signature? (y/N)")))
3616             okay = 0;
3617           if (okay)
3618             {
3619               delete_kbnode (node);
3620               changed++;
3621             }
3622
3623         }
3624       else if (node->pkt->pkttype == PKT_PUBLIC_SUBKEY)
3625         uid = NULL;
3626     }
3627
3628   if (changed)
3629     {
3630       commit_kbnode (&pub_keyblock);
3631       tty_printf (changed == 1 ? _("Deleted %d signature.\n")
3632                   : _("Deleted %d signatures.\n"), changed);
3633     }
3634   else
3635     tty_printf (_("Nothing deleted.\n"));
3636
3637   return changed;
3638 }
3639
3640
3641 static int
3642 menu_clean (KBNODE keyblock, int self_only)
3643 {
3644   KBNODE uidnode;
3645   int modified = 0, select_all = !count_selected_uids (keyblock);
3646
3647   for (uidnode = keyblock->next;
3648        uidnode && uidnode->pkt->pkttype != PKT_PUBLIC_SUBKEY;
3649        uidnode = uidnode->next)
3650     {
3651       if (uidnode->pkt->pkttype == PKT_USER_ID
3652           && (uidnode->flag & NODFLG_SELUID || select_all))
3653         {
3654           int uids = 0, sigs = 0;
3655           char *user = utf8_to_native (uidnode->pkt->pkt.user_id->name,
3656                                        uidnode->pkt->pkt.user_id->len,
3657                                        0);
3658
3659           clean_one_uid (keyblock, uidnode, opt.verbose, self_only, &uids,
3660                          &sigs);
3661           if (uids)
3662             {
3663               const char *reason;
3664
3665               if (uidnode->pkt->pkt.user_id->is_revoked)
3666                 reason = _("revoked");
3667               else if (uidnode->pkt->pkt.user_id->is_expired)
3668                 reason = _("expired");
3669               else
3670                 reason = _("invalid");
3671
3672               tty_printf (_("User ID \"%s\" compacted: %s\n"), user, reason);
3673
3674               modified = 1;
3675             }
3676           else if (sigs)
3677             {
3678               tty_printf (sigs == 1 ?
3679                           _("User ID \"%s\": %d signature removed\n") :
3680                           _("User ID \"%s\": %d signatures removed\n"),
3681                           user, sigs);
3682
3683               modified = 1;
3684             }
3685           else
3686             {
3687               tty_printf (self_only == 1 ?
3688                           _("User ID \"%s\": already minimized\n") :
3689                           _("User ID \"%s\": already clean\n"), user);
3690             }
3691
3692           xfree (user);
3693         }
3694     }
3695
3696   return modified;
3697 }
3698
3699
3700 /*
3701  * Remove some of the secondary keys
3702  */
3703 static void
3704 menu_delkey (KBNODE pub_keyblock)
3705 {
3706   KBNODE node;
3707   int selected = 0;
3708
3709   for (node = pub_keyblock; node; node = node->next)
3710     {
3711       if (node->pkt->pkttype == PKT_PUBLIC_SUBKEY)
3712         {
3713           selected = node->flag & NODFLG_SELKEY;
3714           if (selected)
3715             delete_kbnode (node);
3716         }
3717       else if (selected && node->pkt->pkttype == PKT_SIGNATURE)
3718         delete_kbnode (node);
3719       else
3720         selected = 0;
3721     }
3722   commit_kbnode (&pub_keyblock);
3723
3724   /* No need to set update_trust here since signing keys are no
3725      longer used to certify other keys, so there is no change in
3726      trust when revoking/removing them.   */
3727 }
3728
3729
3730 /*
3731  * Ask for a new revoker, create the self-signature and put it into
3732  * the keyblock.  Returns true if there is a new revoker.
3733  */
3734 static int
3735 menu_addrevoker (ctrl_t ctrl, kbnode_t pub_keyblock, int sensitive)
3736 {
3737   PKT_public_key *pk = NULL;
3738   PKT_public_key *revoker_pk = NULL;
3739   PKT_signature *sig = NULL;
3740   PACKET *pkt;
3741   struct revocation_key revkey;
3742   size_t fprlen;
3743   int rc;
3744
3745   assert (pub_keyblock->pkt->pkttype == PKT_PUBLIC_KEY);
3746
3747   pk = pub_keyblock->pkt->pkt.public_key;
3748
3749   if (pk->numrevkeys == 0 && pk->version == 3)
3750     {
3751       /* It is legal but bad for compatibility to add a revoker to a
3752          v3 key as it means that PGP2 will not be able to use that key
3753          anymore.  Also, PGP may not expect a revoker on a v3 key.
3754          Don't bother to ask this if the key already has a revoker -
3755          any damage has already been done at that point. -dms */
3756       if (opt.expert)
3757         {
3758           tty_printf (_("WARNING: This is a PGP 2.x-style key.  "
3759                         "Adding a designated revoker may cause\n"
3760                         "         some versions of PGP to reject this key.\n"));
3761
3762           if (!cpr_get_answer_is_yes ("keyedit.v3_revoker.okay",
3763                                       _("Are you sure you still want "
3764                                         "to add it? (y/N) ")))
3765             return 0;
3766         }
3767       else
3768         {
3769           tty_printf (_("You may not add a designated revoker to "
3770                         "a PGP 2.x-style key.\n"));
3771           return 0;
3772         }
3773     }
3774
3775   for (;;)
3776     {
3777       char *answer;
3778
3779       free_public_key (revoker_pk);
3780       revoker_pk = xmalloc_clear (sizeof (*revoker_pk));
3781
3782       tty_printf ("\n");
3783
3784       answer = cpr_get_utf8
3785         ("keyedit.add_revoker",
3786          _("Enter the user ID of the designated revoker: "));
3787       if (answer[0] == '\0' || answer[0] == CONTROL_D)
3788         {
3789           xfree (answer);
3790           goto fail;
3791         }
3792
3793       /* Note that I'm requesting CERT here, which usually implies
3794          primary keys only, but some casual testing shows that PGP and
3795          GnuPG both can handle a designated revocation from a subkey. */
3796       revoker_pk->req_usage = PUBKEY_USAGE_CERT;
3797       rc = get_pubkey_byname (ctrl, NULL, revoker_pk, answer, NULL, NULL, 1, 1);
3798       if (rc)
3799         {
3800           log_error (_("key \"%s\" not found: %s\n"), answer,
3801                      gpg_strerror (rc));
3802           xfree (answer);
3803           continue;
3804         }
3805
3806       xfree (answer);
3807
3808       fingerprint_from_pk (revoker_pk, revkey.fpr, &fprlen);
3809       if (fprlen != 20)
3810         {
3811           log_error (_("cannot appoint a PGP 2.x style key as a "
3812                        "designated revoker\n"));
3813           continue;
3814         }
3815
3816       revkey.class = 0x80;
3817       if (sensitive)
3818         revkey.class |= 0x40;
3819       revkey.algid = revoker_pk->pubkey_algo;
3820
3821       if (cmp_public_keys (revoker_pk, pk) == 0)
3822         {
3823           /* This actually causes no harm (after all, a key that
3824              designates itself as a revoker is the same as a
3825              regular key), but it's easy enough to check. */
3826           log_error (_("you cannot appoint a key as its own "
3827                        "designated revoker\n"));
3828
3829           continue;
3830         }
3831
3832       keyid_from_pk (pk, NULL);
3833
3834       /* Does this revkey already exist? */
3835       if (!pk->revkey && pk->numrevkeys)
3836         BUG ();
3837       else
3838         {
3839           int i;
3840
3841           for (i = 0; i < pk->numrevkeys; i++)
3842             {
3843               if (memcmp (&pk->revkey[i], &revkey,
3844                           sizeof (struct revocation_key)) == 0)
3845                 {
3846                   char buf[50];
3847
3848                   log_error (_("this key has already been designated "
3849                                "as a revoker\n"));
3850
3851                   sprintf (buf, "%08lX%08lX",
3852                            (ulong) pk->keyid[0], (ulong) pk->keyid[1]);
3853                   write_status_text (STATUS_ALREADY_SIGNED, buf);
3854
3855                   break;
3856                 }
3857             }
3858
3859           if (i < pk->numrevkeys)
3860             continue;
3861         }
3862
3863       print_pubkey_info (NULL, revoker_pk);
3864       print_fingerprint (NULL, revoker_pk, 2);
3865       tty_printf ("\n");
3866
3867       tty_printf (_("WARNING: appointing a key as a designated revoker "
3868                     "cannot be undone!\n"));
3869
3870       tty_printf ("\n");
3871
3872       if (!cpr_get_answer_is_yes ("keyedit.add_revoker.okay",
3873                                   _("Are you sure you want to appoint this "
3874                                     "key as a designated revoker? (y/N) ")))
3875         continue;
3876
3877       free_public_key (revoker_pk);
3878       revoker_pk = NULL;
3879       break;
3880     }
3881
3882   rc = make_keysig_packet (&sig, pk, NULL, NULL, pk, 0x1F, 0, 0, 0,
3883                            keygen_add_revkey, &revkey, NULL);
3884   if (rc)
3885     {
3886       write_status_error ("keysig", rc);
3887       log_error ("signing failed: %s\n", gpg_strerror (rc));
3888       goto fail;
3889     }
3890
3891   /* Insert into public keyblock.  */
3892   pkt = xmalloc_clear (sizeof *pkt);
3893   pkt->pkttype = PKT_SIGNATURE;
3894   pkt->pkt.signature = sig;
3895   insert_kbnode (pub_keyblock, new_kbnode (pkt), PKT_SIGNATURE);
3896
3897   return 1;
3898
3899 fail:
3900   if (sig)
3901     free_seckey_enc (sig);
3902   free_public_key (revoker_pk);
3903
3904   return 0;
3905 }
3906
3907
3908 static int
3909 menu_expire (KBNODE pub_keyblock)
3910 {
3911   int n1, signumber, rc;
3912   u32 expiredate;
3913   int mainkey = 0;
3914   PKT_public_key *main_pk, *sub_pk;
3915   PKT_user_id *uid;
3916   KBNODE node;
3917   u32 keyid[2];
3918
3919   n1 = count_selected_keys (pub_keyblock);
3920   if (n1 > 1)
3921     {
3922       tty_printf (_("Please select at most one subkey.\n"));
3923       return 0;
3924     }