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