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