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