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