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