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