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