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