Release 2.1.12
[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 ();
134
135 #ifdef USE_TOFU
136   tofu_begin_batch_update ();
137 #endif
138
139   if (locate_mode)
140     locate_one (ctrl, list);
141   else if (!list)
142     list_all (ctrl, 0, opt.with_secret);
143   else
144     list_one (ctrl, list, 0, opt.with_secret);
145
146 #ifdef USE_TOFU
147   tofu_end_batch_update ();
148 #endif
149 }
150
151
152 void
153 secret_key_list (ctrl_t ctrl, strlist_t list)
154 {
155   (void)ctrl;
156
157   check_trustdb_stale ();
158
159   if (!list)
160     list_all (ctrl, 1, 0);
161   else                          /* List by user id */
162     list_one (ctrl, list, 1, 0);
163 }
164
165 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 (KBNODE 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 ();
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 (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 (pk, uid);
1138               indent = ((keystrlen () + (opt.legacy_list_mode? 9:11))
1139                         - atoi (uid_trust_string_fixed (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 (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 (KBNODE keyblock, int secret, int has_secret, int fpr)
1394 {
1395   int rc;
1396   KBNODE kbctx;
1397   KBNODE node;
1398   PKT_public_key *pk;
1399   u32 keyid[2];
1400   int trustletter = 0;
1401   int ulti_hack = 0;
1402   int i;
1403   char *p;
1404   char *hexgrip = NULL;
1405   char *serialno = NULL;
1406   int stubkey;
1407
1408   /* Get the keyid from the keyblock.  */
1409   node = find_kbnode (keyblock, PKT_PUBLIC_KEY);
1410   if (!node)
1411     {
1412       log_error ("Oops; key lost!\n");
1413       dump_kbnode (keyblock);
1414       return;
1415     }
1416
1417   pk = node->pkt->pkt.public_key;
1418   if (secret || has_secret || opt.with_keygrip || opt.with_key_data)
1419     {
1420       rc = hexkeygrip_from_pk (pk, &hexgrip);
1421       if (rc)
1422         log_error ("error computing a keygrip: %s\n", gpg_strerror (rc));
1423     }
1424   stubkey = 0;
1425   if ((secret||has_secret) && agent_get_keyinfo (NULL, hexgrip, &serialno))
1426     stubkey = 1;  /* Key not found.  */
1427
1428   keyid_from_pk (pk, keyid);
1429   es_fputs (secret? "sec:":"pub:", es_stdout);
1430   if (!pk->flags.valid)
1431     es_putc ('i', es_stdout);
1432   else if (pk->flags.revoked)
1433     es_putc ('r', es_stdout);
1434   else if (pk->has_expired)
1435     es_putc ('e', es_stdout);
1436   else if (opt.fast_list_mode || opt.no_expensive_trust_checks)
1437     ;
1438   else
1439     {
1440       trustletter = get_validity_info (pk, NULL);
1441       if (trustletter == 'u')
1442         ulti_hack = 1;
1443       es_putc (trustletter, es_stdout);
1444     }
1445
1446   es_fprintf (es_stdout, ":%u:%d:%08lX%08lX:%s:%s::",
1447           nbits_from_pk (pk),
1448           pk->pubkey_algo,
1449           (ulong) keyid[0], (ulong) keyid[1],
1450           colon_datestr_from_pk (pk), colon_strtime (pk->expiredate));
1451
1452   if (!opt.fast_list_mode && !opt.no_expensive_trust_checks)
1453     es_putc (get_ownertrust_info (pk), es_stdout);
1454   es_putc (':', es_stdout);
1455
1456   es_putc (':', es_stdout);
1457   es_putc (':', es_stdout);
1458   print_capabilities (pk, keyblock);
1459   es_putc (':', es_stdout);             /* End of field 13. */
1460   es_putc (':', es_stdout);             /* End of field 14. */
1461   if (secret || has_secret)
1462     {
1463       if (stubkey)
1464         es_putc ('#', es_stdout);
1465       else if (serialno)
1466         es_fputs (serialno, es_stdout);
1467       else if (has_secret)
1468         es_putc ('+', es_stdout);
1469     }
1470   es_putc (':', es_stdout);             /* End of field 15. */
1471   es_putc (':', es_stdout);             /* End of field 16. */
1472   if (pk->pubkey_algo == PUBKEY_ALGO_ECDSA
1473       || pk->pubkey_algo == PUBKEY_ALGO_EDDSA
1474       || pk->pubkey_algo == PUBKEY_ALGO_ECDH)
1475     {
1476       char *curve = openpgp_oid_to_str (pk->pkey[0]);
1477       const char *name = openpgp_oid_to_curve (curve, 0);
1478       if (!name)
1479         name = curve;
1480       es_fputs (name, es_stdout);
1481       xfree (curve);
1482     }
1483   es_putc (':', es_stdout);             /* End of field 17. */
1484   es_putc (':', es_stdout);             /* End of field 18. */
1485   es_putc ('\n', es_stdout);
1486
1487   print_revokers (es_stdout, pk);
1488   if (fpr)
1489     print_fingerprint (NULL, pk, 0);
1490   if (opt.with_key_data || opt.with_keygrip)
1491     {
1492       if (hexgrip)
1493         es_fprintf (es_stdout, "grp:::::::::%s:\n", hexgrip);
1494       if (opt.with_key_data)
1495         print_key_data (pk);
1496     }
1497
1498   for (kbctx = NULL; (node = walk_kbnode (keyblock, &kbctx, 0));)
1499     {
1500       if (node->pkt->pkttype == PKT_USER_ID)
1501         {
1502           char *str;
1503           PKT_user_id *uid = node->pkt->pkt.user_id;
1504
1505           if (attrib_fp && node->pkt->pkt.user_id->attrib_data != NULL)
1506             dump_attribs (node->pkt->pkt.user_id, pk);
1507           /*
1508            * Fixme: We need a valid flag here too
1509            */
1510           str = uid->attrib_data ? "uat" : "uid";
1511           if (uid->is_revoked)
1512             es_fprintf (es_stdout, "%s:r::::", str);
1513           else if (uid->is_expired)
1514             es_fprintf (es_stdout, "%s:e::::", str);
1515           else if (opt.no_expensive_trust_checks)
1516             es_fprintf (es_stdout, "%s:::::", str);
1517           else
1518             {
1519               int uid_validity;
1520
1521               if (!ulti_hack)
1522                 uid_validity = get_validity_info (pk, uid);
1523               else
1524                 uid_validity = 'u';
1525               es_fprintf (es_stdout, "%s:%c::::", str, uid_validity);
1526             }
1527
1528           es_fprintf (es_stdout, "%s:", colon_strtime (uid->created));
1529           es_fprintf (es_stdout, "%s:", colon_strtime (uid->expiredate));
1530
1531           namehash_from_uid (uid);
1532
1533           for (i = 0; i < 20; i++)
1534             es_fprintf (es_stdout, "%02X", uid->namehash[i]);
1535
1536           es_fprintf (es_stdout, "::");
1537
1538           if (uid->attrib_data)
1539             es_fprintf (es_stdout, "%u %lu", uid->numattribs, uid->attrib_len);
1540           else
1541             es_write_sanitized (es_stdout, uid->name, uid->len, ":", NULL);
1542           es_fprintf (es_stdout, "::::::::");
1543           if (opt.trust_model == TM_TOFU || opt.trust_model == TM_TOFU_PGP)
1544             {
1545 #ifdef USE_TOFU
1546               enum tofu_policy policy;
1547               if (! tofu_get_policy (pk, uid, &policy)
1548                   && policy != TOFU_POLICY_NONE)
1549                 es_fprintf (es_stdout, "%s", tofu_policy_str (policy));
1550 #endif /*USE_TOFU*/
1551             }
1552           es_putc (':', es_stdout);
1553           es_putc ('\n', es_stdout);
1554         }
1555       else if (node->pkt->pkttype == PKT_PUBLIC_SUBKEY)
1556         {
1557           u32 keyid2[2];
1558           PKT_public_key *pk2;
1559
1560           pk2 = node->pkt->pkt.public_key;
1561           xfree (hexgrip); hexgrip = NULL;
1562           xfree (serialno); serialno = NULL;
1563           if (secret || has_secret || opt.with_keygrip || opt.with_key_data)
1564             {
1565               rc = hexkeygrip_from_pk (pk2, &hexgrip);
1566               if (rc)
1567                 log_error ("error computing a keygrip: %s\n",
1568                            gpg_strerror (rc));
1569             }
1570           stubkey = 0;
1571           if ((secret||has_secret)
1572               && agent_get_keyinfo (NULL, hexgrip, &serialno))
1573             stubkey = 1;  /* Key not found.  */
1574
1575           keyid_from_pk (pk2, keyid2);
1576           es_fputs (secret? "ssb:":"sub:", es_stdout);
1577           if (!pk2->flags.valid)
1578             es_putc ('i', es_stdout);
1579           else if (pk2->flags.revoked)
1580             es_putc ('r', es_stdout);
1581           else if (pk2->has_expired)
1582             es_putc ('e', es_stdout);
1583           else if (opt.fast_list_mode || opt.no_expensive_trust_checks)
1584             ;
1585           else
1586             {
1587               /* TRUSTLETTER should always be defined here. */
1588               if (trustletter)
1589                 es_fprintf (es_stdout, "%c", trustletter);
1590             }
1591           es_fprintf (es_stdout, ":%u:%d:%08lX%08lX:%s:%s:::::",
1592                   nbits_from_pk (pk2),
1593                   pk2->pubkey_algo,
1594                   (ulong) keyid2[0], (ulong) keyid2[1],
1595                   colon_datestr_from_pk (pk2), colon_strtime (pk2->expiredate)
1596                   /* fixme: add LID and ownertrust here */
1597             );
1598           print_capabilities (pk2, NULL);
1599           es_putc (':', es_stdout);     /* End of field 13. */
1600           es_putc (':', es_stdout);     /* End of field 14. */
1601           if (secret || has_secret)
1602             {
1603               if (stubkey)
1604                 es_putc ('#', es_stdout);
1605               else if (serialno)
1606                 es_fputs (serialno, es_stdout);
1607               else if (has_secret)
1608                 es_putc ('+', es_stdout);
1609             }
1610           es_putc (':', es_stdout);     /* End of field 15. */
1611           es_putc (':', es_stdout);     /* End of field 16. */
1612           if (pk->pubkey_algo == PUBKEY_ALGO_ECDSA
1613               || pk->pubkey_algo == PUBKEY_ALGO_EDDSA
1614               || pk->pubkey_algo == PUBKEY_ALGO_ECDH)
1615             {
1616               char *curve = openpgp_oid_to_str (pk->pkey[0]);
1617               const char *name = openpgp_oid_to_curve (curve, 0);
1618               if (!name)
1619                 name = curve;
1620               es_fputs (name, es_stdout);
1621               xfree (curve);
1622             }
1623           es_putc (':', es_stdout);     /* End of field 17. */
1624           es_putc ('\n', es_stdout);
1625           if (fpr > 1)
1626             print_fingerprint (NULL, pk2, 0);
1627           if (opt.with_key_data || opt.with_keygrip)
1628             {
1629               if (hexgrip)
1630                 es_fprintf (es_stdout, "grp:::::::::%s:\n", hexgrip);
1631               if (opt.with_key_data)
1632                 print_key_data (pk2);
1633             }
1634         }
1635       else if (opt.list_sigs && node->pkt->pkttype == PKT_SIGNATURE)
1636         {
1637           PKT_signature *sig = node->pkt->pkt.signature;
1638           int sigrc, fprokay = 0;
1639           char *sigstr;
1640           size_t fplen;
1641           byte fparray[MAX_FINGERPRINT_LEN];
1642
1643           if (sig->sig_class == 0x20 || sig->sig_class == 0x28
1644               || sig->sig_class == 0x30)
1645             sigstr = "rev";
1646           else if ((sig->sig_class & ~3) == 0x10)
1647             sigstr = "sig";
1648           else if (sig->sig_class == 0x18)
1649             sigstr = "sig";
1650           else if (sig->sig_class == 0x1F)
1651             sigstr = "sig";
1652           else
1653             {
1654               es_fprintf (es_stdout, "sig::::::::::%02x%c:\n",
1655                       sig->sig_class, sig->flags.exportable ? 'x' : 'l');
1656               continue;
1657             }
1658
1659           if (opt.check_sigs)
1660             {
1661               PKT_public_key *signer_pk = NULL;
1662
1663               fflush (stdout);
1664               if (opt.no_sig_cache)
1665                 signer_pk = xmalloc_clear (sizeof (PKT_public_key));
1666
1667               rc = check_key_signature2 (keyblock, node, NULL, signer_pk,
1668                                          NULL, NULL, NULL);
1669               switch (gpg_err_code (rc))
1670                 {
1671                 case 0:
1672                   sigrc = '!';
1673                   break;
1674                 case GPG_ERR_BAD_SIGNATURE:
1675                   sigrc = '-';
1676                   break;
1677                 case GPG_ERR_NO_PUBKEY:
1678                 case GPG_ERR_UNUSABLE_PUBKEY:
1679                   sigrc = '?';
1680                   break;
1681                 default:
1682                   sigrc = '%';
1683                   break;
1684                 }
1685
1686               if (opt.no_sig_cache)
1687                 {
1688                   if (!rc)
1689                     {
1690                       fingerprint_from_pk (signer_pk, fparray, &fplen);
1691                       fprokay = 1;
1692                     }
1693                   free_public_key (signer_pk);
1694                 }
1695             }
1696           else
1697             {
1698               rc = 0;
1699               sigrc = ' ';
1700             }
1701           es_fputs (sigstr, es_stdout);
1702           es_putc (':', es_stdout);
1703           if (sigrc != ' ')
1704             es_putc (sigrc, es_stdout);
1705           es_fprintf (es_stdout, "::%d:%08lX%08lX:%s:%s:", sig->pubkey_algo,
1706                   (ulong) sig->keyid[0], (ulong) sig->keyid[1],
1707                   colon_datestr_from_sig (sig),
1708                   colon_expirestr_from_sig (sig));
1709
1710           if (sig->trust_depth || sig->trust_value)
1711             es_fprintf (es_stdout, "%d %d", sig->trust_depth, sig->trust_value);
1712           es_fprintf (es_stdout, ":");
1713
1714           if (sig->trust_regexp)
1715             es_write_sanitized (es_stdout, sig->trust_regexp,
1716                                 strlen (sig->trust_regexp), ":", NULL);
1717           es_fprintf (es_stdout, ":");
1718
1719           if (sigrc == '%')
1720             es_fprintf (es_stdout, "[%s] ", gpg_strerror (rc));
1721           else if (sigrc == '?')
1722             ;
1723           else if (!opt.fast_list_mode)
1724             {
1725               size_t n;
1726               p = get_user_id (sig->keyid, &n);
1727               es_write_sanitized (es_stdout, p, n, ":", NULL);
1728               xfree (p);
1729             }
1730           es_fprintf (es_stdout, ":%02x%c::", sig->sig_class,
1731                   sig->flags.exportable ? 'x' : 'l');
1732
1733           if (opt.no_sig_cache && opt.check_sigs && fprokay)
1734             {
1735               for (i = 0; i < fplen; i++)
1736                 es_fprintf (es_stdout, "%02X", fparray[i]);
1737             }
1738
1739           es_fprintf (es_stdout, ":::%d:\n", sig->digest_algo);
1740
1741           if (opt.show_subpackets)
1742             print_subpackets_colon (sig);
1743
1744           /* fixme: check or list other sigs here */
1745         }
1746     }
1747
1748   xfree (hexgrip);
1749   xfree (serialno);
1750 }
1751
1752 /*
1753  * Reorder the keyblock so that the primary user ID (and not attribute
1754  * packet) comes first.  Fixme: Replace this by a generic sort
1755  * function.  */
1756 static void
1757 do_reorder_keyblock (KBNODE keyblock, int attr)
1758 {
1759   KBNODE primary = NULL, primary0 = NULL, primary2 = NULL;
1760   KBNODE last, node;
1761
1762   for (node = keyblock; node; primary0 = node, node = node->next)
1763     {
1764       if (node->pkt->pkttype == PKT_USER_ID &&
1765           ((attr && node->pkt->pkt.user_id->attrib_data) ||
1766            (!attr && !node->pkt->pkt.user_id->attrib_data)) &&
1767           node->pkt->pkt.user_id->is_primary)
1768         {
1769           primary = primary2 = node;
1770           for (node = node->next; node; primary2 = node, node = node->next)
1771             {
1772               if (node->pkt->pkttype == PKT_USER_ID
1773                   || node->pkt->pkttype == PKT_PUBLIC_SUBKEY
1774                   || node->pkt->pkttype == PKT_SECRET_SUBKEY)
1775                 {
1776                   break;
1777                 }
1778             }
1779           break;
1780         }
1781     }
1782   if (!primary)
1783     return; /* No primary key flag found (should not happen).  */
1784
1785   for (last = NULL, node = keyblock; node; last = node, node = node->next)
1786     {
1787       if (node->pkt->pkttype == PKT_USER_ID)
1788         break;
1789     }
1790   log_assert (node);
1791   log_assert (last);     /* The user ID is never the first packet.  */
1792   log_assert (primary0); /* Ditto (this is the node before primary).  */
1793   if (node == primary)
1794     return; /* Already the first one.  */
1795
1796   last->next = primary;
1797   primary0->next = primary2->next;
1798   primary2->next = node;
1799 }
1800
1801 void
1802 reorder_keyblock (KBNODE keyblock)
1803 {
1804   do_reorder_keyblock (keyblock, 1);
1805   do_reorder_keyblock (keyblock, 0);
1806 }
1807
1808 static void
1809 list_keyblock (ctrl_t ctrl,
1810                KBNODE keyblock, int secret, int has_secret, int fpr,
1811                struct keylist_context *listctx)
1812 {
1813   reorder_keyblock (keyblock);
1814   if (opt.print_pka_records || opt.print_dane_records)
1815     list_keyblock_pka (ctrl, keyblock);
1816   else if (opt.with_colons)
1817     list_keyblock_colon (keyblock, secret, has_secret, fpr);
1818   else
1819     list_keyblock_print (keyblock, secret, fpr, listctx);
1820   if (secret)
1821     es_fflush (es_stdout);
1822 }
1823
1824
1825 /* Public function used by keygen to list a keyblock.  */
1826 void
1827 list_keyblock_direct (ctrl_t ctrl,
1828                       kbnode_t keyblock, int secret, int has_secret, int fpr)
1829 {
1830   struct keylist_context listctx;
1831
1832   memset (&listctx, 0, sizeof (listctx));
1833   list_keyblock (ctrl, keyblock, secret, has_secret, fpr, &listctx);
1834   keylist_context_release (&listctx);
1835 }
1836
1837
1838 /* Print an hex digit in ICAO spelling.  */
1839 static void
1840 print_icao_hexdigit (estream_t fp, int c)
1841 {
1842   static const char *list[16] = {
1843     "Zero", "One", "Two", "Three", "Four", "Five", "Six", "Seven",
1844     "Eight", "Niner", "Alfa", "Bravo", "Charlie", "Delta", "Echo", "Foxtrot"
1845   };
1846
1847   tty_fprintf (fp, "%s", list[c&15]);
1848 }
1849
1850
1851 /*
1852  * Function to print the finperprint.
1853  * mode 0: as used in key listings, opt.with_colons is honored
1854  *      1: print using log_info ()
1855  *      2: direct use of tty
1856  *      3: direct use of tty but only primary key.
1857  *      4: direct use of tty but only subkey.
1858  *     10: Same as 0 but with_colons etc is ignored.
1859  *
1860  * Modes 1 and 2 will try and print both subkey and primary key
1861  * fingerprints.  A MODE with bit 7 set is used internally.  If
1862  * OVERRIDE_FP is not NULL that stream will be used in  0 instead
1863  * of es_stdout or instead of the TTY in modes 2 and 3.
1864  */
1865 void
1866 print_fingerprint (estream_t override_fp, PKT_public_key *pk, int mode)
1867 {
1868   char hexfpr[2*MAX_FINGERPRINT_LEN+1];
1869   char *p;
1870   size_t i;
1871   estream_t fp;
1872   const char *text;
1873   int primary = 0;
1874   int with_colons = opt.with_colons;
1875   int with_icao   = opt.with_icao_spelling;
1876
1877   if (mode == 10)
1878     {
1879       mode = 0;
1880       with_colons = 0;
1881       with_icao = 0;
1882     }
1883
1884   if (pk->main_keyid[0] == pk->keyid[0]
1885       && pk->main_keyid[1] == pk->keyid[1])
1886     primary = 1;
1887
1888   /* Just to be safe */
1889   if ((mode & 0x80) && !primary)
1890     {
1891       log_error ("primary key is not really primary!\n");
1892       return;
1893     }
1894
1895   mode &= ~0x80;
1896
1897   if (!primary && (mode == 1 || mode == 2))
1898     {
1899       PKT_public_key *primary_pk = xmalloc_clear (sizeof (*primary_pk));
1900       get_pubkey (primary_pk, pk->main_keyid);
1901       print_fingerprint (override_fp, primary_pk, (mode | 0x80));
1902       free_public_key (primary_pk);
1903     }
1904
1905   if (mode == 1)
1906     {
1907       fp = log_get_stream ();
1908       if (primary)
1909         text = _("Primary key fingerprint:");
1910       else
1911         text = _("     Subkey fingerprint:");
1912     }
1913   else if (mode == 2)
1914     {
1915       fp = override_fp; /* Use tty or given stream.  */
1916       if (primary)
1917         /* TRANSLATORS: this should fit into 24 bytes so that the
1918          * fingerprint data is properly aligned with the user ID */
1919         text = _(" Primary key fingerprint:");
1920       else
1921         text = _("      Subkey fingerprint:");
1922     }
1923   else if (mode == 3)
1924     {
1925       fp = override_fp; /* Use tty or given stream.  */
1926       text = _("      Key fingerprint =");
1927     }
1928   else if (mode == 4)
1929     {
1930       fp = override_fp; /* Use tty or given stream.  */
1931       text = _("      Subkey fingerprint:");
1932     }
1933   else
1934     {
1935       fp = override_fp? override_fp : es_stdout;
1936       text = _("      Key fingerprint =");
1937     }
1938
1939   hexfingerprint (pk, hexfpr, sizeof hexfpr);
1940   if (with_colons && !mode)
1941     {
1942       es_fprintf (fp, "fpr:::::::::%s:", hexfpr);
1943     }
1944   else
1945     {
1946       char fmtfpr[MAX_FORMATTED_FINGERPRINT_LEN + 1];
1947       format_hexfingerprint (hexfpr, fmtfpr, sizeof fmtfpr);
1948       tty_fprintf (fp, "%s %s", text, fmtfpr);
1949     }
1950   tty_fprintf (fp, "\n");
1951   if (!with_colons && with_icao)
1952     {
1953       ;
1954       tty_fprintf (fp, "%*s\"", (int)strlen(text)+1, "");
1955       for (i = 0, p = hexfpr; *p; i++, p++)
1956         {
1957           if (!i)
1958             ;
1959           else if (!(i%8))
1960             tty_fprintf (fp, "\n%*s ", (int)strlen(text)+1, "");
1961           else if (!(i%4))
1962             tty_fprintf (fp, "  ");
1963           else
1964             tty_fprintf (fp, " ");
1965           print_icao_hexdigit (fp, xtoi_1 (p));
1966         }
1967       tty_fprintf (fp, "\"\n");
1968     }
1969 }
1970
1971 /* Print the serial number of an OpenPGP card if available.  */
1972 static void
1973 print_card_serialno (const char *serialno)
1974 {
1975   if (!serialno)
1976     return;
1977   if (opt.with_colons)
1978     return; /* Handled elsewhere. */
1979
1980   es_fputs (_("      Card serial no. ="), es_stdout);
1981   es_putc (' ', es_stdout);
1982   if (strlen (serialno) == 32 && !strncmp (serialno, "D27600012401", 12))
1983     {
1984       /* This is an OpenPGP card.  Print the relevant part.  */
1985       /* Example: D2760001240101010001000003470000 */
1986       /*                          xxxxyyyyyyyy     */
1987       es_fprintf (es_stdout, "%.*s %.*s", 4, serialno+16, 8, serialno+20);
1988     }
1989  else
1990    es_fputs (serialno, es_stdout);
1991   es_putc ('\n', es_stdout);
1992 }
1993
1994
1995
1996 void
1997 set_attrib_fd (int fd)
1998 {
1999   static int last_fd = -1;
2000
2001   if (fd != -1 && last_fd == fd)
2002     return;
2003
2004   /* Fixme: Do we need to check for the log stream here?  */
2005   if (attrib_fp && attrib_fp != log_get_stream ())
2006     es_fclose (attrib_fp);
2007   attrib_fp = NULL;
2008   if (fd == -1)
2009     return;
2010
2011 #ifdef HAVE_DOSISH_SYSTEM
2012   setmode (fd, O_BINARY);
2013 #endif
2014   if (fd == 1)
2015     attrib_fp = es_stdout;
2016   else if (fd == 2)
2017     attrib_fp = es_stderr;
2018   else
2019     attrib_fp = es_fdopen (fd, "wb");
2020   if (!attrib_fp)
2021     {
2022       log_fatal ("can't open fd %d for attribute output: %s\n",
2023                  fd, strerror (errno));
2024     }
2025
2026   last_fd = fd;
2027 }