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