gpg: Add commands "fpr *" and "grip" to --edit-key.
[gnupg.git] / g10 / keylist.c
1 /* keylist.c - Print information about OpenPGP keys
2  * Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006,
3  *               2008, 2010, 2012 Free Software Foundation, Inc.
4  * Copyright (C) 2013, 2014  Werner Koch
5  *
6  * This file is part of GnuPG.
7  *
8  * GnuPG is free software; you can redistribute it and/or modify
9  * it under the terms of the GNU General Public License as published by
10  * the Free Software Foundation; either version 3 of the License, or
11  * (at your option) any later version.
12  *
13  * GnuPG is distributed in the hope that it will be useful,
14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
16  * GNU General Public License for more details.
17  *
18  * You should have received a copy of the GNU General Public License
19  * along with this program; if not, see <http://www.gnu.org/licenses/>.
20  */
21
22 #include <config.h>
23 #include <stdio.h>
24 #include <stdlib.h>
25 #include <string.h>
26 #include <errno.h>
27 #include <assert.h>
28 #ifdef HAVE_DOSISH_SYSTEM
29 #include <fcntl.h>              /* for setmode() */
30 #endif
31
32 #include "gpg.h"
33 #include "options.h"
34 #include "packet.h"
35 #include "status.h"
36 #include "keydb.h"
37 #include "photoid.h"
38 #include "util.h"
39 #include "ttyio.h"
40 #include "trustdb.h"
41 #include "main.h"
42 #include "i18n.h"
43 #include "status.h"
44 #include "call-agent.h"
45 #include "mbox-util.h"
46
47
48 static void list_all (int, int);
49 static void list_one (strlist_t names, int secret, int mark_secret);
50 static void locate_one (ctrl_t ctrl, strlist_t names);
51 static void print_card_serialno (const char *serialno);
52
53 struct keylist_context
54 {
55   int check_sigs;  /* If set signatures shall be verified.  */
56   int good_sigs;   /* Counter used if CHECK_SIGS is set.  */
57   int inv_sigs;    /* Counter used if CHECK_SIGS is set.  */
58   int no_key;      /* Counter used if CHECK_SIGS is set.  */
59   int oth_err;     /* Counter used if CHECK_SIGS is set.  */
60 };
61
62
63 static void list_keyblock (kbnode_t keyblock, int secret, int has_secret,
64                            int fpr, struct keylist_context *listctx);
65
66
67 /* The stream used to write attribute packets to.  */
68 static estream_t attrib_fp;
69
70
71 /* Release resources from a keylist context.  */
72 static void
73 keylist_context_release (struct keylist_context *listctx)
74 {
75   (void)listctx; /* Nothing to release.  */
76 }
77
78
79 /* List the keys.  If list is NULL, all available keys are listed.
80    With LOCATE_MODE set the locate algorithm is used to find a
81    key.  */
82 void
83 public_key_list (ctrl_t ctrl, strlist_t list, int locate_mode)
84 {
85 #ifndef NO_TRUST_MODELS
86   if (opt.with_colons)
87     {
88       byte trust_model, marginals, completes, cert_depth, min_cert_level;
89       ulong created, nextcheck;
90
91       read_trust_options (&trust_model, &created, &nextcheck,
92                           &marginals, &completes, &cert_depth, &min_cert_level);
93
94       es_fprintf (es_stdout, "tru:");
95
96       if (nextcheck && nextcheck <= make_timestamp ())
97         es_fprintf (es_stdout, "o");
98       if (trust_model != opt.trust_model)
99         es_fprintf (es_stdout, "t");
100       if (opt.trust_model == TM_PGP || opt.trust_model == TM_CLASSIC)
101         {
102           if (marginals != opt.marginals_needed)
103             es_fprintf (es_stdout, "m");
104           if (completes != opt.completes_needed)
105             es_fprintf (es_stdout, "c");
106           if (cert_depth != opt.max_cert_depth)
107             es_fprintf (es_stdout, "d");
108           if (min_cert_level != opt.min_cert_level)
109             es_fprintf (es_stdout, "l");
110         }
111
112       es_fprintf (es_stdout, ":%d:%lu:%lu", trust_model, created, nextcheck);
113
114       /* Only show marginals, completes, and cert_depth in the classic
115          or PGP trust models since they are not meaningful
116          otherwise. */
117
118       if (trust_model == TM_PGP || trust_model == TM_CLASSIC)
119         es_fprintf (es_stdout, ":%d:%d:%d", marginals, completes, cert_depth);
120       es_fprintf (es_stdout, "\n");
121     }
122 #endif /*!NO_TRUST_MODELS*/
123
124   /* We need to do the stale check right here because it might need to
125      update the keyring while we already have the keyring open.  This
126      is very bad for W32 because of a sharing violation. For real OSes
127      it might lead to false results if we are later listing a keyring
128      which is associated with the inode of a deleted file.  */
129   check_trustdb_stale ();
130
131   if (locate_mode)
132     locate_one (ctrl, list);
133   else if (!list)
134     list_all (0, opt.with_secret);
135   else
136     list_one (list, 0, opt.with_secret);
137 }
138
139
140 void
141 secret_key_list (ctrl_t ctrl, strlist_t list)
142 {
143   (void)ctrl;
144
145   check_trustdb_stale ();
146
147   if (!list)
148     list_all (1, 0);
149   else                          /* List by user id */
150     list_one (list, 1, 0);
151 }
152
153 void
154 print_seckey_info (PKT_public_key *pk)
155 {
156   u32 keyid[2];
157   char *p;
158   char pkstrbuf[PUBKEY_STRING_SIZE];
159
160   keyid_from_pk (pk, keyid);
161   p = get_user_id_native (keyid);
162
163   tty_printf ("\nsec  %s/%s %s %s\n",
164               pubkey_string (pk, pkstrbuf, sizeof pkstrbuf),
165               keystr (keyid), datestr_from_pk (pk), p);
166
167   xfree (p);
168 }
169
170 /* Print information about the public key.  With FP passed as NULL,
171    the tty output interface is used, otherwise output is directted to
172    the given stream.  */
173 void
174 print_pubkey_info (estream_t fp, PKT_public_key *pk)
175 {
176   u32 keyid[2];
177   char *p;
178   char pkstrbuf[PUBKEY_STRING_SIZE];
179
180   keyid_from_pk (pk, keyid);
181
182   /* If the pk was chosen by a particular user ID, that is the one to
183      print.  */
184   if (pk->user_id)
185     p = utf8_to_native (pk->user_id->name, pk->user_id->len, 0);
186   else
187     p = get_user_id_native (keyid);
188
189   if (fp)
190     tty_printf ("\n");
191   tty_fprintf (fp, "%s  %s/%s %s %s\n",
192                pk->flags.primary? "pub":"sub",
193                pubkey_string (pk, pkstrbuf, sizeof pkstrbuf),
194                keystr (keyid), datestr_from_pk (pk), p);
195   xfree (p);
196 }
197
198
199 /* Print basic information of a secret key including the card serial
200    number information.  */
201 #ifdef ENABLE_CARD_SUPPORT
202 void
203 print_card_key_info (estream_t fp, kbnode_t keyblock)
204 {
205   kbnode_t node;
206   char *hexgrip;
207   char *serialno;
208   int s2k_char;
209   char pkstrbuf[PUBKEY_STRING_SIZE];
210   int indent;
211
212   for (node = keyblock; node; node = node->next)
213     {
214       if (node->pkt->pkttype == PKT_PUBLIC_KEY
215           || node->pkt->pkttype == PKT_PUBLIC_SUBKEY)
216         {
217           int rc;
218           PKT_public_key *pk = node->pkt->pkt.public_key;
219
220           serialno = NULL;
221           rc = hexkeygrip_from_pk (pk, &hexgrip);
222           if (rc)
223             {
224               log_error ("error computing a keygrip: %s\n", gpg_strerror (rc));
225               s2k_char = '?';
226             }
227           else if (!agent_get_keyinfo (NULL, hexgrip, &serialno))
228             s2k_char = serialno? '>':' ';
229           else
230             s2k_char = '#';  /* Key not found.  */
231
232           tty_fprintf (fp, "%s%c  %s/%s  %n",
233                        node->pkt->pkttype == PKT_PUBLIC_KEY ? "sec" : "ssb",
234                        s2k_char,
235                        pubkey_string (pk, pkstrbuf, sizeof pkstrbuf),
236                        keystr_from_pk (pk),
237                        &indent);
238           tty_fprintf (fp, _("created: %s"), datestr_from_pk (pk));
239           tty_fprintf (fp, "  ");
240           tty_fprintf (fp, _("expires: %s"), expirestr_from_pk (pk));
241           if (serialno)
242             {
243               tty_fprintf (fp, "\n%*s%s", indent, "", _("card-no: "));
244               if (strlen (serialno) == 32
245                   && !strncmp (serialno, "D27600012401", 12))
246                 {
247                   /* This is an OpenPGP card.  Print the relevant part.  */
248                   /* Example: D2760001240101010001000003470000 */
249                   /*                          xxxxyyyyyyyy     */
250                   tty_fprintf (fp, "%.*s %.*s", 4, serialno+16, 8, serialno+20);
251                 }
252               else
253                 tty_fprintf (fp, "%s", serialno);
254             }
255           tty_fprintf (fp, "\n");
256           xfree (hexgrip);
257           xfree (serialno);
258         }
259     }
260 }
261 #endif /*ENABLE_CARD_SUPPORT*/
262
263
264 /* Flags = 0x01 hashed 0x02 critical.  */
265 static void
266 status_one_subpacket (sigsubpkttype_t type, size_t len, int flags,
267                       const byte * buf)
268 {
269   char status[40];
270
271   /* Don't print these. */
272   if (len > 256)
273     return;
274
275   snprintf (status, sizeof status,
276             "%d %u %u ", type, flags, (unsigned int) len);
277
278   write_status_text_and_buffer (STATUS_SIG_SUBPACKET, status, buf, len, 0);
279 }
280
281
282 /* Print a policy URL.  Allowed values for MODE are:
283  *   0 - print to stdout.
284  *   1 - use log_info and emit status messages.
285  *   2 - emit only status messages.
286  */
287 void
288 show_policy_url (PKT_signature * sig, int indent, int mode)
289 {
290   const byte *p;
291   size_t len;
292   int seq = 0, crit;
293   estream_t fp = mode ? log_get_stream () : es_stdout;
294
295   while ((p =
296           enum_sig_subpkt (sig->hashed, SIGSUBPKT_POLICY, &len, &seq, &crit)))
297     {
298       if (mode != 2)
299         {
300           int i;
301           const char *str;
302
303           for (i = 0; i < indent; i++)
304             es_putc (' ', fp);
305
306           if (crit)
307             str = _("Critical signature policy: ");
308           else
309             str = _("Signature policy: ");
310           if (mode)
311             log_info ("%s", str);
312           else
313             es_fprintf (fp, "%s", str);
314           print_utf8_buffer (fp, p, len);
315           es_fprintf (fp, "\n");
316         }
317
318       if (mode)
319         write_status_buffer (STATUS_POLICY_URL, p, len, 0);
320     }
321 }
322
323
324 /*
325   mode=0 for stdout.
326   mode=1 for log_info + status messages
327   mode=2 for status messages only
328 */
329 /* TODO: use this */
330 void
331 show_keyserver_url (PKT_signature * sig, int indent, int mode)
332 {
333   const byte *p;
334   size_t len;
335   int seq = 0, crit;
336   estream_t fp = mode ? log_get_stream () : es_stdout;
337
338   while ((p =
339           enum_sig_subpkt (sig->hashed, SIGSUBPKT_PREF_KS, &len, &seq,
340                            &crit)))
341     {
342       if (mode != 2)
343         {
344           int i;
345           const char *str;
346
347           for (i = 0; i < indent; i++)
348             es_putc (' ', es_stdout);
349
350           if (crit)
351             str = _("Critical preferred keyserver: ");
352           else
353             str = _("Preferred keyserver: ");
354           if (mode)
355             log_info ("%s", str);
356           else
357             es_fprintf (es_stdout, "%s", str);
358           print_utf8_buffer (fp, p, len);
359           es_fprintf (fp, "\n");
360         }
361
362       if (mode)
363         status_one_subpacket (SIGSUBPKT_PREF_KS, len,
364                               (crit ? 0x02 : 0) | 0x01, p);
365     }
366 }
367
368 /*
369   mode=0 for stdout.
370   mode=1 for log_info + status messages
371   mode=2 for status messages only
372
373   Defined bits in WHICH:
374     1 == standard notations
375     2 == user notations
376 */
377 void
378 show_notation (PKT_signature * sig, int indent, int mode, int which)
379 {
380   estream_t fp = mode ? log_get_stream () : es_stdout;
381   struct notation *nd, *notations;
382
383   if (which == 0)
384     which = 3;
385
386   notations = sig_to_notation (sig);
387
388   /* There may be multiple notations in the same sig. */
389   for (nd = notations; nd; nd = nd->next)
390     {
391       if (mode != 2)
392         {
393           int has_at = !!strchr (nd->name, '@');
394
395           if ((which & 1 && !has_at) || (which & 2 && has_at))
396             {
397               int i;
398               const char *str;
399
400               for (i = 0; i < indent; i++)
401                 es_putc (' ', es_stdout);
402
403               if (nd->flags.critical)
404                 str = _("Critical signature notation: ");
405               else
406                 str = _("Signature notation: ");
407               if (mode)
408                 log_info ("%s", str);
409               else
410                 es_fprintf (es_stdout, "%s", str);
411               /* This is all UTF8 */
412               print_utf8_buffer (fp, nd->name, strlen (nd->name));
413               es_fprintf (fp, "=");
414               print_utf8_buffer (fp, nd->value, strlen (nd->value));
415               /* (We need to use log_printf so that the next call to a
416                   log function does not insert an extra LF.)  */
417               if (mode)
418                 log_printf ("\n");
419               else
420                 es_putc ('\n', fp);
421             }
422         }
423
424       if (mode)
425         {
426           write_status_buffer (STATUS_NOTATION_NAME,
427                                nd->name, strlen (nd->name), 0);
428           write_status_buffer (STATUS_NOTATION_DATA,
429                                nd->value, strlen (nd->value), 50);
430         }
431     }
432
433   free_notation (notations);
434 }
435
436
437 static void
438 print_signature_stats (struct keylist_context *s)
439 {
440   if (!s->check_sigs)
441     return;  /* Signature checking was not requested.  */
442
443   if (s->good_sigs == 1)
444     log_info (_("1 good signature\n"));
445   else if (s->good_sigs)
446     log_info (_("%d good signatures\n"), s->good_sigs);
447
448   if (s->inv_sigs == 1)
449     log_info (_("1 bad signature\n"));
450   else if (s->inv_sigs)
451     log_info (_("%d bad signatures\n"), s->inv_sigs);
452
453   if (s->no_key == 1)
454     log_info (_("1 signature not checked due to a missing key\n"));
455   else if (s->no_key)
456     log_info (_("%d signatures not checked due to missing keys\n"), s->no_key);
457
458   if (s->oth_err == 1)
459     log_info (_("1 signature not checked due to an error\n"));
460   else if (s->oth_err)
461     log_info (_("%d signatures not checked due to errors\n"), s->oth_err);
462 }
463
464
465 /* List all keys.  If SECRET is true only secret keys are listed.  If
466    MARK_SECRET is true secret keys are indicated in a public key
467    listing.  */
468 static void
469 list_all (int secret, int mark_secret)
470 {
471   KEYDB_HANDLE hd;
472   KBNODE keyblock = NULL;
473   int rc = 0;
474   int any_secret;
475   const char *lastresname, *resname;
476   struct keylist_context listctx;
477
478   memset (&listctx, 0, sizeof (listctx));
479   if (opt.check_sigs)
480     listctx.check_sigs = 1;
481
482   hd = keydb_new ();
483   if (!hd)
484     rc = gpg_error (GPG_ERR_GENERAL);
485   else
486     rc = keydb_search_first (hd);
487   if (rc)
488     {
489       if (gpg_err_code (rc) != GPG_ERR_NOT_FOUND)
490         log_error ("keydb_search_first failed: %s\n", gpg_strerror (rc));
491       goto leave;
492     }
493
494   lastresname = NULL;
495   do
496     {
497       rc = keydb_get_keyblock (hd, &keyblock);
498       if (rc)
499         {
500           if (gpg_err_code (rc) == GPG_ERR_LEGACY_KEY)
501             continue;  /* Skip legacy keys.  */
502           log_error ("keydb_get_keyblock failed: %s\n", gpg_strerror (rc));
503           goto leave;
504         }
505
506       if (secret || mark_secret)
507         any_secret = !agent_probe_any_secret_key (NULL, keyblock);
508       else
509         any_secret = 0;
510
511       if (secret && !any_secret)
512         ; /* Secret key listing requested but this isn't one.  */
513       else
514         {
515           if (!opt.with_colons)
516             {
517               resname = keydb_get_resource_name (hd);
518               if (lastresname != resname)
519                 {
520                   int i;
521
522                   es_fprintf (es_stdout, "%s\n", resname);
523                   for (i = strlen (resname); i; i--)
524                     es_putc ('-', es_stdout);
525                   es_putc ('\n', es_stdout);
526                   lastresname = resname;
527                 }
528             }
529           merge_keys_and_selfsig (keyblock);
530           list_keyblock (keyblock, secret, any_secret, opt.fingerprint,
531                          &listctx);
532         }
533       release_kbnode (keyblock);
534       keyblock = NULL;
535     }
536   while (!(rc = keydb_search_next (hd)));
537   es_fflush (es_stdout);
538   if (rc && gpg_err_code (rc) != GPG_ERR_NOT_FOUND)
539     log_error ("keydb_search_next failed: %s\n", gpg_strerror (rc));
540   if (keydb_get_skipped_counter (hd))
541     log_info (_("Warning: %lu key(s) skipped due to their large size\n"),
542               keydb_get_skipped_counter (hd));
543
544   if (opt.check_sigs && !opt.with_colons)
545     print_signature_stats (&listctx);
546
547  leave:
548   keylist_context_release (&listctx);
549   release_kbnode (keyblock);
550   keydb_release (hd);
551 }
552
553
554 static void
555 list_one (strlist_t names, int secret, int mark_secret)
556 {
557   int rc = 0;
558   KBNODE keyblock = NULL;
559   GETKEY_CTX ctx;
560   const char *resname;
561   const char *keyring_str = _("Keyring");
562   int i;
563   struct keylist_context listctx;
564
565   memset (&listctx, 0, sizeof (listctx));
566   if (!secret && opt.check_sigs)
567     listctx.check_sigs = 1;
568
569   /* fixme: using the bynames function has the disadvantage that we
570    * don't know wether one of the names given was not found.  OTOH,
571    * this function has the advantage to list the names in the
572    * sequence as defined by the keyDB and does not duplicate
573    * outputs.  A solution could be do test whether all given have
574    * been listed (this needs a way to use the keyDB search
575    * functions) or to have the search function return indicators for
576    * found names.  Yet another way is to use the keydb search
577    * facilities directly. */
578   rc = getkey_bynames (&ctx, NULL, names, secret, &keyblock);
579   if (rc)
580     {
581       log_error ("error reading key: %s\n", gpg_strerror (rc));
582       get_pubkey_end (ctx);
583       return;
584     }
585
586   do
587     {
588       if ((opt.list_options & LIST_SHOW_KEYRING) && !opt.with_colons)
589         {
590           resname = keydb_get_resource_name (get_ctx_handle (ctx));
591           es_fprintf (es_stdout, "%s: %s\n", keyring_str, resname);
592           for (i = strlen (resname) + strlen (keyring_str) + 2; i; i--)
593             es_putc ('-', es_stdout);
594           es_putc ('\n', es_stdout);
595         }
596       list_keyblock (keyblock, secret, mark_secret, opt.fingerprint, &listctx);
597       release_kbnode (keyblock);
598     }
599   while (!getkey_next (ctx, NULL, &keyblock));
600   getkey_end (ctx);
601
602   if (opt.check_sigs && !opt.with_colons)
603     print_signature_stats (&listctx);
604
605   keylist_context_release (&listctx);
606 }
607
608
609 static void
610 locate_one (ctrl_t ctrl, strlist_t names)
611 {
612   int rc = 0;
613   strlist_t sl;
614   GETKEY_CTX ctx = NULL;
615   KBNODE keyblock = NULL;
616   struct keylist_context listctx;
617
618   memset (&listctx, 0, sizeof (listctx));
619   if (opt.check_sigs)
620     listctx.check_sigs = 1;
621
622   for (sl = names; sl; sl = sl->next)
623     {
624       rc = get_pubkey_byname (ctrl, &ctx, NULL, sl->d, &keyblock, NULL, 1, 0);
625       if (rc)
626         {
627           if (gpg_err_code (rc) != GPG_ERR_NO_PUBKEY)
628             log_error ("error reading key: %s\n", gpg_strerror (rc));
629         }
630       else
631         {
632           do
633             {
634               list_keyblock (keyblock, 0, 0, opt.fingerprint, &listctx);
635               release_kbnode (keyblock);
636             }
637           while (ctx && !get_pubkey_next (ctx, NULL, &keyblock));
638           get_pubkey_end (ctx);
639           ctx = NULL;
640         }
641     }
642
643   if (opt.check_sigs && !opt.with_colons)
644     print_signature_stats (&listctx);
645
646   keylist_context_release (&listctx);
647 }
648
649
650 static void
651 print_key_data (PKT_public_key * pk)
652 {
653   int n = pk ? pubkey_get_npkey (pk->pubkey_algo) : 0;
654   int i;
655
656   for (i = 0; i < n; i++)
657     {
658       es_fprintf (es_stdout, "pkd:%d:%u:", i, mpi_get_nbits (pk->pkey[i]));
659       mpi_print (es_stdout, pk->pkey[i], 1);
660       es_putc (':', es_stdout);
661       es_putc ('\n', es_stdout);
662     }
663 }
664
665 static void
666 print_capabilities (PKT_public_key *pk, KBNODE keyblock)
667 {
668   unsigned int use = pk->pubkey_usage;
669   int c_printed = 0;
670
671   if (use & PUBKEY_USAGE_ENC)
672     es_putc ('e', es_stdout);
673
674   if (use & PUBKEY_USAGE_SIG)
675     {
676       es_putc ('s', es_stdout);
677       if (pk->flags.primary)
678         {
679           es_putc ('c', es_stdout);
680           /* The PUBKEY_USAGE_CERT flag was introduced later and we
681              used to always print 'c' for a primary key.  To avoid any
682              regression here we better track whether we printed 'c'
683              already.  */
684           c_printed = 1;
685         }
686     }
687
688   if ((use & PUBKEY_USAGE_CERT) && !c_printed)
689     es_putc ('c', es_stdout);
690
691   if ((use & PUBKEY_USAGE_AUTH))
692     es_putc ('a', es_stdout);
693
694   if ((use & PUBKEY_USAGE_UNKNOWN))
695     es_putc ('?', es_stdout);
696
697   if (keyblock)
698     {
699       /* Figure out the usable capabilities.  */
700       KBNODE k;
701       int enc = 0, sign = 0, cert = 0, auth = 0, disabled = 0;
702
703       for (k = keyblock; k; k = k->next)
704         {
705           if (k->pkt->pkttype == PKT_PUBLIC_KEY
706               || k->pkt->pkttype == PKT_PUBLIC_SUBKEY)
707             {
708               pk = k->pkt->pkt.public_key;
709
710               if (pk->flags.primary)
711                 disabled = pk_is_disabled (pk);
712
713               if (pk->flags.valid && !pk->flags.revoked && !pk->has_expired)
714                 {
715                   if (pk->pubkey_usage & PUBKEY_USAGE_ENC)
716                     enc = 1;
717                   if (pk->pubkey_usage & PUBKEY_USAGE_SIG)
718                     {
719                       sign = 1;
720                       if (pk->flags.primary)
721                         cert = 1;
722                     }
723                   if (pk->pubkey_usage & PUBKEY_USAGE_CERT)
724                     cert = 1;
725                   if ((pk->pubkey_usage & PUBKEY_USAGE_AUTH))
726                     auth = 1;
727                 }
728             }
729         }
730       if (enc)
731         es_putc ('E', es_stdout);
732       if (sign)
733         es_putc ('S', es_stdout);
734       if (cert)
735         es_putc ('C', es_stdout);
736       if (auth)
737         es_putc ('A', es_stdout);
738       if (disabled)
739         es_putc ('D', es_stdout);
740     }
741
742   es_putc (':', es_stdout);
743 }
744
745
746 /* FLAGS: 0x01 hashed
747           0x02 critical  */
748 static void
749 print_one_subpacket (sigsubpkttype_t type, size_t len, int flags,
750                      const byte * buf)
751 {
752   size_t i;
753
754   es_fprintf (es_stdout, "spk:%d:%u:%u:", type, flags, (unsigned int) len);
755
756   for (i = 0; i < len; i++)
757     {
758       /* printable ascii other than : and % */
759       if (buf[i] >= 32 && buf[i] <= 126 && buf[i] != ':' && buf[i] != '%')
760         es_fprintf (es_stdout, "%c", buf[i]);
761       else
762         es_fprintf (es_stdout, "%%%02X", buf[i]);
763     }
764
765   es_fprintf (es_stdout, "\n");
766 }
767
768
769 void
770 print_subpackets_colon (PKT_signature * sig)
771 {
772   byte *i;
773
774   assert (opt.show_subpackets);
775
776   for (i = opt.show_subpackets; *i; i++)
777     {
778       const byte *p;
779       size_t len;
780       int seq, crit;
781
782       seq = 0;
783
784       while ((p = enum_sig_subpkt (sig->hashed, *i, &len, &seq, &crit)))
785         print_one_subpacket (*i, len, 0x01 | (crit ? 0x02 : 0), p);
786
787       seq = 0;
788
789       while ((p = enum_sig_subpkt (sig->unhashed, *i, &len, &seq, &crit)))
790         print_one_subpacket (*i, len, 0x00 | (crit ? 0x02 : 0), p);
791     }
792 }
793
794
795 void
796 dump_attribs (const PKT_user_id *uid, PKT_public_key *pk)
797 {
798   int i;
799
800   if (!attrib_fp)
801     return;
802
803   for (i = 0; i < uid->numattribs; i++)
804     {
805       if (is_status_enabled ())
806         {
807           byte array[MAX_FINGERPRINT_LEN], *p;
808           char buf[(MAX_FINGERPRINT_LEN * 2) + 90];
809           size_t j, n;
810
811           if (!pk)
812             BUG ();
813           fingerprint_from_pk (pk, array, &n);
814
815           p = array;
816           for (j = 0; j < n; j++, p++)
817             sprintf (buf + 2 * j, "%02X", *p);
818
819           sprintf (buf + strlen (buf), " %lu %u %u %u %lu %lu %u",
820                    (ulong) uid->attribs[i].len, uid->attribs[i].type, i + 1,
821                    uid->numattribs, (ulong) uid->created,
822                    (ulong) uid->expiredate,
823                    ((uid->is_primary ? 0x01 : 0) | (uid->
824                                                     is_revoked ? 0x02 : 0) |
825                     (uid->is_expired ? 0x04 : 0)));
826           write_status_text (STATUS_ATTRIBUTE, buf);
827         }
828
829       es_fwrite (uid->attribs[i].data, uid->attribs[i].len, 1, attrib_fp);
830       es_fflush (attrib_fp);
831     }
832 }
833
834
835 /* Print IPGP cert records instead of a standard key listing.  */
836 static void
837 list_keyblock_pka (kbnode_t keyblock)
838 {
839   kbnode_t kbctx;
840   kbnode_t node;
841   PKT_public_key *pk;
842   char pkstrbuf[PUBKEY_STRING_SIZE];
843   char *hexfpr;
844
845   /* Get the keyid from the keyblock.  */
846   node = find_kbnode (keyblock, PKT_PUBLIC_KEY);
847   if (!node)
848     {
849       log_error ("Oops; key lost!\n");
850       dump_kbnode (keyblock);
851       return;
852     }
853
854   pk = node->pkt->pkt.public_key;
855
856   es_fprintf (es_stdout, ";; pub  %s/%s %s\n;; ",
857               pubkey_string (pk, pkstrbuf, sizeof pkstrbuf),
858               keystr_from_pk (pk), datestr_from_pk (pk));
859   print_fingerprint (NULL, pk, 10);
860   hexfpr = hexfingerprint (pk);
861
862   for (kbctx = NULL; (node = walk_kbnode (keyblock, &kbctx, 0));)
863     {
864       if (node->pkt->pkttype == PKT_USER_ID)
865         {
866           PKT_user_id *uid = node->pkt->pkt.user_id;
867           char *mbox;
868           char *p;
869
870           if (pk && (uid->is_expired || uid->is_revoked)
871               && !(opt.list_options & LIST_SHOW_UNUSABLE_UIDS))
872             continue;
873
874           es_fputs (";; uid  ", es_stdout);
875           print_utf8_buffer (es_stdout, uid->name, uid->len);
876           es_putc ('\n', es_stdout);
877           mbox = mailbox_from_userid (uid->name);
878           if (mbox && (p = strchr (mbox, '@')))
879             {
880               char hashbuf[20];
881               char *hash;
882               unsigned int len;
883
884               *p++ = 0;
885               es_fprintf (es_stdout, "$ORIGIN _pka.%s.\n", p);
886               gcry_md_hash_buffer (GCRY_MD_SHA1, hashbuf, mbox, strlen (mbox));
887               hash = zb32_encode (hashbuf, 8*20);
888               if (hash)
889                 {
890                   len = strlen (hexfpr)/2;
891                   es_fprintf (es_stdout,
892                               "%s TYPE37 \\# %u 0006 0000 00 %02X %s\n",
893                               hash, 6 + len, len, hexfpr);
894                   xfree (hash);
895                 }
896             }
897           xfree (mbox);
898         }
899
900     }
901   es_putc ('\n', es_stdout);
902
903   xfree (hexfpr);
904 }
905
906
907 static void
908 list_keyblock_print (KBNODE keyblock, int secret, int fpr,
909                      struct keylist_context *listctx)
910 {
911   int rc;
912   KBNODE kbctx;
913   KBNODE node;
914   PKT_public_key *pk;
915   int skip_sigs = 0;
916   int s2k_char;
917   char *hexgrip = NULL;
918   char *serialno = NULL;
919   char pkstrbuf[PUBKEY_STRING_SIZE];
920
921   /* Get the keyid from the keyblock.  */
922   node = find_kbnode (keyblock, PKT_PUBLIC_KEY);
923   if (!node)
924     {
925       log_error ("Oops; key lost!\n");
926       dump_kbnode (keyblock);
927       return;
928     }
929
930   pk = node->pkt->pkt.public_key;
931
932   if (secret || opt.with_keygrip)
933     {
934       rc = hexkeygrip_from_pk (pk, &hexgrip);
935       if (rc)
936         log_error ("error computing a keygrip: %s\n", gpg_strerror (rc));
937     }
938
939   if (secret)
940     {
941       if (!agent_get_keyinfo (NULL, hexgrip, &serialno))
942         s2k_char = serialno? '>':' ';
943       else
944         s2k_char = '#';  /* Key not found.  */
945     }
946   else
947     s2k_char = ' ';
948
949   check_trustdb_stale ();
950
951
952   es_fprintf (es_stdout, "%s%c  %s/%s %s",
953               secret? "sec":"pub",
954               s2k_char,
955               pubkey_string (pk, pkstrbuf, sizeof pkstrbuf),
956               keystr_from_pk (pk), datestr_from_pk (pk));
957
958   if ((opt.list_options & LIST_SHOW_USAGE))
959     {
960       es_fprintf (es_stdout, " [%s]", usagestr_from_pk (pk, 0));
961     }
962   if (pk->flags.revoked)
963     {
964       es_fprintf (es_stdout, " [");
965       es_fprintf (es_stdout, _("revoked: %s"), revokestr_from_pk (pk));
966       es_fprintf (es_stdout, "]");
967     }
968   else if (pk->has_expired)
969     {
970       es_fprintf (es_stdout, " [");
971       es_fprintf (es_stdout, _("expired: %s"), expirestr_from_pk (pk));
972       es_fprintf (es_stdout, "]");
973     }
974   else if (pk->expiredate)
975     {
976       es_fprintf (es_stdout, " [");
977       es_fprintf (es_stdout, _("expires: %s"), expirestr_from_pk (pk));
978       es_fprintf (es_stdout, "]");
979     }
980
981 #if 0
982   /* I need to think about this some more.  It's easy enough to
983      include, but it looks sort of confusing in the listing... */
984   if (opt.list_options & LIST_SHOW_VALIDITY)
985     {
986       int validity = get_validity (pk, NULL);
987       es_fprintf (es_stdout, " [%s]", trust_value_to_string (validity));
988     }
989 #endif
990
991   if (pk->pubkey_algo >= 100)
992     es_fprintf (es_stdout, " [experimental algorithm %d]", pk->pubkey_algo);
993
994   es_fprintf (es_stdout, "\n");
995
996   if (fpr)
997     print_fingerprint (NULL, pk, 0);
998
999   if (opt.with_keygrip && hexgrip)
1000     es_fprintf (es_stdout, "      Keygrip = %s\n", hexgrip);
1001
1002   if (serialno)
1003     print_card_serialno (serialno);
1004
1005   if (opt.with_key_data)
1006     print_key_data (pk);
1007
1008   for (kbctx = NULL; (node = walk_kbnode (keyblock, &kbctx, 0));)
1009     {
1010       if (node->pkt->pkttype == PKT_USER_ID)
1011         {
1012           PKT_user_id *uid = node->pkt->pkt.user_id;
1013
1014           if ((uid->is_expired || uid->is_revoked)
1015               && !(opt.list_options & LIST_SHOW_UNUSABLE_UIDS))
1016             {
1017               skip_sigs = 1;
1018               continue;
1019             }
1020           else
1021             skip_sigs = 0;
1022
1023           if (attrib_fp && uid->attrib_data != NULL)
1024             dump_attribs (uid, pk);
1025
1026           if ((uid->is_revoked || uid->is_expired)
1027               || (opt.list_options & LIST_SHOW_UID_VALIDITY))
1028             {
1029               const char *validity;
1030               int indent;
1031
1032               validity = uid_trust_string_fixed (pk, uid);
1033               indent =
1034                 (keystrlen () + (opt.legacy_list_mode? 9:11)) -
1035                 atoi (uid_trust_string_fixed (NULL, NULL));
1036
1037               if (indent < 0 || indent > 40)
1038                 indent = 0;
1039
1040               es_fprintf (es_stdout, "uid%*s%s ", indent, "", validity);
1041             }
1042           else
1043             es_fprintf (es_stdout, "uid%*s",
1044                         (int) keystrlen () + (opt.legacy_list_mode? 10:12), "");
1045
1046           print_utf8_buffer (es_stdout, uid->name, uid->len);
1047           es_putc ('\n', es_stdout);
1048
1049           if ((opt.list_options & LIST_SHOW_PHOTOS) && uid->attribs != NULL)
1050             show_photos (uid->attribs, uid->numattribs, pk, uid);
1051         }
1052       else if (node->pkt->pkttype == PKT_PUBLIC_SUBKEY)
1053         {
1054           PKT_public_key *pk2 = node->pkt->pkt.public_key;
1055
1056           if ((pk2->flags.revoked || pk2->has_expired)
1057               && !(opt.list_options & LIST_SHOW_UNUSABLE_SUBKEYS))
1058             {
1059               skip_sigs = 1;
1060               continue;
1061             }
1062           else
1063             skip_sigs = 0;
1064
1065           xfree (serialno); serialno = NULL;
1066           xfree (hexgrip); hexgrip = NULL;
1067           if (secret || opt.with_keygrip)
1068             {
1069               rc = hexkeygrip_from_pk (pk2, &hexgrip);
1070               if (rc)
1071                 log_error ("error computing a keygrip: %s\n",
1072                            gpg_strerror (rc));
1073             }
1074           if (secret)
1075             {
1076               if (!agent_get_keyinfo (NULL, hexgrip, &serialno))
1077                 s2k_char = serialno? '>':' ';
1078               else
1079                 s2k_char = '#';  /* Key not found.  */
1080             }
1081           else
1082             s2k_char = ' ';
1083
1084           es_fprintf (es_stdout, "%s%c  %s/%s %s",
1085                   secret? "ssb":"sub",
1086                   s2k_char,
1087                   pubkey_string (pk2, pkstrbuf, sizeof pkstrbuf),
1088                   keystr_from_pk (pk2), datestr_from_pk (pk2));
1089
1090           if (pk2->pubkey_algo == PUBKEY_ALGO_ECDSA
1091               || pk2->pubkey_algo == PUBKEY_ALGO_EDDSA
1092               || pk2->pubkey_algo == PUBKEY_ALGO_ECDH)
1093             {
1094               char *curve = openpgp_oid_to_str (pk2->pkey[0]);
1095               const char *name = openpgp_oid_to_curve (curve, 0);
1096               if (!name)
1097                 name = curve;
1098               es_fprintf (es_stdout, " %s", name);
1099               xfree (curve);
1100             }
1101
1102           if ((opt.list_options & LIST_SHOW_USAGE))
1103             {
1104               es_fprintf (es_stdout, " [%s]", usagestr_from_pk (pk2, 0));
1105             }
1106           if (pk2->flags.revoked)
1107             {
1108               es_fprintf (es_stdout, " [");
1109               es_fprintf (es_stdout, _("revoked: %s"), revokestr_from_pk (pk2));
1110               es_fprintf (es_stdout, "]");
1111             }
1112           else if (pk2->has_expired)
1113             {
1114               es_fprintf (es_stdout, " [");
1115               es_fprintf (es_stdout, _("expired: %s"), expirestr_from_pk (pk2));
1116               es_fprintf (es_stdout, "]");
1117             }
1118           else if (pk2->expiredate)
1119             {
1120               es_fprintf (es_stdout, " [");
1121               es_fprintf (es_stdout, _("expires: %s"), expirestr_from_pk (pk2));
1122               es_fprintf (es_stdout, "]");
1123             }
1124           es_putc ('\n', es_stdout);
1125           if (fpr > 1)
1126             {
1127               print_fingerprint (NULL, pk2, 0);
1128               if (serialno)
1129                 print_card_serialno (serialno);
1130             }
1131           if (opt.with_keygrip && hexgrip)
1132             es_fprintf (es_stdout, "      Keygrip = %s\n", hexgrip);
1133           if (opt.with_key_data)
1134             print_key_data (pk2);
1135         }
1136       else if (opt.list_sigs
1137                && node->pkt->pkttype == PKT_SIGNATURE && !skip_sigs)
1138         {
1139           PKT_signature *sig = node->pkt->pkt.signature;
1140           int sigrc;
1141           char *sigstr;
1142
1143           if (listctx->check_sigs)
1144             {
1145               rc = check_key_signature (keyblock, node, NULL);
1146               switch (gpg_err_code (rc))
1147                 {
1148                 case 0:
1149                   listctx->good_sigs++;
1150                   sigrc = '!';
1151                   break;
1152                 case GPG_ERR_BAD_SIGNATURE:
1153                   listctx->inv_sigs++;
1154                   sigrc = '-';
1155                   break;
1156                 case GPG_ERR_NO_PUBKEY:
1157                 case GPG_ERR_UNUSABLE_PUBKEY:
1158                   listctx->no_key++;
1159                   continue;
1160                 default:
1161                   listctx->oth_err++;
1162                   sigrc = '%';
1163                   break;
1164                 }
1165
1166               /* TODO: Make sure a cached sig record here still has
1167                  the pk that issued it.  See also
1168                  keyedit.c:print_and_check_one_sig */
1169             }
1170           else
1171             {
1172               rc = 0;
1173               sigrc = ' ';
1174             }
1175
1176           if (sig->sig_class == 0x20 || sig->sig_class == 0x28
1177               || sig->sig_class == 0x30)
1178             sigstr = "rev";
1179           else if ((sig->sig_class & ~3) == 0x10)
1180             sigstr = "sig";
1181           else if (sig->sig_class == 0x18)
1182             sigstr = "sig";
1183           else if (sig->sig_class == 0x1F)
1184             sigstr = "sig";
1185           else
1186             {
1187               es_fprintf (es_stdout, "sig                             "
1188                       "[unexpected signature class 0x%02x]\n",
1189                       sig->sig_class);
1190               continue;
1191             }
1192
1193           es_fputs (sigstr, es_stdout);
1194           es_fprintf (es_stdout, "%c%c %c%c%c%c%c%c %s %s",
1195                   sigrc, (sig->sig_class - 0x10 > 0 &&
1196                           sig->sig_class - 0x10 <
1197                           4) ? '0' + sig->sig_class - 0x10 : ' ',
1198                   sig->flags.exportable ? ' ' : 'L',
1199                   sig->flags.revocable ? ' ' : 'R',
1200                   sig->flags.policy_url ? 'P' : ' ',
1201                   sig->flags.notation ? 'N' : ' ',
1202                   sig->flags.expired ? 'X' : ' ',
1203                   (sig->trust_depth > 9) ? 'T' : (sig->trust_depth >
1204                                                   0) ? '0' +
1205                   sig->trust_depth : ' ', keystr (sig->keyid),
1206                   datestr_from_sig (sig));
1207           if (opt.list_options & LIST_SHOW_SIG_EXPIRE)
1208             es_fprintf (es_stdout, " %s", expirestr_from_sig (sig));
1209           es_fprintf (es_stdout, "  ");
1210           if (sigrc == '%')
1211             es_fprintf (es_stdout, "[%s] ", gpg_strerror (rc));
1212           else if (sigrc == '?')
1213             ;
1214           else if (!opt.fast_list_mode)
1215             {
1216               size_t n;
1217               char *p = get_user_id (sig->keyid, &n);
1218               print_utf8_buffer (es_stdout, p, n);
1219               xfree (p);
1220             }
1221           es_putc ('\n', es_stdout);
1222
1223           if (sig->flags.policy_url
1224               && (opt.list_options & LIST_SHOW_POLICY_URLS))
1225             show_policy_url (sig, 3, 0);
1226
1227           if (sig->flags.notation && (opt.list_options & LIST_SHOW_NOTATIONS))
1228             show_notation (sig, 3, 0,
1229                            ((opt.
1230                              list_options & LIST_SHOW_STD_NOTATIONS) ? 1 : 0)
1231                            +
1232                            ((opt.
1233                              list_options & LIST_SHOW_USER_NOTATIONS) ? 2 :
1234                             0));
1235
1236           if (sig->flags.pref_ks
1237               && (opt.list_options & LIST_SHOW_KEYSERVER_URLS))
1238             show_keyserver_url (sig, 3, 0);
1239
1240           /* fixme: check or list other sigs here */
1241         }
1242     }
1243   es_putc ('\n', es_stdout);
1244   xfree (serialno);
1245   xfree (hexgrip);
1246 }
1247
1248 void
1249 print_revokers (estream_t fp, PKT_public_key * pk)
1250 {
1251   /* print the revoker record */
1252   if (!pk->revkey && pk->numrevkeys)
1253     BUG ();
1254   else
1255     {
1256       int i, j;
1257
1258       for (i = 0; i < pk->numrevkeys; i++)
1259         {
1260           byte *p;
1261
1262           es_fprintf (fp, "rvk:::%d::::::", pk->revkey[i].algid);
1263           p = pk->revkey[i].fpr;
1264           for (j = 0; j < 20; j++, p++)
1265             es_fprintf (fp, "%02X", *p);
1266           es_fprintf (fp, ":%02x%s:\n",
1267                       pk->revkey[i].class,
1268                       (pk->revkey[i].class & 0x40) ? "s" : "");
1269         }
1270     }
1271 }
1272
1273
1274 /* List a key in colon mode.  If SECRET is true this is a secret key
1275    record (i.e. requested via --list-secret-key).  If HAS_SECRET a
1276    secret key is available even if SECRET is not set.  */
1277 static void
1278 list_keyblock_colon (KBNODE keyblock, int secret, int has_secret, int fpr)
1279 {
1280   int rc;
1281   KBNODE kbctx;
1282   KBNODE node;
1283   PKT_public_key *pk;
1284   u32 keyid[2];
1285   int trustletter = 0;
1286   int ulti_hack = 0;
1287   int i;
1288   char *p;
1289   char *hexgrip = NULL;
1290   char *serialno = NULL;
1291   int stubkey;
1292
1293   /* Get the keyid from the keyblock.  */
1294   node = find_kbnode (keyblock, PKT_PUBLIC_KEY);
1295   if (!node)
1296     {
1297       log_error ("Oops; key lost!\n");
1298       dump_kbnode (keyblock);
1299       return;
1300     }
1301
1302   pk = node->pkt->pkt.public_key;
1303   if (secret || has_secret || opt.with_keygrip || opt.with_key_data)
1304     {
1305       rc = hexkeygrip_from_pk (pk, &hexgrip);
1306       if (rc)
1307         log_error ("error computing a keygrip: %s\n", gpg_strerror (rc));
1308     }
1309   stubkey = 0;
1310   if ((secret||has_secret) && agent_get_keyinfo (NULL, hexgrip, &serialno))
1311     stubkey = 1;  /* Key not found.  */
1312
1313   keyid_from_pk (pk, keyid);
1314   es_fputs (secret? "sec:":"pub:", es_stdout);
1315   if (!pk->flags.valid)
1316     es_putc ('i', es_stdout);
1317   else if (pk->flags.revoked)
1318     es_putc ('r', es_stdout);
1319   else if (pk->has_expired)
1320     es_putc ('e', es_stdout);
1321   else if (opt.fast_list_mode || opt.no_expensive_trust_checks)
1322     ;
1323   else
1324     {
1325       trustletter = get_validity_info (pk, NULL);
1326       if (trustletter == 'u')
1327         ulti_hack = 1;
1328       es_putc (trustletter, es_stdout);
1329     }
1330
1331   es_fprintf (es_stdout, ":%u:%d:%08lX%08lX:%s:%s::",
1332           nbits_from_pk (pk),
1333           pk->pubkey_algo,
1334           (ulong) keyid[0], (ulong) keyid[1],
1335           colon_datestr_from_pk (pk), colon_strtime (pk->expiredate));
1336
1337   if (!opt.fast_list_mode && !opt.no_expensive_trust_checks)
1338     es_putc (get_ownertrust_info (pk), es_stdout);
1339   es_putc (':', es_stdout);
1340
1341   es_putc (':', es_stdout);
1342   es_putc (':', es_stdout);
1343   print_capabilities (pk, keyblock);
1344   es_putc (':', es_stdout);             /* End of field 13. */
1345   es_putc (':', es_stdout);             /* End of field 14. */
1346   if (secret || has_secret)
1347     {
1348       if (stubkey)
1349         es_putc ('#', es_stdout);
1350       else if (serialno)
1351         es_fputs (serialno, es_stdout);
1352       else if (has_secret)
1353         es_putc ('+', es_stdout);
1354     }
1355   es_putc (':', es_stdout);             /* End of field 15. */
1356   es_putc (':', es_stdout);             /* End of field 16. */
1357   if (pk->pubkey_algo == PUBKEY_ALGO_ECDSA
1358       || pk->pubkey_algo == PUBKEY_ALGO_EDDSA
1359       || pk->pubkey_algo == PUBKEY_ALGO_ECDH)
1360     {
1361       char *curve = openpgp_oid_to_str (pk->pkey[0]);
1362       const char *name = openpgp_oid_to_curve (curve, 0);
1363       if (!name)
1364         name = curve;
1365       es_fputs (name, es_stdout);
1366       xfree (curve);
1367     }
1368   es_putc (':', es_stdout);             /* End of field 17. */
1369   es_putc ('\n', es_stdout);
1370
1371   print_revokers (es_stdout, pk);
1372   if (fpr)
1373     print_fingerprint (NULL, pk, 0);
1374   if (opt.with_key_data || opt.with_keygrip)
1375     {
1376       if (hexgrip)
1377         es_fprintf (es_stdout, "grp:::::::::%s:\n", hexgrip);
1378       if (opt.with_key_data)
1379         print_key_data (pk);
1380     }
1381
1382   for (kbctx = NULL; (node = walk_kbnode (keyblock, &kbctx, 0));)
1383     {
1384       if (node->pkt->pkttype == PKT_USER_ID)
1385         {
1386           char *str;
1387           PKT_user_id *uid = node->pkt->pkt.user_id;
1388
1389           if (attrib_fp && node->pkt->pkt.user_id->attrib_data != NULL)
1390             dump_attribs (node->pkt->pkt.user_id, pk);
1391           /*
1392            * Fixme: We need a valid flag here too
1393            */
1394           str = uid->attrib_data ? "uat" : "uid";
1395           if (uid->is_revoked)
1396             es_fprintf (es_stdout, "%s:r::::", str);
1397           else if (uid->is_expired)
1398             es_fprintf (es_stdout, "%s:e::::", str);
1399           else if (opt.no_expensive_trust_checks)
1400             es_fprintf (es_stdout, "%s:::::", str);
1401           else
1402             {
1403               int uid_validity;
1404
1405               if (!ulti_hack)
1406                 uid_validity = get_validity_info (pk, uid);
1407               else
1408                 uid_validity = 'u';
1409               es_fprintf (es_stdout, "%s:%c::::", str, uid_validity);
1410             }
1411
1412           es_fprintf (es_stdout, "%s:", colon_strtime (uid->created));
1413           es_fprintf (es_stdout, "%s:", colon_strtime (uid->expiredate));
1414
1415           namehash_from_uid (uid);
1416
1417           for (i = 0; i < 20; i++)
1418             es_fprintf (es_stdout, "%02X", uid->namehash[i]);
1419
1420           es_fprintf (es_stdout, "::");
1421
1422           if (uid->attrib_data)
1423             es_fprintf (es_stdout, "%u %lu", uid->numattribs, uid->attrib_len);
1424           else
1425             es_write_sanitized (es_stdout, uid->name, uid->len, ":", NULL);
1426           es_putc (':', es_stdout);
1427           es_putc ('\n', es_stdout);
1428         }
1429       else if (node->pkt->pkttype == PKT_PUBLIC_SUBKEY)
1430         {
1431           u32 keyid2[2];
1432           PKT_public_key *pk2;
1433
1434           pk2 = node->pkt->pkt.public_key;
1435           xfree (hexgrip); hexgrip = NULL;
1436           xfree (serialno); serialno = NULL;
1437           if (secret || has_secret || opt.with_keygrip || opt.with_key_data)
1438             {
1439               rc = hexkeygrip_from_pk (pk2, &hexgrip);
1440               if (rc)
1441                 log_error ("error computing a keygrip: %s\n",
1442                            gpg_strerror (rc));
1443             }
1444           stubkey = 0;
1445           if ((secret||has_secret)
1446               && agent_get_keyinfo (NULL, hexgrip, &serialno))
1447             stubkey = 1;  /* Key not found.  */
1448
1449           keyid_from_pk (pk2, keyid2);
1450           es_fputs (secret? "ssb:":"sub:", es_stdout);
1451           if (!pk2->flags.valid)
1452             es_putc ('i', es_stdout);
1453           else if (pk2->flags.revoked)
1454             es_putc ('r', es_stdout);
1455           else if (pk2->has_expired)
1456             es_putc ('e', es_stdout);
1457           else if (opt.fast_list_mode || opt.no_expensive_trust_checks)
1458             ;
1459           else
1460             {
1461               /* TRUSTLETTER should always be defined here. */
1462               if (trustletter)
1463                 es_fprintf (es_stdout, "%c", trustletter);
1464             }
1465           es_fprintf (es_stdout, ":%u:%d:%08lX%08lX:%s:%s:::::",
1466                   nbits_from_pk (pk2),
1467                   pk2->pubkey_algo,
1468                   (ulong) keyid2[0], (ulong) keyid2[1],
1469                   colon_datestr_from_pk (pk2), colon_strtime (pk2->expiredate)
1470                   /* fixme: add LID and ownertrust here */
1471             );
1472           print_capabilities (pk2, NULL);
1473           es_putc (':', es_stdout);     /* End of field 13. */
1474           es_putc (':', es_stdout);     /* End of field 14. */
1475           if (secret || has_secret)
1476             {
1477               if (stubkey)
1478                 es_putc ('#', es_stdout);
1479               else if (serialno)
1480                 es_fputs (serialno, es_stdout);
1481               else if (has_secret)
1482                 es_putc ('+', es_stdout);
1483             }
1484           es_putc (':', es_stdout);     /* End of field 15. */
1485           es_putc (':', es_stdout);     /* End of field 16. */
1486           if (pk->pubkey_algo == PUBKEY_ALGO_ECDSA
1487               || pk->pubkey_algo == PUBKEY_ALGO_EDDSA
1488               || pk->pubkey_algo == PUBKEY_ALGO_ECDH)
1489             {
1490               char *curve = openpgp_oid_to_str (pk->pkey[0]);
1491               const char *name = openpgp_oid_to_curve (curve, 0);
1492               if (!name)
1493                 name = curve;
1494               es_fputs (name, es_stdout);
1495               xfree (curve);
1496             }
1497           es_putc (':', es_stdout);     /* End of field 17. */
1498           es_putc ('\n', es_stdout);
1499           if (fpr > 1)
1500             print_fingerprint (NULL, pk2, 0);
1501           if (opt.with_key_data || opt.with_keygrip)
1502             {
1503               if (hexgrip)
1504                 es_fprintf (es_stdout, "grp:::::::::%s:\n", hexgrip);
1505               if (opt.with_key_data)
1506                 print_key_data (pk2);
1507             }
1508         }
1509       else if (opt.list_sigs && node->pkt->pkttype == PKT_SIGNATURE)
1510         {
1511           PKT_signature *sig = node->pkt->pkt.signature;
1512           int sigrc, fprokay = 0;
1513           char *sigstr;
1514           size_t fplen;
1515           byte fparray[MAX_FINGERPRINT_LEN];
1516
1517           if (sig->sig_class == 0x20 || sig->sig_class == 0x28
1518               || sig->sig_class == 0x30)
1519             sigstr = "rev";
1520           else if ((sig->sig_class & ~3) == 0x10)
1521             sigstr = "sig";
1522           else if (sig->sig_class == 0x18)
1523             sigstr = "sig";
1524           else if (sig->sig_class == 0x1F)
1525             sigstr = "sig";
1526           else
1527             {
1528               es_fprintf (es_stdout, "sig::::::::::%02x%c:\n",
1529                       sig->sig_class, sig->flags.exportable ? 'x' : 'l');
1530               continue;
1531             }
1532
1533           if (opt.check_sigs)
1534             {
1535               PKT_public_key *signer_pk = NULL;
1536
1537               fflush (stdout);
1538               if (opt.no_sig_cache)
1539                 signer_pk = xmalloc_clear (sizeof (PKT_public_key));
1540
1541               rc = check_key_signature2 (keyblock, node, NULL, signer_pk,
1542                                          NULL, NULL, NULL);
1543               switch (gpg_err_code (rc))
1544                 {
1545                 case 0:
1546                   sigrc = '!';
1547                   break;
1548                 case GPG_ERR_BAD_SIGNATURE:
1549                   sigrc = '-';
1550                   break;
1551                 case GPG_ERR_NO_PUBKEY:
1552                 case GPG_ERR_UNUSABLE_PUBKEY:
1553                   sigrc = '?';
1554                   break;
1555                 default:
1556                   sigrc = '%';
1557                   break;
1558                 }
1559
1560               if (opt.no_sig_cache)
1561                 {
1562                   if (!rc)
1563                     {
1564                       fingerprint_from_pk (signer_pk, fparray, &fplen);
1565                       fprokay = 1;
1566                     }
1567                   free_public_key (signer_pk);
1568                 }
1569             }
1570           else
1571             {
1572               rc = 0;
1573               sigrc = ' ';
1574             }
1575           es_fputs (sigstr, es_stdout);
1576           es_putc (':', es_stdout);
1577           if (sigrc != ' ')
1578             es_putc (sigrc, es_stdout);
1579           es_fprintf (es_stdout, "::%d:%08lX%08lX:%s:%s:", sig->pubkey_algo,
1580                   (ulong) sig->keyid[0], (ulong) sig->keyid[1],
1581                   colon_datestr_from_sig (sig),
1582                   colon_expirestr_from_sig (sig));
1583
1584           if (sig->trust_depth || sig->trust_value)
1585             es_fprintf (es_stdout, "%d %d", sig->trust_depth, sig->trust_value);
1586           es_fprintf (es_stdout, ":");
1587
1588           if (sig->trust_regexp)
1589             es_write_sanitized (es_stdout, sig->trust_regexp,
1590                                 strlen (sig->trust_regexp), ":", NULL);
1591           es_fprintf (es_stdout, ":");
1592
1593           if (sigrc == '%')
1594             es_fprintf (es_stdout, "[%s] ", gpg_strerror (rc));
1595           else if (sigrc == '?')
1596             ;
1597           else if (!opt.fast_list_mode)
1598             {
1599               size_t n;
1600               p = get_user_id (sig->keyid, &n);
1601               es_write_sanitized (es_stdout, p, n, ":", NULL);
1602               xfree (p);
1603             }
1604           es_fprintf (es_stdout, ":%02x%c::", sig->sig_class,
1605                   sig->flags.exportable ? 'x' : 'l');
1606
1607           if (opt.no_sig_cache && opt.check_sigs && fprokay)
1608             {
1609               for (i = 0; i < fplen; i++)
1610                 es_fprintf (es_stdout, "%02X", fparray[i]);
1611             }
1612
1613           es_fprintf (es_stdout, ":::%d:\n", sig->digest_algo);
1614
1615           if (opt.show_subpackets)
1616             print_subpackets_colon (sig);
1617
1618           /* fixme: check or list other sigs here */
1619         }
1620     }
1621
1622   xfree (hexgrip);
1623   xfree (serialno);
1624 }
1625
1626 /*
1627  * Reorder the keyblock so that the primary user ID (and not attribute
1628  * packet) comes first.  Fixme: Replace this by a generic sort
1629  * function.  */
1630 static void
1631 do_reorder_keyblock (KBNODE keyblock, int attr)
1632 {
1633   KBNODE primary = NULL, primary0 = NULL, primary2 = NULL;
1634   KBNODE last, node;
1635
1636   for (node = keyblock; node; primary0 = node, node = node->next)
1637     {
1638       if (node->pkt->pkttype == PKT_USER_ID &&
1639           ((attr && node->pkt->pkt.user_id->attrib_data) ||
1640            (!attr && !node->pkt->pkt.user_id->attrib_data)) &&
1641           node->pkt->pkt.user_id->is_primary)
1642         {
1643           primary = primary2 = node;
1644           for (node = node->next; node; primary2 = node, node = node->next)
1645             {
1646               if (node->pkt->pkttype == PKT_USER_ID
1647                   || node->pkt->pkttype == PKT_PUBLIC_SUBKEY
1648                   || node->pkt->pkttype == PKT_SECRET_SUBKEY)
1649                 {
1650                   break;
1651                 }
1652             }
1653           break;
1654         }
1655     }
1656   if (!primary)
1657     return; /* No primary key flag found (should not happen).  */
1658
1659   for (last = NULL, node = keyblock; node; last = node, node = node->next)
1660     {
1661       if (node->pkt->pkttype == PKT_USER_ID)
1662         break;
1663     }
1664   assert (node);
1665   assert (last);         /* The user ID is never the first packet.  */
1666   assert (primary0);     /* Ditto (this is the node before primary).  */
1667   if (node == primary)
1668     return; /* Already the first one.  */
1669
1670   last->next = primary;
1671   primary0->next = primary2->next;
1672   primary2->next = node;
1673 }
1674
1675 void
1676 reorder_keyblock (KBNODE keyblock)
1677 {
1678   do_reorder_keyblock (keyblock, 1);
1679   do_reorder_keyblock (keyblock, 0);
1680 }
1681
1682 static void
1683 list_keyblock (KBNODE keyblock, int secret, int has_secret, int fpr,
1684                struct keylist_context *listctx)
1685 {
1686   reorder_keyblock (keyblock);
1687   if (opt.print_pka_records)
1688     list_keyblock_pka (keyblock);
1689   else if (opt.with_colons)
1690     list_keyblock_colon (keyblock, secret, has_secret, fpr);
1691   else
1692     list_keyblock_print (keyblock, secret, fpr, listctx);
1693   if (secret)
1694     es_fflush (es_stdout);
1695 }
1696
1697
1698 /* Public function used by keygen to list a keyblock.  */
1699 void
1700 list_keyblock_direct (kbnode_t keyblock, int secret, int has_secret, int fpr)
1701 {
1702   struct keylist_context listctx;
1703
1704   memset (&listctx, 0, sizeof (listctx));
1705   list_keyblock (keyblock, secret, has_secret, fpr, &listctx);
1706   keylist_context_release (&listctx);
1707 }
1708
1709
1710 /* Print an hex digit in ICAO spelling.  */
1711 static void
1712 print_icao_hexdigit (estream_t fp, int c)
1713 {
1714   static const char *list[16] = {
1715     "Zero", "One", "Two", "Three", "Four", "Five", "Six", "Seven",
1716     "Eight", "Niner", "Alfa", "Bravo", "Charlie", "Delta", "Echo", "Foxtrot"
1717   };
1718
1719   tty_fprintf (fp, "%s", list[c&15]);
1720 }
1721
1722
1723 /*
1724  * Function to print the finperprint.
1725  * mode 0: as used in key listings, opt.with_colons is honored
1726  *      1: print using log_info ()
1727  *      2: direct use of tty
1728  *      3: direct use of tty but only primary key.
1729  *      4: direct use of tty but only subkey.
1730  *     10: Same as 0 but with_colons etc is ignored.
1731  *
1732  * Modes 1 and 2 will try and print both subkey and primary key
1733  * fingerprints.  A MODE with bit 7 set is used internally.  If
1734  * OVERRIDE_FP is not NULL that stream will be used in  0 instead
1735  * of es_stdout or instead of the TTY in modes 2 and 3.
1736  */
1737 void
1738 print_fingerprint (estream_t override_fp, PKT_public_key *pk, int mode)
1739 {
1740   byte array[MAX_FINGERPRINT_LEN], *p;
1741   size_t i, n;
1742   estream_t fp;
1743   const char *text;
1744   int primary = 0;
1745   int with_colons = opt.with_colons;
1746   int with_icao   = opt.with_icao_spelling;
1747
1748   if (mode == 10)
1749     {
1750       mode = 0;
1751       with_colons = 0;
1752       with_icao = 0;
1753     }
1754
1755   if (pk->main_keyid[0] == pk->keyid[0]
1756       && pk->main_keyid[1] == pk->keyid[1])
1757     primary = 1;
1758
1759   /* Just to be safe */
1760   if ((mode & 0x80) && !primary)
1761     {
1762       log_error ("primary key is not really primary!\n");
1763       return;
1764     }
1765
1766   mode &= ~0x80;
1767
1768   if (!primary && (mode == 1 || mode == 2))
1769     {
1770       PKT_public_key *primary_pk = xmalloc_clear (sizeof (*primary_pk));
1771       get_pubkey (primary_pk, pk->main_keyid);
1772       print_fingerprint (override_fp, primary_pk, (mode | 0x80));
1773       free_public_key (primary_pk);
1774     }
1775
1776   if (mode == 1)
1777     {
1778       fp = log_get_stream ();
1779       if (primary)
1780         text = _("Primary key fingerprint:");
1781       else
1782         text = _("     Subkey fingerprint:");
1783     }
1784   else if (mode == 2)
1785     {
1786       fp = override_fp; /* Use tty or given stream.  */
1787       if (primary)
1788         /* TRANSLATORS: this should fit into 24 bytes so that the
1789          * fingerprint data is properly aligned with the user ID */
1790         text = _(" Primary key fingerprint:");
1791       else
1792         text = _("      Subkey fingerprint:");
1793     }
1794   else if (mode == 3)
1795     {
1796       fp = override_fp; /* Use tty or given stream.  */
1797       text = _("      Key fingerprint =");
1798     }
1799   else if (mode == 4)
1800     {
1801       fp = override_fp; /* Use tty or given stream.  */
1802       text = _("      Subkey fingerprint:");
1803     }
1804   else
1805     {
1806       fp = override_fp? override_fp : es_stdout;
1807       text = _("      Key fingerprint =");
1808     }
1809
1810   fingerprint_from_pk (pk, array, &n);
1811   p = array;
1812   if (with_colons && !mode)
1813     {
1814       es_fprintf (fp, "fpr:::::::::");
1815       for (i = 0; i < n; i++, p++)
1816         es_fprintf (fp, "%02X", *p);
1817       es_putc (':', fp);
1818     }
1819   else
1820     {
1821       tty_fprintf (fp, "%s", text);
1822       if (n == 20)
1823         {
1824           for (i = 0; i < n; i++, i++, p += 2)
1825             tty_fprintf (fp, "%s %02X%02X", i==10? " ":"", *p, p[1]);
1826         }
1827       else
1828         {
1829           for (i = 0; i < n; i++, p++)
1830             tty_fprintf (fp, "%s %02X", (i && !(i % 8))? " ":"", *p);
1831         }
1832     }
1833   tty_fprintf (fp, "\n");
1834   if (!with_colons && with_icao)
1835     {
1836       p = array;
1837       tty_fprintf (fp, "%*s\"", (int)strlen(text)+1, "");
1838       for (i = 0; i < n; i++, p++)
1839         {
1840           if (!i)
1841             ;
1842           else if (!(i%4))
1843             tty_fprintf (fp, "\n%*s ", (int)strlen(text)+1, "");
1844           else if (!(i%2))
1845             tty_fprintf (fp, "  ");
1846           else
1847             tty_fprintf (fp, " ");
1848           print_icao_hexdigit (fp, *p >> 4);
1849           tty_fprintf (fp, " ");
1850           print_icao_hexdigit (fp, *p & 15);
1851         }
1852       tty_fprintf (fp, "\"\n");
1853     }
1854 }
1855
1856 /* Print the serial number of an OpenPGP card if available.  */
1857 static void
1858 print_card_serialno (const char *serialno)
1859 {
1860   if (!serialno)
1861     return;
1862   if (opt.with_colons)
1863     return; /* Handled elsewhere. */
1864
1865   es_fputs (_("      Card serial no. ="), es_stdout);
1866   es_putc (' ', es_stdout);
1867   if (strlen (serialno) == 32 && !strncmp (serialno, "D27600012401", 12))
1868     {
1869       /* This is an OpenPGP card.  Print the relevant part.  */
1870       /* Example: D2760001240101010001000003470000 */
1871       /*                          xxxxyyyyyyyy     */
1872       es_fprintf (es_stdout, "%.*s %.*s", 4, serialno+16, 8, serialno+20);
1873     }
1874  else
1875    es_fputs (serialno, es_stdout);
1876   es_putc ('\n', es_stdout);
1877 }
1878
1879
1880
1881 void
1882 set_attrib_fd (int fd)
1883 {
1884   static int last_fd = -1;
1885
1886   if (fd != -1 && last_fd == fd)
1887     return;
1888
1889   /* Fixme: Do we need to check for the log stream here?  */
1890   if (attrib_fp && attrib_fp != log_get_stream ())
1891     es_fclose (attrib_fp);
1892   attrib_fp = NULL;
1893   if (fd == -1)
1894     return;
1895
1896 #ifdef HAVE_DOSISH_SYSTEM
1897   setmode (fd, O_BINARY);
1898 #endif
1899   if (fd == 1)
1900     attrib_fp = es_stdout;
1901   else if (fd == 2)
1902     attrib_fp = es_stderr;
1903   else
1904     attrib_fp = es_fdopen (fd, "wb");
1905   if (!attrib_fp)
1906     {
1907       log_fatal ("can't open fd %d for attribute output: %s\n",
1908                  fd, strerror (errno));
1909     }
1910
1911   last_fd = fd;
1912 }