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