d8dba2d735f32bba55acacaf30cad3f34aca8dc2
[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                   log_error (_("signing failed: %s\n"), gpg_strerror (rc));
1045                   goto leave;
1046                 }
1047
1048               *ret_modified = 1;        /* We changed the keyblock. */
1049               update_trust = 1;
1050
1051               pkt = xmalloc_clear (sizeof *pkt);
1052               pkt->pkttype = PKT_SIGNATURE;
1053               pkt->pkt.signature = sig;
1054               insert_kbnode (node, new_kbnode (pkt), PKT_SIGNATURE);
1055               goto reloop;
1056             }
1057         }
1058
1059       /* Delete any sigs that got promoted */
1060       for (node = keyblock; node; node = node->next)
1061         if (node->flag & NODFLG_DELSIG)
1062           delete_kbnode (node);
1063     } /* End loop over signators.  */
1064
1065  leave:
1066   release_sk_list (sk_list);
1067   return rc;
1068 }
1069
1070
1071 /*
1072  * Change the passphrase of the primary and all secondary keys.  Note
1073  * that it is common to use only one passphrase for the primary and
1074  * all subkeys.  However, this is now (since GnuPG 2.1) all up to the
1075  * gpg-agent.  Returns 0 on success or an error code.
1076  */
1077 static gpg_error_t
1078 change_passphrase (ctrl_t ctrl, kbnode_t keyblock)
1079 {
1080   gpg_error_t err;
1081   kbnode_t node;
1082   PKT_public_key *pk;
1083   int any;
1084   u32 keyid[2], subid[2];
1085   char *hexgrip = NULL;
1086   char *cache_nonce = NULL;
1087   char *passwd_nonce = NULL;
1088
1089   node = find_kbnode (keyblock, PKT_PUBLIC_KEY);
1090   if (!node)
1091     {
1092       log_error ("Oops; public key missing!\n");
1093       err = gpg_error (GPG_ERR_INTERNAL);
1094       goto leave;
1095     }
1096   pk = node->pkt->pkt.public_key;
1097   keyid_from_pk (pk, keyid);
1098
1099   /* Check whether it is likely that we will be able to change the
1100      passphrase for any subkey.  */
1101   for (any = 0, node = keyblock; node; node = node->next)
1102     {
1103       if (node->pkt->pkttype == PKT_PUBLIC_KEY
1104           || node->pkt->pkttype == PKT_PUBLIC_SUBKEY)
1105         {
1106           char *serialno;
1107
1108           pk = node->pkt->pkt.public_key;
1109           keyid_from_pk (pk, subid);
1110
1111           xfree (hexgrip);
1112           err = hexkeygrip_from_pk (pk, &hexgrip);
1113           if (err)
1114             goto leave;
1115           err = agent_get_keyinfo (ctrl, hexgrip, &serialno);
1116           if (!err && serialno)
1117             ; /* Key on card.  */
1118           else if (gpg_err_code (err) == GPG_ERR_NOT_FOUND)
1119             ; /* Maybe stub key. */
1120           else if (!err)
1121             any = 1; /* Key is known.  */
1122           else
1123             log_error ("key %s: error getting keyinfo from agent: %s\n",
1124                        keystr_with_sub (keyid, subid), gpg_strerror (err));
1125           xfree (serialno);
1126         }
1127     }
1128   err = 0;
1129   if (!any)
1130     {
1131       tty_printf (_("Key has only stub or on-card key items - "
1132                     "no passphrase to change.\n"));
1133       goto leave;
1134     }
1135
1136   /* Change the passphrase for all keys.  */
1137   for (any = 0, node = keyblock; node; node = node->next)
1138     {
1139       if (node->pkt->pkttype == PKT_PUBLIC_KEY
1140           || node->pkt->pkttype == PKT_PUBLIC_SUBKEY)
1141         {
1142           char *desc;
1143
1144           pk = node->pkt->pkt.public_key;
1145           keyid_from_pk (pk, subid);
1146
1147           xfree (hexgrip);
1148           err = hexkeygrip_from_pk (pk, &hexgrip);
1149           if (err)
1150             goto leave;
1151
1152           desc = gpg_format_keydesc (pk, FORMAT_KEYDESC_NORMAL, 1);
1153           err = agent_passwd (ctrl, hexgrip, desc, &cache_nonce, &passwd_nonce);
1154           xfree (desc);
1155
1156           if (err)
1157             log_log ((gpg_err_code (err) == GPG_ERR_CANCELED
1158                       || gpg_err_code (err) == GPG_ERR_FULLY_CANCELED)
1159                      ? GPGRT_LOG_INFO : GPGRT_LOG_ERROR,
1160                      _("key %s: error changing passphrase: %s\n"),
1161                        keystr_with_sub (keyid, subid),
1162                        gpg_strerror (err));
1163           if (gpg_err_code (err) == GPG_ERR_FULLY_CANCELED)
1164             break;
1165         }
1166     }
1167
1168  leave:
1169   xfree (hexgrip);
1170   xfree (cache_nonce);
1171   xfree (passwd_nonce);
1172   return err;
1173 }
1174
1175
1176 \f
1177 /*
1178  * There are some keys out (due to a bug in gnupg), where the sequence
1179  * of the packets is wrong.  This function fixes that.
1180  * Returns: true if the keyblock has been fixed.
1181  *
1182  * Note:  This function does not work if there is more than one user ID.
1183  */
1184 static int
1185 fix_key_signature_order (KBNODE keyblock)
1186 {
1187   KBNODE node, last, subkey;
1188   int fixed = 0;
1189
1190   /* Locate key signatures of class 0x10..0x13 behind sub key packets.  */
1191   for (subkey = last = NULL, node = keyblock; node;
1192        last = node, node = node->next)
1193     {
1194       switch (node->pkt->pkttype)
1195         {
1196         case PKT_PUBLIC_SUBKEY:
1197         case PKT_SECRET_SUBKEY:
1198           if (!subkey)
1199             subkey = last; /* Actually it is the one before the subkey.  */
1200           break;
1201         case PKT_SIGNATURE:
1202           if (subkey)
1203             {
1204               PKT_signature *sig = node->pkt->pkt.signature;
1205               if (sig->sig_class >= 0x10 && sig->sig_class <= 0x13)
1206                 {
1207                   log_info (_("moving a key signature to the correct place\n"));
1208                   last->next = node->next;
1209                   node->next = subkey->next;
1210                   subkey->next = node;
1211                   node = last;
1212                   fixed = 1;
1213                 }
1214             }
1215           break;
1216         default:
1217           break;
1218         }
1219     }
1220
1221   return fixed;
1222 }
1223
1224
1225 /* Fix various problems in the keyblock.  Returns true if the keyblock
1226    was changed.  Note that a pointer to the keyblock must be given and
1227    the function may change it (i.e. replacing the first node).  */
1228 static int
1229 fix_keyblock (kbnode_t *keyblockp)
1230 {
1231   int changed = 0;
1232
1233   if (fix_key_signature_order (*keyblockp))
1234     changed++;
1235   if (collapse_uids (keyblockp))
1236     changed++;
1237   reorder_keyblock (*keyblockp);
1238   /* If we modified the keyblock, make sure the flags are right. */
1239   if (changed)
1240     merge_keys_and_selfsig (*keyblockp);
1241
1242   return changed;
1243 }
1244
1245
1246 static int
1247 parse_sign_type (const char *str, int *localsig, int *nonrevokesig,
1248                  int *trustsig)
1249 {
1250   const char *p = str;
1251
1252   while (*p)
1253     {
1254       if (ascii_strncasecmp (p, "l", 1) == 0)
1255         {
1256           *localsig = 1;
1257           p++;
1258         }
1259       else if (ascii_strncasecmp (p, "nr", 2) == 0)
1260         {
1261           *nonrevokesig = 1;
1262           p += 2;
1263         }
1264       else if (ascii_strncasecmp (p, "t", 1) == 0)
1265         {
1266           *trustsig = 1;
1267           p++;
1268         }
1269       else
1270         return 0;
1271     }
1272
1273   return 1;
1274 }
1275
1276
1277 \f
1278 /*
1279  * Menu driven key editor.  If seckey_check is true, then a secret key
1280  * that matches username will be looked for.  If it is false, not all
1281  * commands will be available.
1282  *
1283  * Note: to keep track of certain selections we use node->mark MARKBIT_xxxx.
1284  */
1285
1286 /* Need an SK for this command */
1287 #define KEYEDIT_NEED_SK 1
1288 /* Cannot be viewing the SK for this command */
1289 #define KEYEDIT_NOT_SK  2
1290 /* Must be viewing the SK for this command */
1291 #define KEYEDIT_ONLY_SK 4
1292 /* Match the tail of the string */
1293 #define KEYEDIT_TAIL_MATCH 8
1294
1295 enum cmdids
1296 {
1297   cmdNONE = 0,
1298   cmdQUIT, cmdHELP, cmdFPR, cmdLIST, cmdSELUID, cmdCHECK, cmdSIGN,
1299   cmdREVSIG, cmdREVKEY, cmdREVUID, cmdDELSIG, cmdPRIMARY, cmdDEBUG,
1300   cmdSAVE, cmdADDUID, cmdADDPHOTO, cmdDELUID, cmdADDKEY, cmdDELKEY,
1301   cmdADDREVOKER, cmdTOGGLE, cmdSELKEY, cmdPASSWD, cmdTRUST, cmdPREF,
1302   cmdEXPIRE, cmdBACKSIGN,
1303 #ifndef NO_TRUST_MODELS
1304   cmdENABLEKEY, cmdDISABLEKEY,
1305 #endif /*!NO_TRUST_MODELS*/
1306   cmdSHOWPREF,
1307   cmdSETPREF, cmdPREFKS, cmdNOTATION, cmdINVCMD, cmdSHOWPHOTO, cmdUPDTRUST,
1308   cmdCHKTRUST, cmdADDCARDKEY, cmdKEYTOCARD, cmdBKUPTOCARD, cmdCHECKBKUPKEY,
1309   cmdCLEAN, cmdMINIMIZE, cmdGRIP, cmdNOP
1310 };
1311
1312 static struct
1313 {
1314   const char *name;
1315   enum cmdids id;
1316   int flags;
1317   const char *desc;
1318 } cmds[] =
1319 {
1320   { "quit", cmdQUIT, 0, N_("quit this menu")},
1321   { "q", cmdQUIT, 0, NULL},
1322   { "save", cmdSAVE, 0, N_("save and quit")},
1323   { "help", cmdHELP, 0, N_("show this help")},
1324   { "?", cmdHELP, 0, NULL},
1325   { "fpr", cmdFPR, 0, N_("show key fingerprint")},
1326   { "grip", cmdGRIP, 0, N_("show the keygrip")},
1327   { "list", cmdLIST, 0, N_("list key and user IDs")},
1328   { "l", cmdLIST, 0, NULL},
1329   { "uid", cmdSELUID, 0, N_("select user ID N")},
1330   { "key", cmdSELKEY, 0, N_("select subkey N")},
1331   { "check", cmdCHECK, 0, N_("check signatures")},
1332   { "c", cmdCHECK, 0, NULL},
1333   { "cross-certify", cmdBACKSIGN, KEYEDIT_NOT_SK | KEYEDIT_NEED_SK, NULL},
1334   { "backsign", cmdBACKSIGN, KEYEDIT_NOT_SK | KEYEDIT_NEED_SK, NULL},
1335   { "sign", cmdSIGN, KEYEDIT_NOT_SK | KEYEDIT_TAIL_MATCH,
1336     N_("sign selected user IDs [* see below for related commands]")},
1337   { "s", cmdSIGN, KEYEDIT_NOT_SK, NULL},
1338     /* "lsign" and friends will never match since "sign" comes first
1339        and it is a tail match.  They are just here so they show up in
1340        the help menu. */
1341   { "lsign", cmdNOP, 0, N_("sign selected user IDs locally")},
1342   { "tsign", cmdNOP, 0, N_("sign selected user IDs with a trust signature")},
1343   { "nrsign", cmdNOP, 0,
1344     N_("sign selected user IDs with a non-revocable signature")},
1345   { "debug", cmdDEBUG, 0, NULL},
1346   { "adduid", cmdADDUID, KEYEDIT_NOT_SK | KEYEDIT_NEED_SK, N_("add a user ID")},
1347   { "addphoto", cmdADDPHOTO, KEYEDIT_NOT_SK | KEYEDIT_NEED_SK,
1348     N_("add a photo ID")},
1349   { "deluid", cmdDELUID, KEYEDIT_NOT_SK, N_("delete selected user IDs")},
1350     /* delphoto is really deluid in disguise */
1351   { "delphoto", cmdDELUID, KEYEDIT_NOT_SK, NULL},
1352   { "addkey", cmdADDKEY, KEYEDIT_NOT_SK | KEYEDIT_NEED_SK, N_("add a subkey")},
1353 #ifdef ENABLE_CARD_SUPPORT
1354   { "addcardkey", cmdADDCARDKEY, KEYEDIT_NOT_SK | KEYEDIT_NEED_SK,
1355     N_("add a key to a smartcard")},
1356   { "keytocard", cmdKEYTOCARD, KEYEDIT_NEED_SK | KEYEDIT_ONLY_SK,
1357     N_("move a key to a smartcard")},
1358   { "bkuptocard", cmdBKUPTOCARD, KEYEDIT_NEED_SK | KEYEDIT_ONLY_SK,
1359     N_("move a backup key to a smartcard")},
1360   { "checkbkupkey", cmdCHECKBKUPKEY, KEYEDIT_NEED_SK | KEYEDIT_ONLY_SK, NULL},
1361 #endif /*ENABLE_CARD_SUPPORT */
1362   { "delkey", cmdDELKEY, KEYEDIT_NOT_SK, N_("delete selected subkeys")},
1363   { "addrevoker", cmdADDREVOKER, KEYEDIT_NOT_SK | KEYEDIT_NEED_SK,
1364     N_("add a revocation key")},
1365   { "delsig", cmdDELSIG, KEYEDIT_NOT_SK,
1366     N_("delete signatures from the selected user IDs")},
1367   { "expire", cmdEXPIRE, KEYEDIT_NOT_SK | KEYEDIT_NEED_SK,
1368     N_("change the expiration date for the key or selected subkeys")},
1369   { "primary", cmdPRIMARY, KEYEDIT_NOT_SK | KEYEDIT_NEED_SK,
1370     N_("flag the selected user ID as primary")},
1371   { "toggle", cmdTOGGLE, KEYEDIT_NEED_SK, NULL},  /* Dummy command.  */
1372   { "t", cmdTOGGLE, KEYEDIT_NEED_SK, NULL},
1373   { "pref", cmdPREF, KEYEDIT_NOT_SK, N_("list preferences (expert)")},
1374   { "showpref", cmdSHOWPREF, KEYEDIT_NOT_SK, N_("list preferences (verbose)")},
1375   { "setpref", cmdSETPREF, KEYEDIT_NOT_SK | KEYEDIT_NEED_SK,
1376     N_("set preference list for the selected user IDs")},
1377   { "updpref", cmdSETPREF, KEYEDIT_NOT_SK | KEYEDIT_NEED_SK, NULL},
1378   { "keyserver", cmdPREFKS, KEYEDIT_NOT_SK | KEYEDIT_NEED_SK,
1379     N_("set the preferred keyserver URL for the selected user IDs")},
1380   { "notation", cmdNOTATION, KEYEDIT_NOT_SK | KEYEDIT_NEED_SK,
1381     N_("set a notation for the selected user IDs")},
1382   { "passwd", cmdPASSWD, KEYEDIT_NOT_SK | KEYEDIT_NEED_SK,
1383     N_("change the passphrase")},
1384   { "password", cmdPASSWD, KEYEDIT_NOT_SK | KEYEDIT_NEED_SK, NULL},
1385 #ifndef NO_TRUST_MODELS
1386   { "trust", cmdTRUST, KEYEDIT_NOT_SK, N_("change the ownertrust")},
1387 #endif /*!NO_TRUST_MODELS*/
1388   { "revsig", cmdREVSIG, KEYEDIT_NOT_SK,
1389     N_("revoke signatures on the selected user IDs")},
1390   { "revuid", cmdREVUID, KEYEDIT_NOT_SK | KEYEDIT_NEED_SK,
1391     N_("revoke selected user IDs")},
1392   { "revphoto", cmdREVUID, KEYEDIT_NOT_SK | KEYEDIT_NEED_SK, NULL},
1393   { "revkey", cmdREVKEY, KEYEDIT_NOT_SK | KEYEDIT_NEED_SK,
1394     N_("revoke key or selected subkeys")},
1395 #ifndef NO_TRUST_MODELS
1396   { "enable", cmdENABLEKEY, KEYEDIT_NOT_SK, N_("enable key")},
1397   { "disable", cmdDISABLEKEY, KEYEDIT_NOT_SK, N_("disable key")},
1398 #endif /*!NO_TRUST_MODELS*/
1399   { "showphoto", cmdSHOWPHOTO, 0, N_("show selected photo IDs")},
1400   { "clean", cmdCLEAN, KEYEDIT_NOT_SK,
1401     N_("compact unusable user IDs and remove unusable signatures from key")},
1402   { "minimize", cmdMINIMIZE, KEYEDIT_NOT_SK,
1403     N_("compact unusable user IDs and remove all signatures from key")},
1404
1405   { NULL, cmdNONE, 0, NULL}
1406 };
1407
1408
1409 \f
1410 #ifdef HAVE_LIBREADLINE
1411
1412 /*
1413    These two functions are used by readline for command completion.
1414  */
1415
1416 static char *
1417 command_generator (const char *text, int state)
1418 {
1419   static int list_index, len;
1420   const char *name;
1421
1422   /* If this is a new word to complete, initialize now.  This includes
1423      saving the length of TEXT for efficiency, and initializing the
1424      index variable to 0. */
1425   if (!state)
1426     {
1427       list_index = 0;
1428       len = strlen (text);
1429     }
1430
1431   /* Return the next partial match */
1432   while ((name = cmds[list_index].name))
1433     {
1434       /* Only complete commands that have help text */
1435       if (cmds[list_index++].desc && strncmp (name, text, len) == 0)
1436         return strdup (name);
1437     }
1438
1439   return NULL;
1440 }
1441
1442 static char **
1443 keyedit_completion (const char *text, int start, int end)
1444 {
1445   /* If we are at the start of a line, we try and command-complete.
1446      If not, just do nothing for now. */
1447
1448   (void) end;
1449
1450   if (start == 0)
1451     return rl_completion_matches (text, command_generator);
1452
1453   rl_attempted_completion_over = 1;
1454
1455   return NULL;
1456 }
1457 #endif /* HAVE_LIBREADLINE */
1458
1459
1460 \f
1461 /* Main function of the menu driven key editor.  */
1462 void
1463 keyedit_menu (ctrl_t ctrl, const char *username, strlist_t locusr,
1464               strlist_t commands, int quiet, int seckey_check)
1465 {
1466   enum cmdids cmd = 0;
1467   gpg_error_t err = 0;
1468   KBNODE keyblock = NULL;
1469   KEYDB_HANDLE kdbhd = NULL;
1470   int have_seckey = 0;
1471   char *answer = NULL;
1472   int redisplay = 1;
1473   int modified = 0;
1474   int sec_shadowing = 0;
1475   int run_subkey_warnings = 0;
1476   int have_commands = !!commands;
1477
1478   if (opt.command_fd != -1)
1479     ;
1480   else if (opt.batch && !have_commands)
1481     {
1482       log_error (_("can't do this in batch mode\n"));
1483       goto leave;
1484     }
1485
1486 #ifdef HAVE_W32_SYSTEM
1487   /* Due to Windows peculiarities we need to make sure that the
1488      trustdb stale check is done before we open another file
1489      (i.e. by searching for a key).  In theory we could make sure
1490      that the files are closed after use but the open/close caches
1491      inhibits that and flushing the cache right before the stale
1492      check is not easy to implement.  Thus we take the easy way out
1493      and run the stale check as early as possible.  Note, that for
1494      non- W32 platforms it is run indirectly trough a call to
1495      get_validity ().  */
1496   check_trustdb_stale ();
1497 #endif
1498
1499   /* Get the public key */
1500   err = get_pubkey_byname (ctrl, NULL, NULL, username, &keyblock, &kdbhd, 1, 1);
1501   if (err)
1502     {
1503       log_error (_("key \"%s\" not found: %s\n"), username, gpg_strerror (err));
1504       goto leave;
1505     }
1506
1507   if (fix_keyblock (&keyblock))
1508     modified++;
1509
1510   /* See whether we have a matching secret key.  */
1511   if (seckey_check)
1512     {
1513       have_seckey = !agent_probe_any_secret_key (ctrl, keyblock);
1514       if (have_seckey && !quiet)
1515         tty_printf (_("Secret key is available.\n"));
1516     }
1517
1518   /* Main command loop.  */
1519   for (;;)
1520     {
1521       int i, arg_number, photo;
1522       const char *arg_string = "";
1523       char *p;
1524       PKT_public_key *pk = keyblock->pkt->pkt.public_key;
1525
1526       tty_printf ("\n");
1527
1528       if (redisplay && !quiet)
1529         {
1530           /* Show using flags: with_revoker, with_subkeys.  */
1531           show_key_with_all_names (ctrl, NULL, keyblock, 0, 1, 0, 1, 0, 0);
1532           tty_printf ("\n");
1533           redisplay = 0;
1534         }
1535
1536       if (run_subkey_warnings)
1537         {
1538           run_subkey_warnings = 0;
1539           if (!count_selected_keys (keyblock))
1540             subkey_expire_warning (keyblock);
1541         }
1542
1543       do
1544         {
1545           xfree (answer);
1546           if (have_commands)
1547             {
1548               if (commands)
1549                 {
1550                   answer = xstrdup (commands->d);
1551                   commands = commands->next;
1552                 }
1553               else if (opt.batch)
1554                 {
1555                   answer = xstrdup ("quit");
1556                 }
1557               else
1558                 have_commands = 0;
1559             }
1560           if (!have_commands)
1561             {
1562 #ifdef HAVE_LIBREADLINE
1563               tty_enable_completion (keyedit_completion);
1564 #endif
1565               answer = cpr_get_no_help ("keyedit.prompt", GPG_NAME "> ");
1566               cpr_kill_prompt ();
1567               tty_disable_completion ();
1568             }
1569           trim_spaces (answer);
1570         }
1571       while (*answer == '#');
1572
1573       arg_number = 0; /* Here is the init which egcc complains about.  */
1574       photo = 0;      /* Same here. */
1575       if (!*answer)
1576         cmd = cmdLIST;
1577       else if (*answer == CONTROL_D)
1578         cmd = cmdQUIT;
1579       else if (digitp (answer))
1580         {
1581           cmd = cmdSELUID;
1582           arg_number = atoi (answer);
1583         }
1584       else
1585         {
1586           if ((p = strchr (answer, ' ')))
1587             {
1588               *p++ = 0;
1589               trim_spaces (answer);
1590               trim_spaces (p);
1591               arg_number = atoi (p);
1592               arg_string = p;
1593             }
1594
1595           for (i = 0; cmds[i].name; i++)
1596             {
1597               if (cmds[i].flags & KEYEDIT_TAIL_MATCH)
1598                 {
1599                   size_t l = strlen (cmds[i].name);
1600                   size_t a = strlen (answer);
1601                   if (a >= l)
1602                     {
1603                       if (!ascii_strcasecmp (&answer[a - l], cmds[i].name))
1604                         {
1605                           answer[a - l] = '\0';
1606                           break;
1607                         }
1608                     }
1609                 }
1610               else if (!ascii_strcasecmp (answer, cmds[i].name))
1611                 break;
1612             }
1613           if ((cmds[i].flags & KEYEDIT_NEED_SK) && !have_seckey)
1614             {
1615               tty_printf (_("Need the secret key to do this.\n"));
1616               cmd = cmdNOP;
1617             }
1618           else
1619             cmd = cmds[i].id;
1620         }
1621
1622       /* Dispatch the command.  */
1623       switch (cmd)
1624         {
1625         case cmdHELP:
1626           for (i = 0; cmds[i].name; i++)
1627             {
1628               if ((cmds[i].flags & KEYEDIT_NEED_SK) && !have_seckey)
1629                 ; /* Skip those item if we do not have the secret key.  */
1630               else if (cmds[i].desc)
1631                 tty_printf ("%-11s %s\n", cmds[i].name, _(cmds[i].desc));
1632             }
1633
1634           tty_printf ("\n");
1635           tty_printf
1636             (_("* The 'sign' command may be prefixed with an 'l' for local "
1637                "signatures (lsign),\n"
1638                "  a 't' for trust signatures (tsign), an 'nr' for "
1639                "non-revocable signatures\n"
1640                "  (nrsign), or any combination thereof (ltsign, "
1641                "tnrsign, etc.).\n"));
1642           break;
1643
1644         case cmdLIST:
1645           redisplay = 1;
1646           break;
1647
1648         case cmdFPR:
1649           show_key_and_fingerprint
1650             (keyblock, (*arg_string == '*'
1651                         && (!arg_string[1] || spacep (arg_string + 1))));
1652           break;
1653
1654         case cmdGRIP:
1655           show_key_and_grip (keyblock);
1656           break;
1657
1658         case cmdSELUID:
1659           if (strlen (arg_string) == NAMEHASH_LEN * 2)
1660             redisplay = menu_select_uid_namehash (keyblock, arg_string);
1661           else
1662             {
1663               if (*arg_string == '*'
1664                   && (!arg_string[1] || spacep (arg_string + 1)))
1665                 arg_number = -1;        /* Select all. */
1666               redisplay = menu_select_uid (keyblock, arg_number);
1667             }
1668           break;
1669
1670         case cmdSELKEY:
1671           {
1672             if (*arg_string == '*'
1673                 && (!arg_string[1] || spacep (arg_string + 1)))
1674               arg_number = -1;  /* Select all. */
1675             if (menu_select_key (keyblock, arg_number))
1676               redisplay = 1;
1677           }
1678           break;
1679
1680         case cmdCHECK:
1681           check_all_keysigs (keyblock, count_selected_uids (keyblock));
1682           break;
1683
1684         case cmdSIGN:
1685           {
1686             int localsig = 0, nonrevokesig = 0, trustsig = 0, interactive = 0;
1687
1688             if (pk->flags.revoked)
1689               {
1690                 tty_printf (_("Key is revoked."));
1691
1692                 if (opt.expert)
1693                   {
1694                     tty_printf ("  ");
1695                     if (!cpr_get_answer_is_yes
1696                         ("keyedit.sign_revoked.okay",
1697                          _("Are you sure you still want to sign it? (y/N) ")))
1698                       break;
1699                   }
1700                 else
1701                   {
1702                     tty_printf (_("  Unable to sign.\n"));
1703                     break;
1704                   }
1705               }
1706
1707             if (count_uids (keyblock) > 1 && !count_selected_uids (keyblock)
1708                 && !cpr_get_answer_is_yes ("keyedit.sign_all.okay",
1709                                            _("Really sign all user IDs?"
1710                                              " (y/N) ")))
1711               {
1712                 if (opt.interactive)
1713                   interactive = 1;
1714                 else
1715                   {
1716                     tty_printf (_("Hint: Select the user IDs to sign\n"));
1717                     have_commands = 0;
1718                     break;
1719                   }
1720
1721               }
1722             /* What sort of signing are we doing? */
1723             if (!parse_sign_type
1724                 (answer, &localsig, &nonrevokesig, &trustsig))
1725               {
1726                 tty_printf (_("Unknown signature type '%s'\n"), answer);
1727                 break;
1728               }
1729
1730             sign_uids (ctrl, NULL, keyblock, locusr, &modified,
1731                        localsig, nonrevokesig, trustsig, interactive, 0);
1732           }
1733           break;
1734
1735         case cmdDEBUG:
1736           dump_kbnode (keyblock);
1737           break;
1738
1739         case cmdTOGGLE:
1740           /* The toggle command is a leftover from old gpg versions
1741              where we worked with a secret and a public keyring.  It
1742              is not necessary anymore but we keep this command for the
1743              sake of scripts using it.  */
1744           redisplay = 1;
1745           break;
1746
1747         case cmdADDPHOTO:
1748           if (RFC2440)
1749             {
1750               tty_printf (_("This command is not allowed while in %s mode.\n"),
1751                           compliance_option_string ());
1752               break;
1753             }
1754           photo = 1;
1755           /* fall through */
1756         case cmdADDUID:
1757           if (menu_adduid (keyblock, photo, arg_string, NULL))
1758             {
1759               update_trust = 1;
1760               redisplay = 1;
1761               modified = 1;
1762               merge_keys_and_selfsig (keyblock);
1763             }
1764           break;
1765
1766         case cmdDELUID:
1767           {
1768             int n1;
1769
1770             if (!(n1 = count_selected_uids (keyblock)))
1771               tty_printf (_("You must select at least one user ID.\n"));
1772             else if (real_uids_left (keyblock) < 1)
1773               tty_printf (_("You can't delete the last user ID!\n"));
1774             else if (cpr_get_answer_is_yes
1775                      ("keyedit.remove.uid.okay",
1776                       n1 > 1 ? _("Really remove all selected user IDs? (y/N) ")
1777                       :        _("Really remove this user ID? (y/N) ")))
1778               {
1779                 menu_deluid (keyblock);
1780                 redisplay = 1;
1781                 modified = 1;
1782               }
1783           }
1784           break;
1785
1786         case cmdDELSIG:
1787           {
1788             int n1;
1789
1790             if (!(n1 = count_selected_uids (keyblock)))
1791               tty_printf (_("You must select at least one user ID.\n"));
1792             else if (menu_delsig (keyblock))
1793               {
1794                 /* No redisplay here, because it may scroll away some
1795                  * of the status output of this command.  */
1796                 modified = 1;
1797               }
1798           }
1799           break;
1800
1801         case cmdADDKEY:
1802           if (!generate_subkeypair (ctrl, keyblock))
1803             {
1804               redisplay = 1;
1805               modified = 1;
1806               merge_keys_and_selfsig (keyblock);
1807             }
1808           break;
1809
1810 #ifdef ENABLE_CARD_SUPPORT
1811         case cmdADDCARDKEY:
1812           if (!card_generate_subkey (keyblock))
1813             {
1814               redisplay = 1;
1815               modified = 1;
1816               merge_keys_and_selfsig (keyblock);
1817             }
1818           break;
1819
1820         case cmdKEYTOCARD:
1821           {
1822             KBNODE node = NULL;
1823             switch (count_selected_keys (keyblock))
1824               {
1825               case 0:
1826                 if (cpr_get_answer_is_yes
1827                     ("keyedit.keytocard.use_primary",
1828                      /* TRANSLATORS: Please take care: This is about
1829                         moving the key and not about removing it.  */
1830                      _("Really move the primary key? (y/N) ")))
1831                   node = keyblock;
1832                 break;
1833               case 1:
1834                 for (node = keyblock; node; node = node->next)
1835                   {
1836                     if (node->pkt->pkttype == PKT_PUBLIC_SUBKEY
1837                         && node->flag & NODFLG_SELKEY)
1838                       break;
1839                   }
1840                 break;
1841               default:
1842                 tty_printf (_("You must select exactly one key.\n"));
1843                 break;
1844               }
1845             if (node)
1846               {
1847                 PKT_public_key *xxpk = node->pkt->pkt.public_key;
1848                 if (card_store_subkey (node, xxpk ? xxpk->pubkey_usage : 0))
1849                   {
1850                     redisplay = 1;
1851                     sec_shadowing = 1;
1852                   }
1853               }
1854           }
1855           break;
1856
1857         case cmdBKUPTOCARD:
1858         case cmdCHECKBKUPKEY:
1859           log_debug ("FIXME: This needs to be changed\n");
1860           {
1861             /* Ask for a filename, check whether this is really a
1862                backup key as generated by the card generation, parse
1863                that key and store it on card. */
1864             KBNODE node;
1865             const char *fname;
1866             PACKET *pkt;
1867             IOBUF a;
1868
1869             fname = arg_string;
1870             if (!*fname)
1871               {
1872                 tty_printf (_("Command expects a filename argument\n"));
1873                 break;
1874               }
1875
1876             /* Open that file.  */
1877             a = iobuf_open (fname);
1878             if (a && is_secured_file (iobuf_get_fd (a)))
1879               {
1880                 iobuf_close (a);
1881                 a = NULL;
1882                 gpg_err_set_errno (EPERM);
1883               }
1884             if (!a)
1885               {
1886                 tty_printf (_("Can't open '%s': %s\n"),
1887                             fname, strerror (errno));
1888                 break;
1889               }
1890
1891             /* Parse and check that file.  */
1892             pkt = xmalloc (sizeof *pkt);
1893             init_packet (pkt);
1894             err = parse_packet (a, pkt);
1895             iobuf_close (a);
1896             iobuf_ioctl (NULL, IOBUF_IOCTL_INVALIDATE_CACHE, 0, (char *) fname);
1897             if (!err && pkt->pkttype != PKT_SECRET_KEY
1898                 && pkt->pkttype != PKT_SECRET_SUBKEY)
1899               err = GPG_ERR_NO_SECKEY;
1900             if (err)
1901               {
1902                 tty_printf (_("Error reading backup key from '%s': %s\n"),
1903                             fname, gpg_strerror (err));
1904                 free_packet (pkt);
1905                 xfree (pkt);
1906                 break;
1907               }
1908             node = new_kbnode (pkt);
1909
1910             if (cmd == cmdCHECKBKUPKEY)
1911               {
1912                 /* PKT_public_key *sk = node->pkt->pkt.secret_key; */
1913                 /* switch (is_secret_key_protected (sk)) */
1914                 /*   { */
1915                 /*   case 0:    /\* Not protected. *\/ */
1916                 /*     tty_printf (_("This key is not protected.\n")); */
1917                 /*     break; */
1918                 /*   case -1: */
1919                 /*     log_error (_("unknown key protection algorithm\n")); */
1920                 /*     break; */
1921                 /*   default: */
1922                 /*     if (sk->protect.s2k.mode == 1001) */
1923                 /*       tty_printf (_("Secret parts of key" */
1924                 /*                  " are not available.\n")); */
1925                 /*     if (sk->protect.s2k.mode == 1002) */
1926                 /*       tty_printf (_("Secret parts of key" */
1927                 /*                  " are stored on-card.\n")); */
1928                     /* else */
1929                     /*   check_secret_key (sk, 0); */
1930                   /* } */
1931               }
1932             else                /* Store it.  */
1933               {
1934                 if (card_store_subkey (node, 0))
1935                   {
1936                     redisplay = 1;
1937                     sec_shadowing = 1;
1938                   }
1939               }
1940             release_kbnode (node);
1941           }
1942           break;
1943
1944 #endif /* ENABLE_CARD_SUPPORT */
1945
1946         case cmdDELKEY:
1947           {
1948             int n1;
1949
1950             if (!(n1 = count_selected_keys (keyblock)))
1951               tty_printf (_("You must select at least one key.\n"));
1952             else if (!cpr_get_answer_is_yes
1953                      ("keyedit.remove.subkey.okay",
1954                       n1 > 1 ? _("Do you really want to delete the "
1955                                  "selected keys? (y/N) ")
1956                       :  _("Do you really want to delete this key? (y/N) ")))
1957               ;
1958             else
1959               {
1960                 menu_delkey (keyblock);
1961                 redisplay = 1;
1962                 modified = 1;
1963               }
1964           }
1965           break;
1966
1967         case cmdADDREVOKER:
1968           {
1969             int sensitive = 0;
1970
1971             if (ascii_strcasecmp (arg_string, "sensitive") == 0)
1972               sensitive = 1;
1973             if (menu_addrevoker (ctrl, keyblock, sensitive))
1974               {
1975                 redisplay = 1;
1976                 modified = 1;
1977                 merge_keys_and_selfsig (keyblock);
1978               }
1979           }
1980           break;
1981
1982         case cmdREVUID:
1983           {
1984             int n1;
1985
1986             if (!(n1 = count_selected_uids (keyblock)))
1987               tty_printf (_("You must select at least one user ID.\n"));
1988             else if (cpr_get_answer_is_yes
1989                      ("keyedit.revoke.uid.okay",
1990                       n1 > 1 ? _("Really revoke all selected user IDs? (y/N) ")
1991                       :        _("Really revoke this user ID? (y/N) ")))
1992               {
1993                 if (menu_revuid (keyblock))
1994                   {
1995                     modified = 1;
1996                     redisplay = 1;
1997                   }
1998               }
1999           }
2000           break;
2001
2002         case cmdREVKEY:
2003           {
2004             int n1;
2005
2006             if (!(n1 = count_selected_keys (keyblock)))
2007               {
2008                 if (cpr_get_answer_is_yes ("keyedit.revoke.subkey.okay",
2009                                            _("Do you really want to revoke"
2010                                              " the entire key? (y/N) ")))
2011                   {
2012                     if (menu_revkey (keyblock))
2013                       modified = 1;
2014
2015                     redisplay = 1;
2016                   }
2017               }
2018             else if (cpr_get_answer_is_yes ("keyedit.revoke.subkey.okay",
2019                                             n1 > 1 ?
2020                                             _("Do you really want to revoke"
2021                                               " the selected subkeys? (y/N) ")
2022                                             : _("Do you really want to revoke"
2023                                                 " this subkey? (y/N) ")))
2024               {
2025                 if (menu_revsubkey (keyblock))
2026                   modified = 1;
2027
2028                 redisplay = 1;
2029               }
2030
2031             if (modified)
2032               merge_keys_and_selfsig (keyblock);
2033           }
2034           break;
2035
2036         case cmdEXPIRE:
2037           if (menu_expire (keyblock))
2038             {
2039               merge_keys_and_selfsig (keyblock);
2040               run_subkey_warnings = 1;
2041               modified = 1;
2042               redisplay = 1;
2043             }
2044           break;
2045
2046         case cmdBACKSIGN:
2047           if (menu_backsign (keyblock))
2048             {
2049               modified = 1;
2050               redisplay = 1;
2051             }
2052           break;
2053
2054         case cmdPRIMARY:
2055           if (menu_set_primary_uid (keyblock))
2056             {
2057               merge_keys_and_selfsig (keyblock);
2058               modified = 1;
2059               redisplay = 1;
2060             }
2061           break;
2062
2063         case cmdPASSWD:
2064           change_passphrase (ctrl, keyblock);
2065           break;
2066
2067 #ifndef NO_TRUST_MODELS
2068         case cmdTRUST:
2069           if (opt.trust_model == TM_EXTERNAL)
2070             {
2071               tty_printf (_("Owner trust may not be set while "
2072                             "using a user provided trust database\n"));
2073               break;
2074             }
2075
2076           show_key_with_all_names (ctrl, NULL, keyblock, 0, 0, 0, 1, 0, 0);
2077           tty_printf ("\n");
2078           if (edit_ownertrust (find_kbnode (keyblock,
2079                                             PKT_PUBLIC_KEY)->pkt->pkt.
2080                                public_key, 1))
2081             {
2082               redisplay = 1;
2083               /* No real need to set update_trust here as
2084                  edit_ownertrust() calls revalidation_mark()
2085                  anyway. */
2086               update_trust = 1;
2087             }
2088           break;
2089 #endif /*!NO_TRUST_MODELS*/
2090
2091         case cmdPREF:
2092           {
2093             int count = count_selected_uids (keyblock);
2094             assert (keyblock->pkt->pkttype == PKT_PUBLIC_KEY);
2095             show_names (NULL, keyblock, keyblock->pkt->pkt.public_key,
2096                         count ? NODFLG_SELUID : 0, 1);
2097           }
2098           break;
2099
2100         case cmdSHOWPREF:
2101           {
2102             int count = count_selected_uids (keyblock);
2103             assert (keyblock->pkt->pkttype == PKT_PUBLIC_KEY);
2104             show_names (NULL, keyblock, keyblock->pkt->pkt.public_key,
2105                         count ? NODFLG_SELUID : 0, 2);
2106           }
2107           break;
2108
2109         case cmdSETPREF:
2110           {
2111             PKT_user_id *tempuid;
2112
2113             keygen_set_std_prefs (!*arg_string ? "default" : arg_string, 0);
2114
2115             tempuid = keygen_get_std_prefs ();
2116             tty_printf (_("Set preference list to:\n"));
2117             show_prefs (tempuid, NULL, 1);
2118             free_user_id (tempuid);
2119
2120             if (cpr_get_answer_is_yes
2121                 ("keyedit.setpref.okay",
2122                  count_selected_uids (keyblock) ?
2123                  _("Really update the preferences"
2124                    " for the selected user IDs? (y/N) ")
2125                  : _("Really update the preferences? (y/N) ")))
2126               {
2127                 if (menu_set_preferences (keyblock))
2128                   {
2129                     merge_keys_and_selfsig (keyblock);
2130                     modified = 1;
2131                     redisplay = 1;
2132                   }
2133               }
2134           }
2135           break;
2136
2137         case cmdPREFKS:
2138           if (menu_set_keyserver_url (*arg_string ? arg_string : NULL,
2139                                       keyblock))
2140             {
2141               merge_keys_and_selfsig (keyblock);
2142               modified = 1;
2143               redisplay = 1;
2144             }
2145           break;
2146
2147         case cmdNOTATION:
2148           if (menu_set_notation (*arg_string ? arg_string : NULL,
2149                                  keyblock))
2150             {
2151               merge_keys_and_selfsig (keyblock);
2152               modified = 1;
2153               redisplay = 1;
2154             }
2155           break;
2156
2157         case cmdNOP:
2158           break;
2159
2160         case cmdREVSIG:
2161           if (menu_revsig (keyblock))
2162             {
2163               redisplay = 1;
2164               modified = 1;
2165             }
2166           break;
2167
2168 #ifndef NO_TRUST_MODELS
2169         case cmdENABLEKEY:
2170         case cmdDISABLEKEY:
2171           if (enable_disable_key (keyblock, cmd == cmdDISABLEKEY))
2172             {
2173               redisplay = 1;
2174               modified = 1;
2175             }
2176           break;
2177 #endif /*!NO_TRUST_MODELS*/
2178
2179         case cmdSHOWPHOTO:
2180           menu_showphoto (keyblock);
2181           break;
2182
2183         case cmdCLEAN:
2184           if (menu_clean (keyblock, 0))
2185             redisplay = modified = 1;
2186           break;
2187
2188         case cmdMINIMIZE:
2189           if (menu_clean (keyblock, 1))
2190             redisplay = modified = 1;
2191           break;
2192
2193         case cmdQUIT:
2194           if (have_commands)
2195             goto leave;
2196           if (!modified && !sec_shadowing)
2197             goto leave;
2198           if (!cpr_get_answer_is_yes ("keyedit.save.okay",
2199                                       _("Save changes? (y/N) ")))
2200             {
2201               if (cpr_enabled ()
2202                   || cpr_get_answer_is_yes ("keyedit.cancel.okay",
2203                                             _("Quit without saving? (y/N) ")))
2204                 goto leave;
2205               break;
2206             }
2207           /* fall thru */
2208         case cmdSAVE:
2209           if (modified)
2210             {
2211               err = keydb_update_keyblock (kdbhd, keyblock);
2212               if (err)
2213                 {
2214                   log_error (_("update failed: %s\n"), gpg_strerror (err));
2215                   break;
2216                 }
2217             }
2218
2219           if (sec_shadowing)
2220             {
2221               err = agent_scd_learn (NULL, 1);
2222               if (err)
2223                 {
2224                   log_error (_("update failed: %s\n"), gpg_strerror (err));
2225                   break;
2226                 }
2227             }
2228
2229           if (!modified && !sec_shadowing)
2230             tty_printf (_("Key not changed so no update needed.\n"));
2231
2232           if (update_trust)
2233             {
2234               revalidation_mark ();
2235               update_trust = 0;
2236             }
2237           goto leave;
2238
2239         case cmdINVCMD:
2240         default:
2241           tty_printf ("\n");
2242           tty_printf (_("Invalid command  (try \"help\")\n"));
2243           break;
2244         }
2245     } /* End of the main command loop.  */
2246
2247  leave:
2248   release_kbnode (keyblock);
2249   keydb_release (kdbhd);
2250   xfree (answer);
2251 }
2252
2253
2254 /* Change the passphrase of the secret key identified by USERNAME.  */
2255 void
2256 keyedit_passwd (ctrl_t ctrl, const char *username)
2257 {
2258   gpg_error_t err;
2259   PKT_public_key *pk;
2260   kbnode_t keyblock = NULL;
2261
2262   pk = xtrycalloc (1, sizeof *pk);
2263   if (!pk)
2264     {
2265       err = gpg_error_from_syserror ();
2266       goto leave;
2267     }
2268   err = getkey_byname (NULL, pk, username, 1, &keyblock);
2269   if (err)
2270     goto leave;
2271
2272   err = change_passphrase (ctrl, keyblock);
2273
2274 leave:
2275   release_kbnode (keyblock);
2276   free_public_key (pk);
2277   if (err)
2278     {
2279       log_info ("error changing the passphrase for '%s': %s\n",
2280                 username, gpg_strerror (err));
2281       write_status_error ("keyedit.passwd", err);
2282     }
2283   else
2284     write_status_text (STATUS_SUCCESS, "keyedit.passwd");
2285 }
2286
2287
2288 /* Unattended adding of a new keyid.  USERNAME specifies the
2289    key. NEWUID is the new user id to add to the key.  */
2290 void
2291 keyedit_quick_adduid (ctrl_t ctrl, const char *username, const char *newuid)
2292 {
2293   gpg_error_t err;
2294   KEYDB_HANDLE kdbhd = NULL;
2295   KEYDB_SEARCH_DESC desc;
2296   kbnode_t keyblock = NULL;
2297   kbnode_t node;
2298   char *uidstring = NULL;
2299
2300   uidstring = xstrdup (newuid);
2301   trim_spaces (uidstring);
2302   if (!*uidstring)
2303     {
2304       log_error ("%s\n", gpg_strerror (GPG_ERR_INV_USER_ID));
2305       goto leave;
2306     }
2307
2308 #ifdef HAVE_W32_SYSTEM
2309   /* See keyedit_menu for why we need this.  */
2310   check_trustdb_stale ();
2311 #endif
2312
2313   /* Search the key; we don't want the whole getkey stuff here.  */
2314   kdbhd = keydb_new ();
2315   err = classify_user_id (username, &desc, 1);
2316   if (!err)
2317     err = keydb_search (kdbhd, &desc, 1, NULL);
2318   if (!err)
2319     {
2320       err = keydb_get_keyblock (kdbhd, &keyblock);
2321       if (err)
2322         {
2323           log_error (_("error reading keyblock: %s\n"), gpg_strerror (err));
2324           goto leave;
2325         }
2326       /* Now with the keyblock retrieved, search again to detect an
2327          ambiguous specification.  We need to save the found state so
2328          that we can do an update later.  */
2329       keydb_push_found_state (kdbhd);
2330       err = keydb_search (kdbhd, &desc, 1, NULL);
2331       if (!err)
2332         err = gpg_error (GPG_ERR_AMBIGUOUS_NAME);
2333       else if (gpg_err_code (err) == GPG_ERR_NOT_FOUND)
2334         err = 0;
2335       keydb_pop_found_state (kdbhd);
2336
2337       if (!err)
2338         {
2339           /* We require the secret primary key to add a UID.  */
2340           node = find_kbnode (keyblock, PKT_PUBLIC_KEY);
2341           if (!node)
2342             BUG ();
2343           err = agent_probe_secret_key (ctrl, node->pkt->pkt.public_key);
2344         }
2345     }
2346   if (err)
2347     {
2348       log_error (_("secret key \"%s\" not found: %s\n"),
2349                  username, gpg_strerror (err));
2350       goto leave;
2351     }
2352
2353   fix_keyblock (&keyblock);
2354
2355   if (menu_adduid (keyblock, 0, NULL, uidstring))
2356     {
2357       err = keydb_update_keyblock (kdbhd, keyblock);
2358       if (err)
2359         {
2360           log_error (_("update failed: %s\n"), gpg_strerror (err));
2361           goto leave;
2362         }
2363
2364       if (update_trust)
2365         revalidation_mark ();
2366     }
2367
2368  leave:
2369   xfree (uidstring);
2370   release_kbnode (keyblock);
2371   keydb_release (kdbhd);
2372 }
2373
2374
2375 /* Unattended key signing function.  If the key specifified by FPR is
2376    availabale and FPR is the primary fingerprint all user ids of the
2377    user ids of the key are signed using the default signing key.  If
2378    UIDS is an empty list all usable UIDs are signed, if it is not
2379    empty, only those user ids matching one of the entries of the loist
2380    are signed.  With LOCAL being true kthe signatures are marked as
2381    non-exportable.  */
2382 void
2383 keyedit_quick_sign (ctrl_t ctrl, const char *fpr, strlist_t uids,
2384                     strlist_t locusr, int local)
2385 {
2386   gpg_error_t err;
2387   kbnode_t keyblock = NULL;
2388   KEYDB_HANDLE kdbhd = NULL;
2389   int modified = 0;
2390   KEYDB_SEARCH_DESC desc;
2391   PKT_public_key *pk;
2392   kbnode_t node;
2393   strlist_t sl;
2394   int any;
2395
2396 #ifdef HAVE_W32_SYSTEM
2397   /* See keyedit_menu for why we need this.  */
2398   check_trustdb_stale ();
2399 #endif
2400
2401   /* We require a fingerprint because only this uniquely identifies a
2402      key and may thus be used to select a key for unattended key
2403      signing.  */
2404   if (classify_user_id (fpr, &desc, 1)
2405       || !(desc.mode == KEYDB_SEARCH_MODE_FPR
2406            || desc.mode == KEYDB_SEARCH_MODE_FPR16
2407            || desc.mode == KEYDB_SEARCH_MODE_FPR20))
2408     {
2409       log_error (_("\"%s\" is not a fingerprint\n"), fpr);
2410       goto leave;
2411     }
2412   err = get_pubkey_byname (ctrl, NULL, NULL, fpr, &keyblock, &kdbhd, 1, 1);
2413   if (err)
2414     {
2415       log_error (_("key \"%s\" not found: %s\n"), fpr, gpg_strerror (err));
2416       goto leave;
2417     }
2418
2419   /* Check that the primary fingerprint has been given. */
2420   {
2421     byte fprbin[MAX_FINGERPRINT_LEN];
2422     size_t fprlen;
2423
2424     fingerprint_from_pk (keyblock->pkt->pkt.public_key, fprbin, &fprlen);
2425     if (fprlen == 16 && desc.mode == KEYDB_SEARCH_MODE_FPR16
2426         && !memcmp (fprbin, desc.u.fpr, 16))
2427       ;
2428     else if (fprlen == 16 && desc.mode == KEYDB_SEARCH_MODE_FPR
2429              && !memcmp (fprbin, desc.u.fpr, 16)
2430              && !desc.u.fpr[16]
2431              && !desc.u.fpr[17]
2432              && !desc.u.fpr[18]
2433              && !desc.u.fpr[19])
2434       ;
2435     else if (fprlen == 20 && (desc.mode == KEYDB_SEARCH_MODE_FPR20
2436                               || desc.mode == KEYDB_SEARCH_MODE_FPR)
2437              && !memcmp (fprbin, desc.u.fpr, 20))
2438       ;
2439     else
2440       {
2441         log_error (_("\"%s\" is not the primary fingerprint\n"), fpr);
2442         goto leave;
2443       }
2444   }
2445
2446   if (fix_keyblock (&keyblock))
2447     modified++;
2448
2449   /* Give some info in verbose.  */
2450   if (opt.verbose)
2451     {
2452       show_key_with_all_names (ctrl, es_stdout, keyblock, 0,
2453                                1/*with_revoker*/, 1/*with_fingerprint*/,
2454                                0, 0, 1);
2455       es_fflush (es_stdout);
2456     }
2457
2458   pk = keyblock->pkt->pkt.public_key;
2459   if (pk->flags.revoked)
2460     {
2461       if (!opt.verbose)
2462         show_key_with_all_names (ctrl, es_stdout, keyblock, 0, 0, 0, 0, 0, 1);
2463       log_error ("%s%s", _("Key is revoked."), _("  Unable to sign.\n"));
2464       goto leave;
2465     }
2466
2467   /* Set the flags according to the UIDS list.  Fixme: We may want to
2468      use classify_user_id along with dedicated compare functions so
2469      that we match the same way as in the key lookup. */
2470   any = 0;
2471   menu_select_uid (keyblock, 0);   /* Better clear the flags first. */
2472   for (sl=uids; sl; sl = sl->next)
2473     {
2474       for (node = keyblock; node; node = node->next)
2475         {
2476           if (node->pkt->pkttype == PKT_USER_ID)
2477             {
2478               PKT_user_id *uid = node->pkt->pkt.user_id;
2479
2480               if (!uid->attrib_data
2481                   && ascii_memistr (uid->name, uid->len, sl->d))
2482                 {
2483                   node->flag |= NODFLG_SELUID;
2484                   any = 1;
2485                 }
2486             }
2487         }
2488     }
2489
2490   if (uids && !any)
2491     {
2492       if (!opt.verbose)
2493         show_key_with_all_names (ctrl, es_stdout, keyblock, 0, 0, 0, 0, 0, 1);
2494       es_fflush (es_stdout);
2495       log_error ("%s  %s", _("No matching user IDs."), _("Nothing to sign.\n"));
2496       goto leave;
2497     }
2498
2499   /* Sign. */
2500   sign_uids (ctrl, es_stdout, keyblock, locusr, &modified, local, 0, 0, 0, 1);
2501   es_fflush (es_stdout);
2502
2503   if (modified)
2504     {
2505       err = keydb_update_keyblock (kdbhd, keyblock);
2506       if (err)
2507         {
2508           log_error (_("update failed: %s\n"), gpg_strerror (err));
2509           goto leave;
2510         }
2511     }
2512   else
2513     log_info (_("Key not changed so no update needed.\n"));
2514
2515   if (update_trust)
2516     revalidation_mark ();
2517
2518
2519  leave:
2520   release_kbnode (keyblock);
2521   keydb_release (kdbhd);
2522 }
2523
2524
2525 \f
2526 static void
2527 tty_print_notations (int indent, PKT_signature * sig)
2528 {
2529   int first = 1;
2530   struct notation *notation, *nd;
2531
2532   if (indent < 0)
2533     {
2534       first = 0;
2535       indent = -indent;
2536     }
2537
2538   notation = sig_to_notation (sig);
2539
2540   for (nd = notation; nd; nd = nd->next)
2541     {
2542       if (!first)
2543         tty_printf ("%*s", indent, "");
2544       else
2545         first = 0;
2546
2547       tty_print_utf8_string (nd->name, strlen (nd->name));
2548       tty_printf ("=");
2549       tty_print_utf8_string (nd->value, strlen (nd->value));
2550       tty_printf ("\n");
2551     }
2552
2553   free_notation (notation);
2554 }
2555
2556
2557 /*
2558  * Show preferences of a public keyblock.
2559  */
2560 static void
2561 show_prefs (PKT_user_id * uid, PKT_signature * selfsig, int verbose)
2562 {
2563   const prefitem_t fake = { 0, 0 };
2564   const prefitem_t *prefs;
2565   int i;
2566
2567   if (!uid)
2568     return;
2569
2570   if (uid->prefs)
2571     prefs = uid->prefs;
2572   else if (verbose)
2573     prefs = &fake;
2574   else
2575     return;
2576
2577   if (verbose)
2578     {
2579       int any, des_seen = 0, sha1_seen = 0, uncomp_seen = 0;
2580
2581       tty_printf ("     ");
2582       tty_printf (_("Cipher: "));
2583       for (i = any = 0; prefs[i].type; i++)
2584         {
2585           if (prefs[i].type == PREFTYPE_SYM)
2586             {
2587               if (any)
2588                 tty_printf (", ");
2589               any = 1;
2590               /* We don't want to display strings for experimental algos */
2591               if (!openpgp_cipher_test_algo (prefs[i].value)
2592                   && prefs[i].value < 100)
2593                 tty_printf ("%s", openpgp_cipher_algo_name (prefs[i].value));
2594               else
2595                 tty_printf ("[%d]", prefs[i].value);
2596               if (prefs[i].value == CIPHER_ALGO_3DES)
2597                 des_seen = 1;
2598             }
2599         }
2600       if (!des_seen)
2601         {
2602           if (any)
2603             tty_printf (", ");
2604           tty_printf ("%s", openpgp_cipher_algo_name (CIPHER_ALGO_3DES));
2605         }
2606       tty_printf ("\n     ");
2607       tty_printf (_("Digest: "));
2608       for (i = any = 0; prefs[i].type; i++)
2609         {
2610           if (prefs[i].type == PREFTYPE_HASH)
2611             {
2612               if (any)
2613                 tty_printf (", ");
2614               any = 1;
2615               /* We don't want to display strings for experimental algos */
2616               if (!gcry_md_test_algo (prefs[i].value) && prefs[i].value < 100)
2617                 tty_printf ("%s", gcry_md_algo_name (prefs[i].value));
2618               else
2619                 tty_printf ("[%d]", prefs[i].value);
2620               if (prefs[i].value == DIGEST_ALGO_SHA1)
2621                 sha1_seen = 1;
2622             }
2623         }
2624       if (!sha1_seen)
2625         {
2626           if (any)
2627             tty_printf (", ");
2628           tty_printf ("%s", gcry_md_algo_name (DIGEST_ALGO_SHA1));
2629         }
2630       tty_printf ("\n     ");
2631       tty_printf (_("Compression: "));
2632       for (i = any = 0; prefs[i].type; i++)
2633         {
2634           if (prefs[i].type == PREFTYPE_ZIP)
2635             {
2636               const char *s = compress_algo_to_string (prefs[i].value);
2637
2638               if (any)
2639                 tty_printf (", ");
2640               any = 1;
2641               /* We don't want to display strings for experimental algos */
2642               if (s && prefs[i].value < 100)
2643                 tty_printf ("%s", s);
2644               else
2645                 tty_printf ("[%d]", prefs[i].value);
2646               if (prefs[i].value == COMPRESS_ALGO_NONE)
2647                 uncomp_seen = 1;
2648             }
2649         }
2650       if (!uncomp_seen)
2651         {
2652           if (any)
2653             tty_printf (", ");
2654           else
2655             {
2656               tty_printf ("%s", compress_algo_to_string (COMPRESS_ALGO_ZIP));
2657               tty_printf (", ");
2658             }
2659           tty_printf ("%s", compress_algo_to_string (COMPRESS_ALGO_NONE));
2660         }
2661       if (uid->flags.mdc || !uid->flags.ks_modify)
2662         {
2663           tty_printf ("\n     ");
2664           tty_printf (_("Features: "));
2665           any = 0;
2666           if (uid->flags.mdc)
2667             {
2668               tty_printf ("MDC");
2669               any = 1;
2670             }
2671           if (!uid->flags.ks_modify)
2672             {
2673               if (any)
2674                 tty_printf (", ");
2675               tty_printf (_("Keyserver no-modify"));
2676             }
2677         }
2678       tty_printf ("\n");
2679
2680       if (selfsig)
2681         {
2682           const byte *pref_ks;
2683           size_t pref_ks_len;
2684
2685           pref_ks = parse_sig_subpkt (selfsig->hashed,
2686                                       SIGSUBPKT_PREF_KS, &pref_ks_len);
2687           if (pref_ks && pref_ks_len)
2688             {
2689               tty_printf ("     ");
2690               tty_printf (_("Preferred keyserver: "));
2691               tty_print_utf8_string (pref_ks, pref_ks_len);
2692               tty_printf ("\n");
2693             }
2694
2695           if (selfsig->flags.notation)
2696             {
2697               tty_printf ("     ");
2698               tty_printf (_("Notations: "));
2699               tty_print_notations (5 + strlen (_("Notations: ")), selfsig);
2700             }
2701         }
2702     }
2703   else
2704     {
2705       tty_printf ("    ");
2706       for (i = 0; prefs[i].type; i++)
2707         {
2708           tty_printf (" %c%d", prefs[i].type == PREFTYPE_SYM ? 'S' :
2709                       prefs[i].type == PREFTYPE_HASH ? 'H' :
2710                       prefs[i].type == PREFTYPE_ZIP ? 'Z' : '?',
2711                       prefs[i].value);
2712         }
2713       if (uid->flags.mdc)
2714         tty_printf (" [mdc]");
2715       if (!uid->flags.ks_modify)
2716         tty_printf (" [no-ks-modify]");
2717       tty_printf ("\n");
2718     }
2719 }
2720
2721
2722 /* This is the version of show_key_with_all_names used when
2723    opt.with_colons is used.  It prints all available data in a easy to
2724    parse format and does not translate utf8 */
2725 static void
2726 show_key_with_all_names_colon (ctrl_t ctrl, estream_t fp, kbnode_t keyblock)
2727 {
2728   KBNODE node;
2729   int i, j, ulti_hack = 0;
2730   byte pk_version = 0;
2731   PKT_public_key *primary = NULL;
2732   int have_seckey;
2733
2734   if (!fp)
2735     fp = es_stdout;
2736
2737   /* the keys */
2738   for (node = keyblock; node; node = node->next)
2739     {
2740       if (node->pkt->pkttype == PKT_PUBLIC_KEY
2741           || (node->pkt->pkttype == PKT_PUBLIC_SUBKEY))
2742         {
2743           PKT_public_key *pk = node->pkt->pkt.public_key;
2744           u32 keyid[2];
2745
2746           if (node->pkt->pkttype == PKT_PUBLIC_KEY)
2747             {
2748               pk_version = pk->version;
2749               primary = pk;
2750             }
2751
2752           keyid_from_pk (pk, keyid);
2753           have_seckey = !agent_probe_secret_key (ctrl, pk);
2754
2755           if (node->pkt->pkttype == PKT_PUBLIC_KEY)
2756             es_fputs (have_seckey? "sec:" : "pub:", fp);
2757           else
2758             es_fputs (have_seckey? "ssb:" : "sub:", fp);
2759
2760           if (!pk->flags.valid)
2761             es_putc ('i', fp);
2762           else if (pk->flags.revoked)
2763             es_putc ('r', fp);
2764           else if (pk->has_expired)
2765             es_putc ('e', fp);
2766           else if (!(opt.fast_list_mode || opt.no_expensive_trust_checks))
2767             {
2768               int trust = get_validity_info (pk, NULL);
2769               if (trust == 'u')
2770                 ulti_hack = 1;
2771               es_putc (trust, fp);
2772             }
2773
2774           es_fprintf (fp, ":%u:%d:%08lX%08lX:%lu:%lu::",
2775                       nbits_from_pk (pk),
2776                       pk->pubkey_algo,
2777                       (ulong) keyid[0], (ulong) keyid[1],
2778                       (ulong) pk->timestamp, (ulong) pk->expiredate);
2779           if (node->pkt->pkttype == PKT_PUBLIC_KEY
2780               && !(opt.fast_list_mode || opt.no_expensive_trust_checks))
2781             es_putc (get_ownertrust_info (pk), fp);
2782           es_putc (':', fp);
2783           es_putc (':', fp);
2784           es_putc (':', fp);
2785           /* Print capabilities.  */
2786           if ((pk->pubkey_usage & PUBKEY_USAGE_ENC))
2787             es_putc ('e', fp);
2788           if ((pk->pubkey_usage & PUBKEY_USAGE_SIG))
2789             es_putc ('s', fp);
2790           if ((pk->pubkey_usage & PUBKEY_USAGE_CERT))
2791             es_putc ('c', fp);
2792           if ((pk->pubkey_usage & PUBKEY_USAGE_AUTH))
2793             es_putc ('a', fp);
2794           es_putc ('\n', fp);
2795
2796           print_fingerprint (fp, pk, 0);
2797           print_revokers (fp, pk);
2798         }
2799     }
2800
2801   /* the user ids */
2802   i = 0;
2803   for (node = keyblock; node; node = node->next)
2804     {
2805       if (node->pkt->pkttype == PKT_USER_ID)
2806         {
2807           PKT_user_id *uid = node->pkt->pkt.user_id;
2808
2809           ++i;
2810
2811           if (uid->attrib_data)
2812             es_fputs ("uat:", fp);
2813           else
2814             es_fputs ("uid:", fp);
2815
2816           if (uid->is_revoked)
2817             es_fputs ("r::::::::", fp);
2818           else if (uid->is_expired)
2819             es_fputs ("e::::::::", fp);
2820           else if (opt.fast_list_mode || opt.no_expensive_trust_checks)
2821             es_fputs ("::::::::", fp);
2822           else
2823             {
2824               int uid_validity;
2825
2826               if (primary && !ulti_hack)
2827                 uid_validity = get_validity_info (primary, uid);
2828               else
2829                 uid_validity = 'u';
2830               es_fprintf (fp, "%c::::::::", uid_validity);
2831             }
2832
2833           if (uid->attrib_data)
2834             es_fprintf (fp, "%u %lu", uid->numattribs, uid->attrib_len);
2835           else
2836             es_write_sanitized (fp, uid->name, uid->len, ":", NULL);
2837
2838           es_putc (':', fp);
2839           /* signature class */
2840           es_putc (':', fp);
2841           /* capabilities */
2842           es_putc (':', fp);
2843           /* preferences */
2844           if (pk_version > 3 || uid->selfsigversion > 3)
2845             {
2846               const prefitem_t *prefs = uid->prefs;
2847
2848               for (j = 0; prefs && prefs[j].type; j++)
2849                 {
2850                   if (j)
2851                     es_putc (' ', fp);
2852                   es_fprintf (fp,
2853                               "%c%d", prefs[j].type == PREFTYPE_SYM ? 'S' :
2854                               prefs[j].type == PREFTYPE_HASH ? 'H' :
2855                               prefs[j].type == PREFTYPE_ZIP ? 'Z' : '?',
2856                               prefs[j].value);
2857                 }
2858               if (uid->flags.mdc)
2859                 es_fputs (",mdc", fp);
2860               if (!uid->flags.ks_modify)
2861                 es_fputs (",no-ks-modify", fp);
2862             }
2863           es_putc (':', fp);
2864           /* flags */
2865           es_fprintf (fp, "%d,", i);
2866           if (uid->is_primary)
2867             es_putc ('p', fp);
2868           if (uid->is_revoked)
2869             es_putc ('r', fp);
2870           if (uid->is_expired)
2871             es_putc ('e', fp);
2872           if ((node->flag & NODFLG_SELUID))
2873             es_putc ('s', fp);
2874           if ((node->flag & NODFLG_MARK_A))
2875             es_putc ('m', fp);
2876           es_putc (':', fp);
2877           es_putc ('\n', fp);
2878         }
2879     }
2880 }
2881
2882
2883 static void
2884 show_names (estream_t fp,
2885             KBNODE keyblock, PKT_public_key * pk, unsigned int flag,
2886             int with_prefs)
2887 {
2888   KBNODE node;
2889   int i = 0;
2890
2891   for (node = keyblock; node; node = node->next)
2892     {
2893       if (node->pkt->pkttype == PKT_USER_ID && !is_deleted_kbnode (node))
2894         {
2895           PKT_user_id *uid = node->pkt->pkt.user_id;
2896           ++i;
2897           if (!flag || (flag && (node->flag & flag)))
2898             {
2899               if (!(flag & NODFLG_MARK_A) && pk)
2900                 tty_fprintf (fp, "%s ", uid_trust_string_fixed (pk, uid));
2901
2902               if (flag & NODFLG_MARK_A)
2903                 tty_fprintf (fp, "     ");
2904               else if (node->flag & NODFLG_SELUID)
2905                 tty_fprintf (fp, "(%d)* ", i);
2906               else if (uid->is_primary)
2907                 tty_fprintf (fp, "(%d). ", i);
2908               else
2909                 tty_fprintf (fp, "(%d)  ", i);
2910               tty_print_utf8_string2 (fp, uid->name, uid->len, 0);
2911               tty_fprintf (fp, "\n");
2912               if (with_prefs && pk)
2913                 {
2914                   if (pk->version > 3 || uid->selfsigversion > 3)
2915                     {
2916                       PKT_signature *selfsig = NULL;
2917                       KBNODE signode;
2918
2919                       for (signode = node->next;
2920                            signode && signode->pkt->pkttype == PKT_SIGNATURE;
2921                            signode = signode->next)
2922                         {
2923                           if (signode->pkt->pkt.signature->
2924                               flags.chosen_selfsig)
2925                             {
2926                               selfsig = signode->pkt->pkt.signature;
2927                               break;
2928                             }
2929                         }
2930
2931                       show_prefs (uid, selfsig, with_prefs == 2);
2932                     }
2933                   else
2934                     tty_fprintf (fp, _("There are no preferences on a"
2935                                        " PGP 2.x-style user ID.\n"));
2936                 }
2937             }
2938         }
2939     }
2940 }
2941
2942
2943 /*
2944  * Display the key a the user ids, if only_marked is true, do only so
2945  * for user ids with mark A flag set and do not display the index
2946  * number.  If FP is not NULL print to the given stream and not to the
2947  * tty (ignored in with-colons mode).
2948  */
2949 static void
2950 show_key_with_all_names (ctrl_t ctrl, estream_t fp,
2951                          KBNODE keyblock, int only_marked, int with_revoker,
2952                          int with_fpr, int with_subkeys, int with_prefs,
2953                          int nowarn)
2954 {
2955   gpg_error_t err;
2956   kbnode_t node;
2957   int i;
2958   int do_warn = 0;
2959   int have_seckey = 0;
2960   char *serialno = NULL;
2961   PKT_public_key *primary = NULL;
2962   char pkstrbuf[PUBKEY_STRING_SIZE];
2963
2964   if (opt.with_colons)
2965     {
2966       show_key_with_all_names_colon (ctrl, fp, keyblock);
2967       return;
2968     }
2969
2970   /* the keys */
2971   for (node = keyblock; node; node = node->next)
2972     {
2973       if (node->pkt->pkttype == PKT_PUBLIC_KEY
2974           || (with_subkeys && node->pkt->pkttype == PKT_PUBLIC_SUBKEY
2975               && !is_deleted_kbnode (node)))
2976         {
2977           PKT_public_key *pk = node->pkt->pkt.public_key;
2978           const char *otrust = "err";
2979           const char *trust = "err";
2980
2981           if (node->pkt->pkttype == PKT_PUBLIC_KEY)
2982             {
2983               /* do it here, so that debug messages don't clutter the
2984                * output */
2985               static int did_warn = 0;
2986
2987               trust = get_validity_string (pk, NULL);
2988               otrust = get_ownertrust_string (pk);
2989
2990               /* Show a warning once */
2991               if (!did_warn
2992                   && (get_validity (pk, NULL) & TRUST_FLAG_PENDING_CHECK))
2993                 {
2994                   did_warn = 1;
2995                   do_warn = 1;
2996                 }
2997
2998               primary = pk;
2999             }
3000
3001           if (pk->flags.revoked)
3002             {
3003               char *user = get_user_id_string_native (pk->revoked.keyid);
3004               tty_fprintf (fp,
3005                            _("The following key was revoked on"
3006                             " %s by %s key %s\n"),
3007                           revokestr_from_pk (pk),
3008                           gcry_pk_algo_name (pk->revoked.algo), user);
3009               xfree (user);
3010             }
3011
3012           if (with_revoker)
3013             {
3014               if (!pk->revkey && pk->numrevkeys)
3015                 BUG ();
3016               else
3017                 for (i = 0; i < pk->numrevkeys; i++)
3018                   {
3019                     u32 r_keyid[2];
3020                     char *user;
3021                     const char *algo;
3022
3023                     algo = gcry_pk_algo_name (pk->revkey[i].algid);
3024                     keyid_from_fingerprint (pk->revkey[i].fpr,
3025                                             MAX_FINGERPRINT_LEN, r_keyid);
3026
3027                     user = get_user_id_string_native (r_keyid);
3028                     tty_fprintf (fp,
3029                                  _("This key may be revoked by %s key %s"),
3030                                  algo ? algo : "?", user);
3031
3032                     if (pk->revkey[i].class & 0x40)
3033                       {
3034                         tty_fprintf (fp, " ");
3035                         tty_fprintf (fp, _("(sensitive)"));
3036                       }
3037
3038                     tty_fprintf (fp, "\n");
3039                     xfree (user);
3040                   }
3041             }
3042
3043           keyid_from_pk (pk, NULL);
3044
3045           xfree (serialno);
3046           serialno = NULL;
3047           {
3048             char *hexgrip;
3049
3050             err = hexkeygrip_from_pk (pk, &hexgrip);
3051             if (err)
3052               {
3053                 log_error ("error computing a keygrip: %s\n",
3054                            gpg_strerror (err));
3055                 have_seckey = 0;
3056               }
3057             else
3058               have_seckey = !agent_get_keyinfo (ctrl, hexgrip, &serialno);
3059             xfree (hexgrip);
3060           }
3061
3062           tty_fprintf
3063             (fp, "%s%c %s/%s",
3064              node->pkt->pkttype == PKT_PUBLIC_KEY && have_seckey? "sec" :
3065              node->pkt->pkttype == PKT_PUBLIC_KEY ?               "pub" :
3066              have_seckey ?                                        "ssb" :
3067                                                                   "sub",
3068              (node->flag & NODFLG_SELKEY) ? '*' : ' ',
3069              pubkey_string (pk, pkstrbuf, sizeof pkstrbuf),
3070              keystr (pk->keyid));
3071
3072           if (opt.legacy_list_mode)
3073             tty_fprintf (fp, "  ");
3074           else
3075             tty_fprintf (fp, "\n     ");
3076
3077           tty_fprintf (fp, _("created: %s"), datestr_from_pk (pk));
3078           tty_fprintf (fp, "  ");
3079           if (pk->flags.revoked)
3080             tty_fprintf (fp, _("revoked: %s"), revokestr_from_pk (pk));
3081           else if (pk->has_expired)
3082             tty_fprintf (fp, _("expired: %s"), expirestr_from_pk (pk));
3083           else
3084             tty_fprintf (fp, _("expires: %s"), expirestr_from_pk (pk));
3085           tty_fprintf (fp, "  ");
3086           tty_fprintf (fp, _("usage: %s"), usagestr_from_pk (pk, 1));
3087           tty_fprintf (fp, "\n");
3088
3089           if (serialno)
3090             {
3091               /* The agent told us that a secret key is available and
3092                  that it has been stored on a card.  */
3093               tty_fprintf (fp, "%*s%s", opt.legacy_list_mode? 21:5, "",
3094                            _("card-no: "));
3095               if (strlen (serialno) == 32
3096                   && !strncmp (serialno, "D27600012401", 12))
3097                 {
3098                   /* This is an OpenPGP card.  Print the relevant part.  */
3099                   /* Example: D2760001240101010001000003470000 */
3100                   /*                          xxxxyyyyyyyy     */
3101                   tty_fprintf (fp, "%.*s %.*s\n",
3102                                4, serialno+16, 8, serialno+20);
3103                 }
3104               else
3105                 tty_fprintf (fp, "%s\n", serialno);
3106
3107             }
3108           else if (pk->seckey_info
3109               && pk->seckey_info->is_protected
3110               && pk->seckey_info->s2k.mode == 1002)
3111             {
3112               /* FIXME: Check wether this code path is still used.  */
3113               tty_fprintf (fp, "%*s%s", opt.legacy_list_mode? 21:5, "",
3114                            _("card-no: "));
3115               if (pk->seckey_info->ivlen == 16
3116                   && !memcmp (pk->seckey_info->iv,
3117                               "\xD2\x76\x00\x01\x24\x01", 6))
3118                 {
3119                   /* This is an OpenPGP card. */
3120                   for (i = 8; i < 14; i++)
3121                     {
3122                       if (i == 10)
3123                         tty_fprintf (fp, " ");
3124                       tty_fprintf (fp, "%02X", pk->seckey_info->iv[i]);
3125                     }
3126                 }
3127               else
3128                 {
3129                   /* Unknown card: Print all. */
3130                   for (i = 0; i < pk->seckey_info->ivlen; i++)
3131                     tty_fprintf (fp, "%02X", pk->seckey_info->iv[i]);
3132                 }
3133               tty_fprintf (fp, "\n");
3134             }
3135
3136           if (node->pkt->pkttype == PKT_PUBLIC_KEY
3137               || node->pkt->pkttype == PKT_SECRET_KEY)
3138             {
3139               if (opt.trust_model != TM_ALWAYS)
3140                 {
3141                   tty_fprintf (fp, "%*s",
3142                                opt.legacy_list_mode?
3143                                ((int) keystrlen () + 13):5, "");
3144                   /* Ownertrust is only meaningful for the PGP or
3145                      classic trust models */
3146                   if (opt.trust_model == TM_PGP
3147                       || opt.trust_model == TM_CLASSIC)
3148                     {
3149                       int width = 14 - strlen (otrust);
3150                       if (width <= 0)
3151                         width = 1;
3152                       tty_fprintf (fp, _("trust: %s"), otrust);
3153                       tty_fprintf (fp, "%*s", width, "");
3154                     }
3155
3156                   tty_fprintf (fp, _("validity: %s"), trust);
3157                   tty_fprintf (fp, "\n");
3158                 }
3159               if (node->pkt->pkttype == PKT_PUBLIC_KEY
3160                   && (get_ownertrust (pk) & TRUST_FLAG_DISABLED))
3161                 {
3162                   tty_fprintf (fp, "*** ");
3163                   tty_fprintf (fp, _("This key has been disabled"));
3164                   tty_fprintf (fp, "\n");
3165                 }
3166             }
3167
3168           if ((node->pkt->pkttype == PKT_PUBLIC_KEY
3169                || node->pkt->pkttype == PKT_SECRET_KEY) && with_fpr)
3170             {
3171               print_fingerprint (fp, pk, 2);
3172               tty_fprintf (fp, "\n");
3173             }
3174         }
3175     }
3176
3177   show_names (fp,
3178               keyblock, primary, only_marked ? NODFLG_MARK_A : 0, with_prefs);
3179
3180   if (do_warn && !nowarn)
3181     tty_fprintf (fp, _("Please note that the shown key validity"
3182                        " is not necessarily correct\n"
3183                        "unless you restart the program.\n"));
3184
3185   xfree (serialno);
3186 }
3187
3188
3189 /* Display basic key information.  This function is suitable to show
3190    information on the key without any dependencies on the trustdb or
3191    any other internal GnuPG stuff.  KEYBLOCK may either be a public or
3192    a secret key.  This function may be called with KEYBLOCK containing
3193    secret keys and thus the printing of "pub" vs. "sec" does only
3194    depend on the packet type and not by checking with gpg-agent.  */
3195 void
3196 show_basic_key_info (KBNODE keyblock)
3197 {
3198   KBNODE node;
3199   int i;
3200   char pkstrbuf[PUBKEY_STRING_SIZE];
3201
3202   /* The primary key */
3203   for (node = keyblock; node; node = node->next)
3204     {
3205       if (node->pkt->pkttype == PKT_PUBLIC_KEY
3206           || node->pkt->pkttype == PKT_SECRET_KEY)
3207         {
3208           PKT_public_key *pk = node->pkt->pkt.public_key;
3209
3210           /* Note, we use the same format string as in other show
3211              functions to make the translation job easier. */
3212           tty_printf ("%s  %s/%s  ",
3213                       node->pkt->pkttype == PKT_PUBLIC_KEY ? "pub" :
3214                       node->pkt->pkttype == PKT_PUBLIC_SUBKEY ? "sub" :
3215                       node->pkt->pkttype == PKT_SECRET_KEY ? "sec" :"ssb",
3216                       pubkey_string (pk, pkstrbuf, sizeof pkstrbuf),
3217                       keystr_from_pk (pk));
3218           tty_printf (_("created: %s"), datestr_from_pk (pk));
3219           tty_printf ("  ");
3220           tty_printf (_("expires: %s"), expirestr_from_pk (pk));
3221           tty_printf ("\n");
3222           print_fingerprint (NULL, pk, 3);
3223           tty_printf ("\n");
3224         }
3225     }
3226
3227   /* The user IDs. */
3228   for (i = 0, node = keyblock; node; node = node->next)
3229     {
3230       if (node->pkt->pkttype == PKT_USER_ID)
3231         {
3232           PKT_user_id *uid = node->pkt->pkt.user_id;
3233           ++i;
3234
3235           tty_printf ("     ");
3236           if (uid->is_revoked)
3237             tty_printf ("[%s] ", _("revoked"));
3238           else if (uid->is_expired)
3239             tty_printf ("[%s] ", _("expired"));
3240           tty_print_utf8_string (uid->name, uid->len);
3241           tty_printf ("\n");
3242         }
3243     }
3244 }
3245
3246
3247 static void
3248 show_key_and_fingerprint (kbnode_t keyblock, int with_subkeys)
3249 {
3250   kbnode_t node;
3251   PKT_public_key *pk = NULL;
3252   char pkstrbuf[PUBKEY_STRING_SIZE];
3253
3254   for (node = keyblock; node; node = node->next)
3255     {
3256       if (node->pkt->pkttype == PKT_PUBLIC_KEY)
3257         {
3258           pk = node->pkt->pkt.public_key;
3259           tty_printf ("pub   %s/%s %s ",
3260                       pubkey_string (pk, pkstrbuf, sizeof pkstrbuf),
3261                       keystr_from_pk(pk),
3262                       datestr_from_pk (pk));
3263         }
3264       else if (node->pkt->pkttype == PKT_USER_ID)
3265         {
3266           PKT_user_id *uid = node->pkt->pkt.user_id;
3267           tty_print_utf8_string (uid->name, uid->len);
3268           break;
3269         }
3270     }
3271   tty_printf ("\n");
3272   if (pk)
3273     print_fingerprint (NULL, pk, 2);
3274   if (with_subkeys)
3275     {
3276       for (node = keyblock; node; node = node->next)
3277         {
3278           if (node->pkt->pkttype == PKT_PUBLIC_SUBKEY)
3279             {
3280               pk = node->pkt->pkt.public_key;
3281               tty_printf ("sub   %s/%s %s [%s]\n",
3282                           pubkey_string (pk, pkstrbuf, sizeof pkstrbuf),
3283                           keystr_from_pk(pk),
3284                           datestr_from_pk (pk),
3285                           usagestr_from_pk (pk, 0));
3286
3287               print_fingerprint (NULL, pk, 4);
3288             }
3289         }
3290     }
3291 }
3292
3293
3294 /* Show a listing of the primary and its subkeys along with their
3295    keygrips.  */
3296 static void
3297 show_key_and_grip (kbnode_t keyblock)
3298 {
3299   kbnode_t node;
3300   PKT_public_key *pk = NULL;
3301   char pkstrbuf[PUBKEY_STRING_SIZE];
3302   char *hexgrip;
3303
3304   for (node = keyblock; node; node = node->next)
3305     {
3306       if (node->pkt->pkttype == PKT_PUBLIC_KEY
3307           || node->pkt->pkttype == PKT_PUBLIC_SUBKEY)
3308         {
3309           pk = node->pkt->pkt.public_key;
3310           tty_printf ("%s   %s/%s %s [%s]\n",
3311                       node->pkt->pkttype == PKT_PUBLIC_KEY? "pub":"sub",
3312                       pubkey_string (pk, pkstrbuf, sizeof pkstrbuf),
3313                       keystr_from_pk(pk),
3314                       datestr_from_pk (pk),
3315                       usagestr_from_pk (pk, 0));
3316
3317           if (!hexkeygrip_from_pk (pk, &hexgrip))
3318             {
3319               tty_printf ("      Keygrip: %s\n", hexgrip);
3320               xfree (hexgrip);
3321             }
3322         }
3323     }
3324 }
3325
3326
3327 /* Show a warning if no uids on the key have the primary uid flag
3328    set. */
3329 static void
3330 no_primary_warning (KBNODE keyblock)
3331 {
3332   KBNODE node;
3333   int have_primary = 0, uid_count = 0;
3334
3335   /* TODO: if we ever start behaving differently with a primary or
3336      non-primary attribute ID, we will need to check for attributes
3337      here as well. */
3338
3339   for (node = keyblock; node; node = node->next)
3340     {
3341       if (node->pkt->pkttype == PKT_USER_ID
3342           && node->pkt->pkt.user_id->attrib_data == NULL)
3343         {
3344           uid_count++;
3345
3346           if (node->pkt->pkt.user_id->is_primary == 2)
3347             {
3348               have_primary = 1;
3349               break;
3350             }
3351         }
3352     }
3353
3354   if (uid_count > 1 && !have_primary)
3355     log_info (_
3356