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