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