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