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