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