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