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