5b77ee747eb6d468c7adf6c8bdc584f79d06b190
[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 <https://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 (ctrl, 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   merge_keys_and_selfsig (keyblock);
2936
2937   if (menu_adduid (ctrl, keyblock, 0, NULL, uidstring))
2938     {
2939       err = keydb_update_keyblock (ctrl, kdbhd, keyblock);
2940       if (err)
2941         {
2942           log_error (_("update failed: %s\n"), gpg_strerror (err));
2943           goto leave;
2944         }
2945
2946       if (update_trust)
2947         revalidation_mark ();
2948     }
2949
2950  leave:
2951   xfree (uidstring);
2952   release_kbnode (keyblock);
2953   keydb_release (kdbhd);
2954 }
2955
2956 /* Unattended revocation of a keyid.  USERNAME specifies the
2957    key. UIDTOREV is the user id revoke from the key.  */
2958 void
2959 keyedit_quick_revuid (ctrl_t ctrl, const char *username, const char *uidtorev)
2960 {
2961   gpg_error_t err;
2962   KEYDB_HANDLE kdbhd = NULL;
2963   KEYDB_SEARCH_DESC desc;
2964   kbnode_t keyblock = NULL;
2965   kbnode_t node;
2966   int modified = 0;
2967   size_t revlen;
2968
2969 #ifdef HAVE_W32_SYSTEM
2970   /* See keyedit_menu for why we need this.  */
2971   check_trustdb_stale (ctrl);
2972 #endif
2973
2974   /* Search the key; we don't want the whole getkey stuff here.  */
2975   kdbhd = keydb_new ();
2976   if (!kdbhd)
2977     {
2978       /* Note that keydb_new has already used log_error.  */
2979       goto leave;
2980     }
2981
2982   err = classify_user_id (username, &desc, 1);
2983   if (!err)
2984     err = keydb_search (kdbhd, &desc, 1, NULL);
2985   if (!err)
2986     {
2987       err = keydb_get_keyblock (kdbhd, &keyblock);
2988       if (err)
2989         {
2990           log_error (_("error reading keyblock: %s\n"), gpg_strerror (err));
2991           goto leave;
2992         }
2993       /* Now with the keyblock retrieved, search again to detect an
2994          ambiguous specification.  We need to save the found state so
2995          that we can do an update later.  */
2996       keydb_push_found_state (kdbhd);
2997       err = keydb_search (kdbhd, &desc, 1, NULL);
2998       if (!err)
2999         err = gpg_error (GPG_ERR_AMBIGUOUS_NAME);
3000       else if (gpg_err_code (err) == GPG_ERR_NOT_FOUND)
3001         err = 0;
3002       keydb_pop_found_state (kdbhd);
3003
3004       if (!err)
3005         {
3006           /* We require the secret primary key to revoke a UID.  */
3007           node = find_kbnode (keyblock, PKT_PUBLIC_KEY);
3008           if (!node)
3009             BUG ();
3010           err = agent_probe_secret_key (ctrl, node->pkt->pkt.public_key);
3011         }
3012     }
3013   if (err)
3014     {
3015       log_error (_("secret key \"%s\" not found: %s\n"),
3016                  username, gpg_strerror (err));
3017       goto leave;
3018     }
3019
3020   fix_keyblock (&keyblock);
3021   setup_main_keyids (keyblock);
3022
3023   revlen = strlen (uidtorev);
3024   /* find the right UID */
3025   for (node = keyblock; node; node = node->next)
3026     {
3027       if (node->pkt->pkttype == PKT_USER_ID
3028           && revlen == node->pkt->pkt.user_id->len
3029           && !memcmp (node->pkt->pkt.user_id->name, uidtorev, revlen))
3030         {
3031           struct revocation_reason_info *reason;
3032
3033           reason = get_default_uid_revocation_reason ();
3034           err = core_revuid (ctrl, keyblock, node, reason, &modified);
3035           release_revocation_reason_info (reason);
3036           if (err)
3037             {
3038               log_error (_("User ID revocation failed: %s\n"),
3039                          gpg_strerror (err));
3040               goto leave;
3041             }
3042           err = keydb_update_keyblock (ctrl, kdbhd, keyblock);
3043           if (err)
3044             {
3045               log_error (_("update failed: %s\n"), gpg_strerror (err));
3046               goto leave;
3047             }
3048
3049           if (update_trust)
3050             revalidation_mark ();
3051           goto leave;
3052         }
3053     }
3054
3055  leave:
3056   release_kbnode (keyblock);
3057   keydb_release (kdbhd);
3058 }
3059
3060
3061 /* Find a keyblock by fingerprint because only this uniquely
3062  * identifies a key and may thus be used to select a key for
3063  * unattended subkey creation os key signing.  */
3064 static gpg_error_t
3065 find_by_primary_fpr (ctrl_t ctrl, const char *fpr,
3066                      kbnode_t *r_keyblock, KEYDB_HANDLE *r_kdbhd)
3067 {
3068   gpg_error_t err;
3069   kbnode_t keyblock = NULL;
3070   KEYDB_HANDLE kdbhd = NULL;
3071   KEYDB_SEARCH_DESC desc;
3072   byte fprbin[MAX_FINGERPRINT_LEN];
3073   size_t fprlen;
3074
3075   *r_keyblock = NULL;
3076   *r_kdbhd = NULL;
3077
3078   if (classify_user_id (fpr, &desc, 1)
3079       || !(desc.mode == KEYDB_SEARCH_MODE_FPR
3080            || desc.mode == KEYDB_SEARCH_MODE_FPR16
3081            || desc.mode == KEYDB_SEARCH_MODE_FPR20))
3082     {
3083       log_error (_("\"%s\" is not a fingerprint\n"), fpr);
3084       err = gpg_error (GPG_ERR_INV_NAME);
3085       goto leave;
3086     }
3087   err = get_pubkey_byname (ctrl, NULL, NULL, fpr, &keyblock, &kdbhd, 1, 1);
3088   if (err)
3089     {
3090       log_error (_("key \"%s\" not found: %s\n"), fpr, gpg_strerror (err));
3091       goto leave;
3092     }
3093
3094   /* Check that the primary fingerprint has been given. */
3095   fingerprint_from_pk (keyblock->pkt->pkt.public_key, fprbin, &fprlen);
3096   if (fprlen == 16 && desc.mode == KEYDB_SEARCH_MODE_FPR16
3097       && !memcmp (fprbin, desc.u.fpr, 16))
3098     ;
3099   else if (fprlen == 16 && desc.mode == KEYDB_SEARCH_MODE_FPR
3100            && !memcmp (fprbin, desc.u.fpr, 16)
3101            && !desc.u.fpr[16]
3102            && !desc.u.fpr[17]
3103            && !desc.u.fpr[18]
3104            && !desc.u.fpr[19])
3105     ;
3106   else if (fprlen == 20 && (desc.mode == KEYDB_SEARCH_MODE_FPR20
3107                             || desc.mode == KEYDB_SEARCH_MODE_FPR)
3108            && !memcmp (fprbin, desc.u.fpr, 20))
3109     ;
3110   else
3111     {
3112       log_error (_("\"%s\" is not the primary fingerprint\n"), fpr);
3113       err = gpg_error (GPG_ERR_INV_NAME);
3114       goto leave;
3115     }
3116
3117   *r_keyblock = keyblock;
3118   keyblock = NULL;
3119   *r_kdbhd = kdbhd;
3120   kdbhd = NULL;
3121   err = 0;
3122
3123  leave:
3124   release_kbnode (keyblock);
3125   keydb_release (kdbhd);
3126   return err;
3127 }
3128
3129
3130 /* Unattended key signing function.  If the key specifified by FPR is
3131    available and FPR is the primary fingerprint all user ids of the
3132    key are signed using the default signing key.  If UIDS is an empty
3133    list all usable UIDs are signed, if it is not empty, only those
3134    user ids matching one of the entries of the list are signed.  With
3135    LOCAL being true the signatures are marked as non-exportable.  */
3136 void
3137 keyedit_quick_sign (ctrl_t ctrl, const char *fpr, strlist_t uids,
3138                     strlist_t locusr, int local)
3139 {
3140   gpg_error_t err;
3141   kbnode_t keyblock = NULL;
3142   KEYDB_HANDLE kdbhd = NULL;
3143   int modified = 0;
3144   PKT_public_key *pk;
3145   kbnode_t node;
3146   strlist_t sl;
3147   int any;
3148
3149 #ifdef HAVE_W32_SYSTEM
3150   /* See keyedit_menu for why we need this.  */
3151   check_trustdb_stale (ctrl);
3152 #endif
3153
3154   /* We require a fingerprint because only this uniquely identifies a
3155      key and may thus be used to select a key for unattended key
3156      signing.  */
3157   if (find_by_primary_fpr (ctrl, fpr, &keyblock, &kdbhd))
3158     goto leave;
3159
3160   if (fix_keyblock (&keyblock))
3161     modified++;
3162
3163   /* Give some info in verbose.  */
3164   if (opt.verbose)
3165     {
3166       show_key_with_all_names (ctrl, es_stdout, keyblock, 0,
3167                                1/*with_revoker*/, 1/*with_fingerprint*/,
3168                                0, 0, 1);
3169       es_fflush (es_stdout);
3170     }
3171
3172   pk = keyblock->pkt->pkt.public_key;
3173   if (pk->flags.revoked)
3174     {
3175       if (!opt.verbose)
3176         show_key_with_all_names (ctrl, es_stdout, keyblock, 0, 0, 0, 0, 0, 1);
3177       log_error ("%s%s", _("Key is revoked."), _("  Unable to sign.\n"));
3178       goto leave;
3179     }
3180
3181   /* Set the flags according to the UIDS list.  Fixme: We may want to
3182      use classify_user_id along with dedicated compare functions so
3183      that we match the same way as in the key lookup. */
3184   any = 0;
3185   menu_select_uid (keyblock, 0);   /* Better clear the flags first. */
3186   for (sl=uids; sl; sl = sl->next)
3187     {
3188       const char *name = sl->d;
3189       int count = 0;
3190
3191       sl->flags &= ~(1|2);  /* Clear flags used for error reporting.  */
3192
3193       for (node = keyblock; node; node = node->next)
3194         {
3195           if (node->pkt->pkttype == PKT_USER_ID)
3196             {
3197               PKT_user_id *uid = node->pkt->pkt.user_id;
3198
3199               if (uid->attrib_data)
3200                 ;
3201               else if (*name == '='
3202                        && strlen (name+1) == uid->len
3203                        && !memcmp (uid->name, name + 1, uid->len))
3204                 { /* Exact match - we don't do a check for ambiguity
3205                    * in this case.  */
3206                   node->flag |= NODFLG_SELUID;
3207                   if (any != -1)
3208                     {
3209                       sl->flags |= 1;  /* Report as found.  */
3210                       any = 1;
3211                     }
3212                 }
3213               else if (ascii_memistr (uid->name, uid->len,
3214                                       *name == '*'? name+1:name))
3215                 {
3216                   node->flag |= NODFLG_SELUID;
3217                   if (any != -1)
3218                     {
3219                       sl->flags |= 1;  /* Report as found.  */
3220                       any = 1;
3221                     }
3222                   count++;
3223                 }
3224             }
3225         }
3226
3227       if (count > 1)
3228         {
3229           any = -1;        /* Force failure at end.  */
3230           sl->flags |= 2;  /* Report as ambiguous.  */
3231         }
3232     }
3233
3234   /* Check whether all given user ids were found.  */
3235   for (sl=uids; sl; sl = sl->next)
3236     if (!(sl->flags & 1))
3237       any = -1;  /* That user id was not found.  */
3238
3239   /* Print an error if there was a problem with the user ids.  */
3240   if (uids && any < 1)
3241     {
3242       if (!opt.verbose)
3243         show_key_with_all_names (ctrl, es_stdout, keyblock, 0, 0, 0, 0, 0, 1);
3244       es_fflush (es_stdout);
3245       for (sl=uids; sl; sl = sl->next)
3246         {
3247           if ((sl->flags & 2))
3248             log_info (_("Invalid user ID '%s': %s\n"),
3249                       sl->d, gpg_strerror (GPG_ERR_AMBIGUOUS_NAME));
3250           else if (!(sl->flags & 1))
3251             log_info (_("Invalid user ID '%s': %s\n"),
3252                       sl->d, gpg_strerror (GPG_ERR_NOT_FOUND));
3253         }
3254       log_error ("%s  %s", _("No matching user IDs."), _("Nothing to sign.\n"));
3255       goto leave;
3256     }
3257
3258   /* Sign. */
3259   sign_uids (ctrl, es_stdout, keyblock, locusr, &modified, local, 0, 0, 0, 1);
3260   es_fflush (es_stdout);
3261
3262   if (modified)
3263     {
3264       err = keydb_update_keyblock (ctrl, kdbhd, keyblock);
3265       if (err)
3266         {
3267           log_error (_("update failed: %s\n"), gpg_strerror (err));
3268           goto leave;
3269         }
3270     }
3271   else
3272     log_info (_("Key not changed so no update needed.\n"));
3273
3274   if (update_trust)
3275     revalidation_mark ();
3276
3277
3278  leave:
3279   release_kbnode (keyblock);
3280   keydb_release (kdbhd);
3281 }
3282
3283
3284 /* Unattended subkey creation function.
3285  *
3286  */
3287 void
3288 keyedit_quick_addkey (ctrl_t ctrl, const char *fpr, const char *algostr,
3289                       const char *usagestr, const char *expirestr)
3290 {
3291   gpg_error_t err;
3292   kbnode_t keyblock;
3293   KEYDB_HANDLE kdbhd;
3294   int modified = 0;
3295   PKT_public_key *pk;
3296
3297 #ifdef HAVE_W32_SYSTEM
3298   /* See keyedit_menu for why we need this.  */
3299   check_trustdb_stale (ctrl);
3300 #endif
3301
3302   /* We require a fingerprint because only this uniquely identifies a
3303    * key and may thus be used to select a key for unattended subkey
3304    * creation.  */
3305   if (find_by_primary_fpr (ctrl, fpr, &keyblock, &kdbhd))
3306     goto leave;
3307
3308   if (fix_keyblock (&keyblock))
3309     modified++;
3310
3311   pk = keyblock->pkt->pkt.public_key;
3312   if (pk->flags.revoked)
3313     {
3314       if (!opt.verbose)
3315         show_key_with_all_names (ctrl, es_stdout, keyblock, 0, 0, 0, 0, 0, 1);
3316       log_error ("%s%s", _("Key is revoked."), "\n");
3317       goto leave;
3318     }
3319
3320   /* Create the subkey.  Note that the called function already prints
3321    * an error message. */
3322   if (!generate_subkeypair (ctrl, keyblock, algostr, usagestr, expirestr))
3323     modified = 1;
3324   es_fflush (es_stdout);
3325
3326   /* Store.  */
3327   if (modified)
3328     {
3329       err = keydb_update_keyblock (ctrl, kdbhd, keyblock);
3330       if (err)
3331         {
3332           log_error (_("update failed: %s\n"), gpg_strerror (err));
3333           goto leave;
3334         }
3335     }
3336   else
3337     log_info (_("Key not changed so no update needed.\n"));
3338
3339  leave:
3340   release_kbnode (keyblock);
3341   keydb_release (kdbhd);
3342 }
3343
3344
3345 \f
3346 static void
3347 tty_print_notations (int indent, PKT_signature * sig)
3348 {
3349   int first = 1;
3350   struct notation *notation, *nd;
3351
3352   if (indent < 0)
3353     {
3354       first = 0;
3355       indent = -indent;
3356     }
3357
3358   notation = sig_to_notation (sig);
3359
3360   for (nd = notation; nd; nd = nd->next)
3361     {
3362       if (!first)
3363         tty_printf ("%*s", indent, "");
3364       else
3365         first = 0;
3366
3367       tty_print_utf8_string (nd->name, strlen (nd->name));
3368       tty_printf ("=");
3369       tty_print_utf8_string (nd->value, strlen (nd->value));
3370       tty_printf ("\n");
3371     }
3372
3373   free_notation (notation);
3374 }
3375
3376
3377 /*
3378  * Show preferences of a public keyblock.
3379  */
3380 static void
3381 show_prefs (PKT_user_id * uid, PKT_signature * selfsig, int verbose)
3382 {
3383   const prefitem_t fake = { 0, 0 };
3384   const prefitem_t *prefs;
3385   int i;
3386
3387   if (!uid)
3388     return;
3389
3390   if (uid->prefs)
3391     prefs = uid->prefs;
3392   else if (verbose)
3393     prefs = &fake;
3394   else
3395     return;
3396
3397   if (verbose)
3398     {
3399       int any, des_seen = 0, sha1_seen = 0, uncomp_seen = 0;
3400
3401       tty_printf ("     ");
3402       tty_printf (_("Cipher: "));
3403       for (i = any = 0; prefs[i].type; i++)
3404         {
3405           if (prefs[i].type == PREFTYPE_SYM)
3406             {
3407               if (any)
3408                 tty_printf (", ");
3409               any = 1;
3410               /* We don't want to display strings for experimental algos */
3411               if (!openpgp_cipher_test_algo (prefs[i].value)
3412                   && prefs[i].value < 100)
3413                 tty_printf ("%s", openpgp_cipher_algo_name (prefs[i].value));
3414               else
3415                 tty_printf ("[%d]", prefs[i].value);
3416               if (prefs[i].value == CIPHER_ALGO_3DES)
3417                 des_seen = 1;
3418             }
3419         }
3420       if (!des_seen)
3421         {
3422           if (any)
3423             tty_printf (", ");
3424           tty_printf ("%s", openpgp_cipher_algo_name (CIPHER_ALGO_3DES));
3425         }
3426       tty_printf ("\n     ");
3427       tty_printf (_("Digest: "));
3428       for (i = any = 0; prefs[i].type; i++)
3429         {
3430           if (prefs[i].type == PREFTYPE_HASH)
3431             {
3432               if (any)
3433                 tty_printf (", ");
3434               any = 1;
3435               /* We don't want to display strings for experimental algos */
3436               if (!gcry_md_test_algo (prefs[i].value) && prefs[i].value < 100)
3437                 tty_printf ("%s", gcry_md_algo_name (prefs[i].value));
3438               else
3439                 tty_printf ("[%d]", prefs[i].value);
3440               if (prefs[i].value == DIGEST_ALGO_SHA1)
3441                 sha1_seen = 1;
3442             }
3443         }
3444       if (!sha1_seen)
3445         {
3446           if (any)
3447             tty_printf (", ");
3448           tty_printf ("%s", gcry_md_algo_name (DIGEST_ALGO_SHA1));
3449         }
3450       tty_printf ("\n     ");
3451       tty_printf (_("Compression: "));
3452       for (i = any = 0; prefs[i].type; i++)
3453         {
3454           if (prefs[i].type == PREFTYPE_ZIP)
3455             {
3456               const char *s = compress_algo_to_string (prefs[i].value);
3457
3458               if (any)
3459                 tty_printf (", ");
3460               any = 1;
3461               /* We don't want to display strings for experimental algos */
3462               if (s && prefs[i].value < 100)
3463                 tty_printf ("%s", s);
3464               else
3465                 tty_printf ("[%d]", prefs[i].value);
3466               if (prefs[i].value == COMPRESS_ALGO_NONE)
3467                 uncomp_seen = 1;
3468             }
3469         }
3470       if (!uncomp_seen)
3471         {
3472           if (any)
3473             tty_printf (", ");
3474           else
3475             {
3476               tty_printf ("%s", compress_algo_to_string (COMPRESS_ALGO_ZIP));
3477               tty_printf (", ");
3478             }
3479           tty_printf ("%s", compress_algo_to_string (COMPRESS_ALGO_NONE));
3480         }
3481       if (uid->flags.mdc || !uid->flags.ks_modify)
3482         {
3483           tty_printf ("\n     ");
3484           tty_printf (_("Features: "));
3485           any = 0;
3486           if (uid->flags.mdc)
3487             {
3488               tty_printf ("MDC");
3489               any = 1;
3490             }
3491           if (!uid->flags.ks_modify)
3492             {
3493               if (any)
3494                 tty_printf (", ");
3495               tty_printf (_("Keyserver no-modify"));
3496             }
3497         }
3498       tty_printf ("\n");
3499
3500       if (selfsig)
3501         {
3502           const byte *pref_ks;
3503           size_t pref_ks_len;
3504
3505           pref_ks = parse_sig_subpkt (selfsig->hashed,
3506                                       SIGSUBPKT_PREF_KS, &pref_ks_len);
3507           if (pref_ks && pref_ks_len)
3508             {
3509               tty_printf ("     ");
3510               tty_printf (_("Preferred keyserver: "));
3511               tty_print_utf8_string (pref_ks, pref_ks_len);
3512               tty_printf ("\n");
3513             }
3514
3515           if (selfsig->flags.notation)
3516             {
3517               tty_printf ("     ");
3518               tty_printf (_("Notations: "));
3519               tty_print_notations (5 + strlen (_("Notations: ")), selfsig);
3520             }
3521         }
3522     }
3523   else
3524     {
3525       tty_printf ("    ");
3526       for (i = 0; prefs[i].type; i++)
3527         {
3528           tty_printf (" %c%d", prefs[i].type == PREFTYPE_SYM ? 'S' :
3529                       prefs[i].type == PREFTYPE_HASH ? 'H' :
3530                       prefs[i].type == PREFTYPE_ZIP ? 'Z' : '?',
3531                       prefs[i].value);
3532         }
3533       if (uid->flags.mdc)
3534         tty_printf (" [mdc]");
3535       if (!uid->flags.ks_modify)
3536         tty_printf (" [no-ks-modify]");
3537       tty_printf ("\n");
3538     }
3539 }
3540
3541
3542 /* This is the version of show_key_with_all_names used when
3543    opt.with_colons is used.  It prints all available data in a easy to
3544    parse format and does not translate utf8 */
3545 static void
3546 show_key_with_all_names_colon (ctrl_t ctrl, estream_t fp, kbnode_t keyblock)
3547 {
3548   KBNODE node;
3549   int i, j, ulti_hack = 0;
3550   byte pk_version = 0;
3551   PKT_public_key *primary = NULL;
3552   int have_seckey;
3553
3554   if (!fp)
3555     fp = es_stdout;
3556
3557   /* the keys */
3558   for (node = keyblock; node; node = node->next)
3559     {
3560       if (node->pkt->pkttype == PKT_PUBLIC_KEY
3561           || (node->pkt->pkttype == PKT_PUBLIC_SUBKEY))
3562         {
3563           PKT_public_key *pk = node->pkt->pkt.public_key;
3564           u32 keyid[2];
3565
3566           if (node->pkt->pkttype == PKT_PUBLIC_KEY)
3567             {
3568               pk_version = pk->version;
3569               primary = pk;
3570             }
3571
3572           keyid_from_pk (pk, keyid);
3573           have_seckey = !agent_probe_secret_key (ctrl, pk);
3574
3575           if (node->pkt->pkttype == PKT_PUBLIC_KEY)
3576             es_fputs (have_seckey? "sec:" : "pub:", fp);
3577           else
3578             es_fputs (have_seckey? "ssb:" : "sub:", fp);
3579
3580           if (!pk->flags.valid)
3581             es_putc ('i', fp);
3582           else if (pk->flags.revoked)
3583             es_putc ('r', fp);
3584           else if (pk->has_expired)
3585             es_putc ('e', fp);
3586           else if (!(opt.fast_list_mode || opt.no_expensive_trust_checks))
3587             {
3588               int trust = get_validity_info (ctrl, pk, NULL);
3589               if (trust == 'u')
3590                 ulti_hack = 1;
3591               es_putc (trust, fp);
3592             }
3593
3594           es_fprintf (fp, ":%u:%d:%08lX%08lX:%lu:%lu::",
3595                       nbits_from_pk (pk),
3596                       pk->pubkey_algo,
3597                       (ulong) keyid[0], (ulong) keyid[1],
3598                       (ulong) pk->timestamp, (ulong) pk->expiredate);
3599           if (node->pkt->pkttype == PKT_PUBLIC_KEY
3600               && !(opt.fast_list_mode || opt.no_expensive_trust_checks))
3601             es_putc (get_ownertrust_info (pk), fp);
3602           es_putc (':', fp);
3603           es_putc (':', fp);
3604           es_putc (':', fp);
3605           /* Print capabilities.  */
3606           if ((pk->pubkey_usage & PUBKEY_USAGE_ENC))
3607             es_putc ('e', fp);
3608           if ((pk->pubkey_usage & PUBKEY_USAGE_SIG))
3609             es_putc ('s', fp);
3610           if ((pk->pubkey_usage & PUBKEY_USAGE_CERT))
3611             es_putc ('c', fp);
3612           if ((pk->pubkey_usage & PUBKEY_USAGE_AUTH))
3613             es_putc ('a', fp);
3614           es_putc ('\n', fp);
3615
3616           print_fingerprint (fp, pk, 0);
3617           print_revokers (fp, pk);
3618         }
3619     }
3620
3621   /* the user ids */
3622   i = 0;
3623   for (node = keyblock; node; node = node->next)
3624     {
3625       if (node->pkt->pkttype == PKT_USER_ID)
3626         {
3627           PKT_user_id *uid = node->pkt->pkt.user_id;
3628
3629           ++i;
3630
3631           if (uid->attrib_data)
3632             es_fputs ("uat:", fp);
3633           else
3634             es_fputs ("uid:", fp);
3635
3636           if (uid->is_revoked)
3637             es_fputs ("r::::::::", fp);
3638           else if (uid->is_expired)
3639             es_fputs ("e::::::::", fp);
3640           else if (opt.fast_list_mode || opt.no_expensive_trust_checks)
3641             es_fputs ("::::::::", fp);
3642           else
3643             {
3644               int uid_validity;
3645
3646               if (primary && !ulti_hack)
3647                 uid_validity = get_validity_info (ctrl, primary, uid);
3648               else
3649                 uid_validity = 'u';
3650               es_fprintf (fp, "%c::::::::", uid_validity);
3651             }
3652
3653           if (uid->attrib_data)
3654             es_fprintf (fp, "%u %lu", uid->numattribs, uid->attrib_len);
3655           else
3656             es_write_sanitized (fp, uid->name, uid->len, ":", NULL);
3657
3658           es_putc (':', fp);
3659           /* signature class */
3660           es_putc (':', fp);
3661           /* capabilities */
3662           es_putc (':', fp);
3663           /* preferences */
3664           if (pk_version > 3 || uid->selfsigversion > 3)
3665             {
3666               const prefitem_t *prefs = uid->prefs;
3667
3668               for (j = 0; prefs && prefs[j].type; j++)
3669                 {
3670                   if (j)
3671                     es_putc (' ', fp);
3672                   es_fprintf (fp,
3673                               "%c%d", prefs[j].type == PREFTYPE_SYM ? 'S' :
3674                               prefs[j].type == PREFTYPE_HASH ? 'H' :
3675                               prefs[j].type == PREFTYPE_ZIP ? 'Z' : '?',
3676                               prefs[j].value);
3677                 }
3678               if (uid->flags.mdc)
3679                 es_fputs (",mdc", fp);
3680               if (!uid->flags.ks_modify)
3681                 es_fputs (",no-ks-modify", fp);
3682             }
3683           es_putc (':', fp);
3684           /* flags */
3685           es_fprintf (fp, "%d,", i);
3686           if (uid->is_primary)
3687             es_putc ('p', fp);
3688           if (uid->is_revoked)
3689             es_putc ('r', fp);
3690           if (uid->is_expired)
3691             es_putc ('e', fp);
3692           if ((node->flag & NODFLG_SELUID))
3693             es_putc ('s', fp);
3694           if ((node->flag & NODFLG_MARK_A))
3695             es_putc ('m', fp);
3696           es_putc (':', fp);
3697           if (opt.trust_model == TM_TOFU || opt.trust_model == TM_TOFU_PGP)
3698             {
3699 #ifdef USE_TOFU
3700               enum tofu_policy policy;
3701               if (! tofu_get_policy (ctrl, primary, uid, &policy)
3702                   && policy != TOFU_POLICY_NONE)
3703                 es_fprintf (fp, "%s", tofu_policy_str (policy));
3704 #endif /*USE_TOFU*/
3705             }
3706           es_putc (':', fp);
3707           es_putc ('\n', fp);
3708         }
3709     }
3710 }
3711
3712
3713 static void
3714 show_names (ctrl_t ctrl, estream_t fp,
3715             kbnode_t keyblock, PKT_public_key * pk, unsigned int flag,
3716             int with_prefs)
3717 {
3718   KBNODE node;
3719   int i = 0;
3720
3721   for (node = keyblock; node; node = node->next)
3722     {
3723       if (node->pkt->pkttype == PKT_USER_ID && !is_deleted_kbnode (node))
3724         {
3725           PKT_user_id *uid = node->pkt->pkt.user_id;
3726           ++i;
3727           if (!flag || (flag && (node->flag & flag)))
3728             {
3729               if (!(flag & NODFLG_MARK_A) && pk)
3730                 tty_fprintf (fp, "%s ", uid_trust_string_fixed (ctrl, pk, uid));
3731
3732               if (flag & NODFLG_MARK_A)
3733                 tty_fprintf (fp, "     ");
3734               else if (node->flag & NODFLG_SELUID)
3735                 tty_fprintf (fp, "(%d)* ", i);
3736               else if (uid->is_primary)
3737                 tty_fprintf (fp, "(%d). ", i);
3738               else
3739                 tty_fprintf (fp, "(%d)  ", i);
3740               tty_print_utf8_string2 (fp, uid->name, uid->len, 0);
3741               tty_fprintf (fp, "\n");
3742               if (with_prefs && pk)
3743                 {
3744                   if (pk->version > 3 || uid->selfsigversion > 3)
3745                     {
3746                       PKT_signature *selfsig = NULL;
3747                       KBNODE signode;
3748
3749                       for (signode = node->next;
3750                            signode && signode->pkt->pkttype == PKT_SIGNATURE;
3751                            signode = signode->next)
3752                         {
3753                           if (signode->pkt->pkt.signature->
3754                               flags.chosen_selfsig)
3755                             {
3756                               selfsig = signode->pkt->pkt.signature;
3757                               break;
3758                             }
3759                         }
3760
3761                       show_prefs (uid, selfsig, with_prefs == 2);
3762                     }
3763                   else
3764                     tty_fprintf (fp, _("There are no preferences on a"
3765                                        " PGP 2.x-style user ID.\n"));
3766                 }
3767             }
3768         }
3769     }
3770 }
3771
3772
3773 /*
3774  * Display the key a the user ids, if only_marked is true, do only so
3775  * for user ids with mark A flag set and do not display the index
3776  * number.  If FP is not NULL print to the given stream and not to the
3777  * tty (ignored in with-colons mode).
3778  */
3779 static void
3780 show_key_with_all_names (ctrl_t ctrl, estream_t fp,
3781                          KBNODE keyblock, int only_marked, int with_revoker,
3782                          int with_fpr, int with_subkeys, int with_prefs,
3783                          int nowarn)
3784 {
3785   gpg_error_t err;
3786   kbnode_t node;
3787   int i;
3788   int do_warn = 0;
3789   int have_seckey = 0;
3790   char *serialno = NULL;
3791   PKT_public_key *primary = NULL;
3792   char pkstrbuf[PUBKEY_STRING_SIZE];
3793
3794   if (opt.with_colons)
3795     {
3796       show_key_with_all_names_colon (ctrl, fp, keyblock);
3797       return;
3798     }
3799
3800   /* the keys */
3801   for (node = keyblock; node; node = node->next)
3802     {
3803       if (node->pkt->pkttype == PKT_PUBLIC_KEY
3804           || (with_subkeys && node->pkt->pkttype == PKT_PUBLIC_SUBKEY
3805               && !is_deleted_kbnode (node)))
3806         {
3807           PKT_public_key *pk = node->pkt->pkt.public_key;
3808           const char *otrust = "err";
3809           const char *trust = "err";
3810
3811           if (node->pkt->pkttype == PKT_PUBLIC_KEY)
3812             {
3813               /* do it here, so that debug messages don't clutter the
3814                * output */
3815               static int did_warn = 0;
3816
3817               trust = get_validity_string (ctrl, pk, NULL);
3818               otrust = get_ownertrust_string (pk);
3819
3820               /* Show a warning once */
3821               if (!did_warn
3822                   && (get_validity (ctrl, pk, NULL, NULL, 0)
3823                       & TRUST_FLAG_PENDING_CHECK))
3824                 {
3825                   did_warn = 1;
3826                   do_warn = 1;
3827                 }
3828
3829               primary = pk;
3830             }
3831
3832           if (pk->flags.revoked)
3833             {
3834               char *user = get_user_id_string_native (pk->revoked.keyid);
3835               tty_fprintf (fp,
3836                            _("The following key was revoked on"
3837                             " %s by %s key %s\n"),
3838                           revokestr_from_pk (pk),
3839                           gcry_pk_algo_name (pk->revoked.algo), user);
3840               xfree (user);
3841             }
3842
3843           if (with_revoker)
3844             {
3845               if (!pk->revkey && pk->numrevkeys)
3846                 BUG ();
3847               else
3848                 for (i = 0; i < pk->numrevkeys; i++)
3849                   {
3850                     u32 r_keyid[2];
3851                     char *user;
3852                     const char *algo;
3853
3854                     algo = gcry_pk_algo_name (pk->revkey[i].algid);
3855                     keyid_from_fingerprint (pk->revkey[i].fpr,
3856                                             MAX_FINGERPRINT_LEN, r_keyid);
3857
3858                     user = get_user_id_string_native (r_keyid);
3859                     tty_fprintf (fp,
3860                                  _("This key may be revoked by %s key %s"),
3861                                  algo ? algo : "?", user);
3862
3863                     if (pk->revkey[i].class & 0x40)
3864                       {
3865                         tty_fprintf (fp, " ");
3866                         tty_fprintf (fp, _("(sensitive)"));
3867                       }
3868
3869                     tty_fprintf (fp, "\n");
3870                     xfree (user);
3871                   }
3872             }
3873
3874           keyid_from_pk (pk, NULL);
3875
3876           xfree (serialno);
3877           serialno = NULL;
3878           {
3879             char *hexgrip;
3880
3881             err = hexkeygrip_from_pk (pk, &hexgrip);
3882             if (err)
3883               {
3884                 log_error ("error computing a keygrip: %s\n",
3885                            gpg_strerror (err));
3886                 have_seckey = 0;
3887               }
3888             else
3889               have_seckey = !agent_get_keyinfo (ctrl, hexgrip, &serialno, NULL);
3890             xfree (hexgrip);
3891           }
3892
3893           tty_fprintf
3894             (fp, "%s%c %s/%s",
3895              node->pkt->pkttype == PKT_PUBLIC_KEY && have_seckey? "sec" :
3896              node->pkt->pkttype == PKT_PUBLIC_KEY ?               "pub" :
3897              have_seckey ?                                        "ssb" :
3898                                                                   "sub",
3899              (node->flag & NODFLG_SELKEY) ? '*' : ' ',
3900              pubkey_string (pk, pkstrbuf, sizeof pkstrbuf),
3901              keystr (pk->keyid));
3902
3903           if (opt.legacy_list_mode)
3904             tty_fprintf (fp, "  ");
3905           else
3906             tty_fprintf (fp, "\n     ");
3907
3908           tty_fprintf (fp, _("created: %s"), datestr_from_pk (pk));
3909           tty_fprintf (fp, "  ");
3910           if (pk->flags.revoked)
3911