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