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