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