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