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