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