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