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