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