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