e67c2d8d3ab3a138ce19fb3b32fc36bc924ed15a
[gnupg.git] / sm / keylist.c
1 /* keylist.c - Print certificates in various formats.
2  * Copyright (C) 1998, 1999, 2000, 2001, 2003,
3  *               2004, 2005, 2008, 2009 Free Software Foundation, Inc.
4  *
5  * This file is part of GnuPG.
6  *
7  * GnuPG is free software; you can redistribute it and/or modify
8  * it under the terms of the GNU General Public License as published by
9  * the Free Software Foundation; either version 3 of the License, or
10  * (at your option) any later version.
11  *
12  * GnuPG is distributed in the hope that it will be useful,
13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15  * GNU General Public License for more details.
16  *
17  * You should have received a copy of the GNU General Public License
18  * along with this program; if not, see <http://www.gnu.org/licenses/>.
19  */
20
21 #include <config.h>
22 #include <stdio.h>
23 #include <stdlib.h>
24 #include <string.h>
25 #include <errno.h>
26 #include <unistd.h>
27 #include <time.h>
28 #include <assert.h>
29
30 #include "gpgsm.h"
31
32 #include <gcrypt.h>
33 #include <ksba.h>
34
35 #include "keydb.h"
36 #include "../kbx/keybox.h" /* for KEYBOX_FLAG_* */
37 #include "i18n.h"
38 #include "tlv.h"
39
40 struct list_external_parm_s
41 {
42   ctrl_t ctrl;
43   estream_t fp;
44   int print_header;
45   int with_colons;
46   int with_chain;
47   int raw_mode;
48 };
49
50
51 /* This table is to map Extended Key Usage OIDs to human readable
52    names.  */
53 struct
54 {
55   const char *oid;
56   const char *name;
57 } key_purpose_map[] = {
58   { "1.3.6.1.5.5.7.3.1",  "serverAuth" },
59   { "1.3.6.1.5.5.7.3.2",  "clientAuth" },
60   { "1.3.6.1.5.5.7.3.3",  "codeSigning" },
61   { "1.3.6.1.5.5.7.3.4",  "emailProtection" },
62   { "1.3.6.1.5.5.7.3.5",  "ipsecEndSystem" },
63   { "1.3.6.1.5.5.7.3.6",  "ipsecTunnel" },
64   { "1.3.6.1.5.5.7.3.7",  "ipsecUser" },
65   { "1.3.6.1.5.5.7.3.8",  "timeStamping" },
66   { "1.3.6.1.5.5.7.3.9",  "ocspSigning" },
67   { "1.3.6.1.5.5.7.3.10", "dvcs" },
68   { "1.3.6.1.5.5.7.3.11", "sbgpCertAAServerAuth" },
69   { "1.3.6.1.5.5.7.3.13", "eapOverPPP" },
70   { "1.3.6.1.5.5.7.3.14", "wlanSSID" },
71
72   { "2.16.840.1.113730.4.1", "serverGatedCrypto.ns" }, /* Netscape. */
73   { "1.3.6.1.4.1.311.10.3.3", "serverGatedCrypto.ms"}, /* Microsoft. */
74
75   { "1.3.6.1.5.5.7.48.1.5", "ocspNoCheck" },
76
77   { NULL, NULL }
78 };
79
80
81 /* Do not print this extension in the list of extensions.  This is set
82    for oids which are already available via ksba fucntions. */
83 #define OID_FLAG_SKIP 1
84 /* The extension is a simple UTF8String and should be printed.  */
85 #define OID_FLAG_UTF8 2
86
87 /* A table mapping OIDs to a descriptive string. */
88 static struct
89 {
90   char *oid;
91   char *name;
92   unsigned int flag; /* A flag as described above.  */
93 } oidtranstbl[] = {
94
95   /* Algorithms. */
96   { "1.2.840.10040.4.1", "dsa" },
97   { "1.2.840.10040.4.3", "dsaWithSha1" },
98
99   { "1.2.840.113549.1.1.1", "rsaEncryption" },
100   { "1.2.840.113549.1.1.2", "md2WithRSAEncryption" },
101   { "1.2.840.113549.1.1.3", "md4WithRSAEncryption" },
102   { "1.2.840.113549.1.1.4", "md5WithRSAEncryption" },
103   { "1.2.840.113549.1.1.5", "sha1WithRSAEncryption" },
104   { "1.2.840.113549.1.1.7", "rsaOAEP" },
105   { "1.2.840.113549.1.1.8", "rsaOAEP-MGF" },
106   { "1.2.840.113549.1.1.9", "rsaOAEP-pSpecified" },
107   { "1.2.840.113549.1.1.10", "rsaPSS" },
108   { "1.2.840.113549.1.1.11", "sha256WithRSAEncryption" },
109   { "1.2.840.113549.1.1.12", "sha384WithRSAEncryption" },
110   { "1.2.840.113549.1.1.13", "sha512WithRSAEncryption" },
111
112   { "1.3.14.3.2.26", "sha1" },
113   { "1.3.14.3.2.29",  "sha-1WithRSAEncryption" },
114   { "1.3.36.3.3.1.2", "rsaSignatureWithripemd160" },
115
116
117   /* Telesec extensions. */
118   { "0.2.262.1.10.12.0", "certExtensionLiabilityLimitationExt" },
119   { "0.2.262.1.10.12.1", "telesecCertIdExt" },
120   { "0.2.262.1.10.12.2", "telesecPolicyIdentifier" },
121   { "0.2.262.1.10.12.3", "telesecPolicyQualifierID" },
122   { "0.2.262.1.10.12.4", "telesecCRLFilteredExt" },
123   { "0.2.262.1.10.12.5", "telesecCRLFilterExt"},
124   { "0.2.262.1.10.12.6", "telesecNamingAuthorityExt" },
125 #define OIDSTR_restriction \
126     "1.3.36.8.3.8"
127   { OIDSTR_restriction,      "restriction", OID_FLAG_UTF8 },
128
129
130   /* PKIX private extensions. */
131   { "1.3.6.1.5.5.7.1.1", "authorityInfoAccess" },
132   { "1.3.6.1.5.5.7.1.2", "biometricInfo" },
133   { "1.3.6.1.5.5.7.1.3", "qcStatements" },
134   { "1.3.6.1.5.5.7.1.4", "acAuditIdentity" },
135   { "1.3.6.1.5.5.7.1.5", "acTargeting" },
136   { "1.3.6.1.5.5.7.1.6", "acAaControls" },
137   { "1.3.6.1.5.5.7.1.7", "sbgp-ipAddrBlock" },
138   { "1.3.6.1.5.5.7.1.8", "sbgp-autonomousSysNum" },
139   { "1.3.6.1.5.5.7.1.9", "sbgp-routerIdentifier" },
140   { "1.3.6.1.5.5.7.1.10", "acProxying" },
141   { "1.3.6.1.5.5.7.1.11", "subjectInfoAccess" },
142
143   { "1.3.6.1.5.5.7.48.1", "ocsp" },
144   { "1.3.6.1.5.5.7.48.2", "caIssuers" },
145   { "1.3.6.1.5.5.7.48.3", "timeStamping" },
146   { "1.3.6.1.5.5.7.48.5", "caRepository" },
147
148   /* X.509 id-ce */
149   { "2.5.29.14", "subjectKeyIdentifier", OID_FLAG_SKIP},
150   { "2.5.29.15", "keyUsage", OID_FLAG_SKIP},
151   { "2.5.29.16", "privateKeyUsagePeriod" },
152   { "2.5.29.17", "subjectAltName", OID_FLAG_SKIP},
153   { "2.5.29.18", "issuerAltName", OID_FLAG_SKIP},
154   { "2.5.29.19", "basicConstraints", OID_FLAG_SKIP},
155   { "2.5.29.20", "cRLNumber" },
156   { "2.5.29.21", "cRLReason" },
157   { "2.5.29.22", "expirationDate" },
158   { "2.5.29.23", "instructionCode" },
159   { "2.5.29.24", "invalidityDate" },
160   { "2.5.29.27", "deltaCRLIndicator" },
161   { "2.5.29.28", "issuingDistributionPoint" },
162   { "2.5.29.29", "certificateIssuer" },
163   { "2.5.29.30", "nameConstraints" },
164   { "2.5.29.31", "cRLDistributionPoints", OID_FLAG_SKIP},
165   { "2.5.29.32", "certificatePolicies", OID_FLAG_SKIP},
166   { "2.5.29.32.0", "anyPolicy" },
167   { "2.5.29.33", "policyMappings" },
168   { "2.5.29.35", "authorityKeyIdentifier", OID_FLAG_SKIP},
169   { "2.5.29.36", "policyConstraints" },
170   { "2.5.29.37", "extKeyUsage", OID_FLAG_SKIP},
171   { "2.5.29.46", "freshestCRL" },
172   { "2.5.29.54", "inhibitAnyPolicy" },
173
174   /* Netscape certificate extensions. */
175   { "2.16.840.1.113730.1.1", "netscape-cert-type" },
176   { "2.16.840.1.113730.1.2", "netscape-base-url" },
177   { "2.16.840.1.113730.1.3", "netscape-revocation-url" },
178   { "2.16.840.1.113730.1.4", "netscape-ca-revocation-url" },
179   { "2.16.840.1.113730.1.7", "netscape-cert-renewal-url" },
180   { "2.16.840.1.113730.1.8", "netscape-ca-policy-url" },
181   { "2.16.840.1.113730.1.9", "netscape-homePage-url" },
182   { "2.16.840.1.113730.1.10", "netscape-entitylogo" },
183   { "2.16.840.1.113730.1.11", "netscape-userPicture" },
184   { "2.16.840.1.113730.1.12", "netscape-ssl-server-name" },
185   { "2.16.840.1.113730.1.13", "netscape-comment" },
186
187   /* GnuPG extensions */
188   { "1.3.6.1.4.1.11591.2.1.1", "pkaAddress" },
189   { "1.3.6.1.4.1.11591.2.2.1", "standaloneCertificate" },
190
191   /* Extensions used by the Bundesnetzagentur.  */
192   { "1.3.6.1.4.1.8301.3.5", "validityModel" },
193
194   { NULL }
195 };
196
197
198 /* Return the description for OID; if no description is available
199    NULL is returned. */
200 static const char *
201 get_oid_desc (const char *oid, unsigned int *flag)
202 {
203   int i;
204
205   if (oid)
206     for (i=0; oidtranstbl[i].oid; i++)
207       if (!strcmp (oidtranstbl[i].oid, oid))
208         {
209           if (flag)
210             *flag = oidtranstbl[i].flag;
211           return oidtranstbl[i].name;
212         }
213   if (flag)
214     *flag = 0;
215   return NULL;
216 }
217
218
219 static void
220 print_key_data (ksba_cert_t cert, estream_t fp)
221 {
222 #if 0
223   int n = pk ? pubkey_get_npkey( pk->pubkey_algo ) : 0;
224   int i;
225
226   for(i=0; i < n; i++ )
227     {
228       es_fprintf (fp, "pkd:%d:%u:", i, mpi_get_nbits( pk->pkey[i] ) );
229       mpi_print(stdout, pk->pkey[i], 1 );
230       putchar(':');
231       putchar('\n');
232     }
233 #else
234   (void)cert;
235   (void)fp;
236 #endif
237 }
238
239 static void
240 print_capabilities (ksba_cert_t cert, estream_t fp)
241 {
242   gpg_error_t err;
243   unsigned int use;
244   size_t buflen;
245   char buffer[1];
246
247   err = ksba_cert_get_user_data (cert, "is_qualified",
248                                  &buffer, sizeof (buffer), &buflen);
249   if (!err && buflen)
250     {
251       if (*buffer)
252         es_putc ('q', fp);
253     }
254   else if (gpg_err_code (err) == GPG_ERR_NOT_FOUND)
255     ; /* Don't know - will not get marked as 'q' */
256   else
257     log_debug ("get_user_data(is_qualified) failed: %s\n",
258                gpg_strerror (err));
259
260   err = ksba_cert_get_key_usage (cert, &use);
261   if (gpg_err_code (err) == GPG_ERR_NO_DATA)
262     {
263       es_putc ('e', fp);
264       es_putc ('s', fp);
265       es_putc ('c', fp);
266       es_putc ('E', fp);
267       es_putc ('S', fp);
268       es_putc ('C', fp);
269       return;
270     }
271   if (err)
272     {
273       log_error (_("error getting key usage information: %s\n"),
274                  gpg_strerror (err));
275       return;
276     }
277
278   if ((use & (KSBA_KEYUSAGE_KEY_ENCIPHERMENT|KSBA_KEYUSAGE_DATA_ENCIPHERMENT)))
279     es_putc ('e', fp);
280   if ((use & (KSBA_KEYUSAGE_DIGITAL_SIGNATURE|KSBA_KEYUSAGE_NON_REPUDIATION)))
281     es_putc ('s', fp);
282   if ((use & KSBA_KEYUSAGE_KEY_CERT_SIGN))
283     es_putc ('c', fp);
284   if ((use & (KSBA_KEYUSAGE_KEY_ENCIPHERMENT|KSBA_KEYUSAGE_DATA_ENCIPHERMENT)))
285     es_putc ('E', fp);
286   if ((use & (KSBA_KEYUSAGE_DIGITAL_SIGNATURE|KSBA_KEYUSAGE_NON_REPUDIATION)))
287     es_putc ('S', fp);
288   if ((use & KSBA_KEYUSAGE_KEY_CERT_SIGN))
289     es_putc ('C', fp);
290
291   es_putc (':', fp);
292 }
293
294
295 static void
296 print_time (gnupg_isotime_t t, estream_t fp)
297 {
298   if (!t || !*t)
299     ;
300   else
301     es_fputs (t, fp);
302 }
303
304
305 /* Return an allocated string with the email address extracted from a
306    DN.  Note hat we use this code also in ../kbx/keybox-blob.c.  */
307 static char *
308 email_kludge (const char *name)
309 {
310   const char *p, *string;
311   unsigned char *buf;
312   int n;
313
314   string = name;
315   for (;;)
316     {
317       p = strstr (string, "1.2.840.113549.1.9.1=#");
318       if (!p)
319         return NULL;
320       if (p == name || (p > string+1 && p[-1] == ',' && p[-2] != '\\'))
321         {
322           name = p + 22;
323           break;
324         }
325       string = p + 22;
326     }
327
328
329   /* This looks pretty much like an email address in the subject's DN
330      we use this to add an additional user ID entry.  This way,
331      OpenSSL generated keys get a nicer and usable listing.  */
332   for (n=0, p=name; hexdigitp (p) && hexdigitp (p+1); p +=2, n++)
333     ;
334   if (!n)
335     return NULL;
336   buf = xtrymalloc (n+3);
337   if (!buf)
338     return NULL; /* oops, out of core */
339   *buf = '<';
340   for (n=1, p=name; hexdigitp (p); p +=2, n++)
341     buf[n] = xtoi_2 (p);
342   buf[n++] = '>';
343   buf[n] = 0;
344   return (char*)buf;
345 }
346
347
348
349
350 /* List one certificate in colon mode */
351 static void
352 list_cert_colon (ctrl_t ctrl, ksba_cert_t cert, unsigned int validity,
353                  estream_t fp, int have_secret)
354 {
355   int rc;
356   int idx;
357   char truststring[2];
358   char *p;
359   ksba_sexp_t sexp;
360   char *fpr;
361   ksba_isotime_t t;
362   gpg_error_t valerr;
363   int algo;
364   unsigned int nbits;
365   const char *chain_id;
366   char *chain_id_buffer = NULL;
367   int is_root = 0;
368   char *kludge_uid;
369
370   if (ctrl->with_validation)
371     valerr = gpgsm_validate_chain (ctrl, cert, "", NULL, 1, NULL, 0, NULL);
372   else
373     valerr = 0;
374
375
376   /* We need to get the fingerprint and the chaining ID in advance. */
377   fpr = gpgsm_get_fingerprint_hexstring (cert, GCRY_MD_SHA1);
378   {
379     ksba_cert_t next;
380
381     rc = gpgsm_walk_cert_chain (ctrl, cert, &next);
382     if (!rc) /* We known the issuer's certificate. */
383       {
384         p = gpgsm_get_fingerprint_hexstring (next, GCRY_MD_SHA1);
385         chain_id_buffer = p;
386         chain_id = chain_id_buffer;
387         ksba_cert_release (next);
388       }
389     else if (rc == -1)  /* We have reached the root certificate. */
390       {
391         chain_id = fpr;
392         is_root = 1;
393       }
394     else
395       chain_id = NULL;
396   }
397
398
399   es_fputs (have_secret? "crs:":"crt:", fp);
400
401   /* Note: We can't use multiple flags, like "ei", because the
402      validation check does only return one error.  */
403   truststring[0] = 0;
404   truststring[1] = 0;
405   if ((validity & VALIDITY_REVOKED)
406       || gpg_err_code (valerr) == GPG_ERR_CERT_REVOKED)
407     *truststring = 'r';
408   else if (gpg_err_code (valerr) == GPG_ERR_CERT_EXPIRED)
409     *truststring = 'e';
410   else
411     {
412       /* Lets also check whether the certificate under question
413          expired.  This is merely a hack until we found a proper way
414          to store the expiration flag in the keybox. */
415       ksba_isotime_t current_time, not_after;
416
417       gnupg_get_isotime (current_time);
418       if (!opt.ignore_expiration
419           && !ksba_cert_get_validity (cert, 1, not_after)
420           && *not_after && strcmp (current_time, not_after) > 0 )
421         *truststring = 'e';
422       else if (valerr)
423         *truststring = 'i';
424       else if (ctrl->with_validation && !is_root)
425         *truststring = 'f';
426     }
427
428   /* If we have no truststring yet (i.e. the certificate might be
429      good) and this is a root certificate, we ask the agent whether
430      this is a trusted root certificate. */
431   if (!*truststring && is_root)
432     {
433       struct rootca_flags_s dummy_flags;
434
435       rc = gpgsm_agent_istrusted (ctrl, cert, NULL, &dummy_flags);
436       if (!rc)
437         *truststring = 'u';  /* Yes, we trust this one (ultimately). */
438       else if (gpg_err_code (rc) == GPG_ERR_NOT_TRUSTED)
439         *truststring = 'n';  /* No, we do not trust this one. */
440       /* (in case of an error we can't tell anything.) */
441     }
442
443   if (*truststring)
444     es_fputs (truststring, fp);
445
446   algo = gpgsm_get_key_algo_info (cert, &nbits);
447   es_fprintf (fp, ":%u:%d:%s:", nbits, algo, fpr+24);
448
449   /* We assume --fixed-list-mode for gpgsm */
450   ksba_cert_get_validity (cert, 0, t);
451   print_time (t, fp);
452   es_putc (':', fp);
453   ksba_cert_get_validity (cert, 1, t);
454   print_time ( t, fp);
455   es_putc (':', fp);
456   /* Field 8, serial number: */
457   if ((sexp = ksba_cert_get_serial (cert)))
458     {
459       int len;
460       const unsigned char *s = sexp;
461
462       if (*s == '(')
463         {
464           s++;
465           for (len=0; *s && *s != ':' && digitp (s); s++)
466             len = len*10 + atoi_1 (s);
467           if (*s == ':')
468             for (s++; len; len--, s++)
469               es_fprintf (fp,"%02X", *s);
470         }
471       xfree (sexp);
472     }
473   es_putc (':', fp);
474   /* Field 9, ownertrust - not used here */
475   es_putc (':', fp);
476   /* field 10, old user ID - we use it here for the issuer DN */
477   if ((p = ksba_cert_get_issuer (cert,0)))
478     {
479       es_write_sanitized (fp, p, strlen (p), ":", NULL);
480       xfree (p);
481     }
482   es_putc (':', fp);
483   /* Field 11, signature class - not used */
484   es_putc (':', fp);
485   /* Field 12, capabilities: */
486   print_capabilities (cert, fp);
487   /* Field 13, not used: */
488   es_putc (':', fp);
489   if (have_secret)
490     {
491       char *cardsn;
492
493       p = gpgsm_get_keygrip_hexstring (cert);
494       if (!gpgsm_agent_keyinfo (ctrl, p, &cardsn) && cardsn)
495         {
496           /* Field 14, not used: */
497           es_putc (':', fp);
498           /* Field 15:  Token serial number.  */
499           es_fputs (cardsn, fp);
500           es_putc (':', fp);
501         }
502       xfree (cardsn);
503       xfree (p);
504     }
505   es_putc ('\n', fp);
506
507   /* FPR record */
508   es_fprintf (fp, "fpr:::::::::%s:::", fpr);
509   /* Print chaining ID (field 13)*/
510   if (chain_id)
511     es_fputs (chain_id, fp);
512   es_putc (':', fp);
513   es_putc ('\n', fp);
514   xfree (fpr); fpr = NULL; chain_id = NULL;
515   xfree (chain_id_buffer); chain_id_buffer = NULL;
516
517   if (opt.with_key_data)
518     {
519       if ( (p = gpgsm_get_keygrip_hexstring (cert)))
520         {
521           es_fprintf (fp, "grp:::::::::%s:\n", p);
522           xfree (p);
523         }
524       print_key_data (cert, fp);
525     }
526
527   kludge_uid = NULL;
528   for (idx=0; (p = ksba_cert_get_subject (cert,idx)); idx++)
529     {
530       /* In the case that the same email address is in the subject DN
531          as well as in an alternate subject name we avoid printing it
532          a second time. */
533       if (kludge_uid && !strcmp (kludge_uid, p))
534         continue;
535
536       es_fprintf (fp, "uid:%s::::::::", truststring);
537       es_write_sanitized (fp, p, strlen (p), ":", NULL);
538       es_putc (':', fp);
539       es_putc (':', fp);
540       es_putc ('\n', fp);
541       if (!idx)
542         {
543           /* It would be better to get the faked email address from
544              the keydb.  But as long as we don't have a way to pass
545              the meta data back, we just check it the same way as the
546              code used to create the keybox meta data does */
547           kludge_uid = email_kludge (p);
548           if (kludge_uid)
549             {
550               es_fprintf (fp, "uid:%s::::::::", truststring);
551               es_write_sanitized (fp, kludge_uid, strlen (kludge_uid),
552                                   ":", NULL);
553               es_putc (':', fp);
554               es_putc (':', fp);
555               es_putc ('\n', fp);
556             }
557         }
558       xfree (p);
559     }
560   xfree (kludge_uid);
561 }
562
563
564 static void
565 print_name_raw (estream_t fp, const char *string)
566 {
567   if (!string)
568     es_fputs ("[error]", fp);
569   else
570     es_write_sanitized (fp, string, strlen (string), NULL, NULL);
571 }
572
573 static void
574 print_names_raw (estream_t fp, int indent, ksba_name_t name)
575 {
576   int idx;
577   const char *s;
578   int indent_all;
579
580   if ((indent_all = (indent < 0)))
581     indent = - indent;
582
583   if (!name)
584     {
585       es_fputs ("none\n", fp);
586       return;
587     }
588
589   for (idx=0; (s = ksba_name_enum (name, idx)); idx++)
590     {
591       char *p = ksba_name_get_uri (name, idx);
592       es_fprintf (fp, "%*s", idx||indent_all?indent:0, "");
593       es_write_sanitized (fp, p?p:s, strlen (p?p:s), NULL, NULL);
594       es_putc ('\n', fp);
595       xfree (p);
596     }
597 }
598
599
600 static void
601 print_utf8_extn_raw (estream_t fp, int indent,
602                      const unsigned char *der, size_t derlen)
603 {
604   gpg_error_t err;
605   int class, tag, constructed, ndef;
606   size_t objlen, hdrlen;
607
608   if (indent < 0)
609     indent = - indent;
610
611   err = parse_ber_header (&der, &derlen, &class, &tag, &constructed,
612                           &ndef, &objlen, &hdrlen);
613   if (!err && (objlen > derlen || tag != TAG_UTF8_STRING))
614     err = gpg_error (GPG_ERR_INV_OBJ);
615   if (err)
616     {
617       es_fprintf (fp, "%*s[%s]\n", indent, "", gpg_strerror (err));
618       return;
619     }
620   es_fprintf (fp, "%*s(%.*s)\n", indent, "", (int)objlen, der);
621 }
622
623
624 static void
625 print_utf8_extn (estream_t fp, int indent,
626                  const unsigned char *der, size_t derlen)
627 {
628   gpg_error_t err;
629   int class, tag, constructed, ndef;
630   size_t objlen, hdrlen;
631   int indent_all;
632
633   if ((indent_all = (indent < 0)))
634     indent = - indent;
635
636   err = parse_ber_header (&der, &derlen, &class, &tag, &constructed,
637                           &ndef, &objlen, &hdrlen);
638   if (!err && (objlen > derlen || tag != TAG_UTF8_STRING))
639     err = gpg_error (GPG_ERR_INV_OBJ);
640   if (err)
641     {
642       es_fprintf (fp, "%*s[%s%s]\n",
643                   indent_all? indent:0, "", _("Error - "), gpg_strerror (err));
644       return;
645     }
646   es_fprintf (fp, "%*s\"", indent_all? indent:0, "");
647   /* Fixme: we should implement word wrapping */
648   es_write_sanitized (fp, der, objlen, "\"", NULL);
649   es_fputs ("\"\n", fp);
650 }
651
652
653 /* List one certificate in raw mode useful to have a closer look at
654    the certificate.  This one does no beautification and only minimal
655    output sanitation.  It is mainly useful for debugging. */
656 static void
657 list_cert_raw (ctrl_t ctrl, KEYDB_HANDLE hd,
658                ksba_cert_t cert, estream_t fp, int have_secret,
659                int with_validation)
660 {
661   gpg_error_t err;
662   size_t off, len;
663   ksba_sexp_t sexp, keyid;
664   char *dn;
665   ksba_isotime_t t;
666   int idx, i;
667   int is_ca, chainlen;
668   unsigned int kusage;
669   char *string, *p, *pend;
670   const char *oid, *s;
671   ksba_name_t name, name2;
672   unsigned int reason;
673   const unsigned char *cert_der = NULL;
674
675   (void)have_secret;
676
677   es_fprintf (fp, "           ID: 0x%08lX\n",
678               gpgsm_get_short_fingerprint (cert, NULL));
679
680   sexp = ksba_cert_get_serial (cert);
681   es_fputs ("          S/N: ", fp);
682   gpgsm_print_serial (fp, sexp);
683   ksba_free (sexp);
684   es_putc ('\n', fp);
685
686   dn = ksba_cert_get_issuer (cert, 0);
687   es_fputs ("       Issuer: ", fp);
688   print_name_raw (fp, dn);
689   ksba_free (dn);
690   es_putc ('\n', fp);
691   for (idx=1; (dn = ksba_cert_get_issuer (cert, idx)); idx++)
692     {
693       es_fputs ("          aka: ", fp);
694       print_name_raw (fp, dn);
695       ksba_free (dn);
696       es_putc ('\n', fp);
697     }
698
699   dn = ksba_cert_get_subject (cert, 0);
700   es_fputs ("      Subject: ", fp);
701   print_name_raw (fp, dn);
702   ksba_free (dn);
703   es_putc ('\n', fp);
704   for (idx=1; (dn = ksba_cert_get_subject (cert, idx)); idx++)
705     {
706       es_fputs ("          aka: ", fp);
707       print_name_raw (fp, dn);
708       ksba_free (dn);
709       es_putc ('\n', fp);
710     }
711
712   dn = gpgsm_get_fingerprint_string (cert, 0);
713   es_fprintf (fp, "     sha1_fpr: %s\n", dn?dn:"error");
714   xfree (dn);
715
716   dn = gpgsm_get_fingerprint_string (cert, GCRY_MD_MD5);
717   es_fprintf (fp, "      md5_fpr: %s\n", dn?dn:"error");
718   xfree (dn);
719
720   dn = gpgsm_get_certid (cert);
721   es_fprintf (fp, "       certid: %s\n", dn?dn:"error");
722   xfree (dn);
723
724   dn = gpgsm_get_keygrip_hexstring (cert);
725   es_fprintf (fp, "      keygrip: %s\n", dn?dn:"error");
726   xfree (dn);
727
728   ksba_cert_get_validity (cert, 0, t);
729   es_fputs ("    notBefore: ", fp);
730   gpgsm_print_time (fp, t);
731   es_putc ('\n', fp);
732   es_fputs ("     notAfter: ", fp);
733   ksba_cert_get_validity (cert, 1, t);
734   gpgsm_print_time (fp, t);
735   es_putc ('\n', fp);
736
737   oid = ksba_cert_get_digest_algo (cert);
738   s = get_oid_desc (oid, NULL);
739   es_fprintf (fp, "     hashAlgo: %s%s%s%s\n", oid, s?" (":"",s?s:"",s?")":"");
740
741   {
742     const char *algoname;
743     unsigned int nbits;
744
745     algoname = gcry_pk_algo_name (gpgsm_get_key_algo_info (cert, &nbits));
746     es_fprintf (fp, "      keyType: %u bit %s\n",
747                 nbits, algoname? algoname:"?");
748   }
749
750   /* subjectKeyIdentifier */
751   es_fputs ("    subjKeyId: ", fp);
752   err = ksba_cert_get_subj_key_id (cert, NULL, &keyid);
753   if (!err || gpg_err_code (err) == GPG_ERR_NO_DATA)
754     {
755       if (gpg_err_code (err) == GPG_ERR_NO_DATA)
756         es_fputs ("[none]\n", fp);
757       else
758         {
759           gpgsm_print_serial (fp, keyid);
760           ksba_free (keyid);
761           es_putc ('\n', fp);
762         }
763     }
764   else
765     es_fputs ("[?]\n", fp);
766
767
768   /* authorityKeyIdentifier */
769   es_fputs ("    authKeyId: ", fp);
770   err = ksba_cert_get_auth_key_id (cert, &keyid, &name, &sexp);
771   if (!err || gpg_err_code (err) == GPG_ERR_NO_DATA)
772     {
773       if (gpg_err_code (err) == GPG_ERR_NO_DATA || !name)
774         es_fputs ("[none]\n", fp);
775       else
776         {
777           gpgsm_print_serial (fp, sexp);
778           ksba_free (sexp);
779           es_putc ('\n', fp);
780           print_names_raw (fp, -15, name);
781           ksba_name_release (name);
782         }
783       if (keyid)
784         {
785           es_fputs (" authKeyId.ki: ", fp);
786           gpgsm_print_serial (fp, keyid);
787           ksba_free (keyid);
788           es_putc ('\n', fp);
789         }
790     }
791   else
792     es_fputs ("[?]\n", fp);
793
794   es_fputs ("     keyUsage:", fp);
795   err = ksba_cert_get_key_usage (cert, &kusage);
796   if (gpg_err_code (err) != GPG_ERR_NO_DATA)
797     {
798       if (err)
799         es_fprintf (fp, " [error: %s]", gpg_strerror (err));
800       else
801         {
802           if ( (kusage & KSBA_KEYUSAGE_DIGITAL_SIGNATURE))
803             es_fputs (" digitalSignature", fp);
804           if ( (kusage & KSBA_KEYUSAGE_NON_REPUDIATION))
805             es_fputs (" nonRepudiation", fp);
806           if ( (kusage & KSBA_KEYUSAGE_KEY_ENCIPHERMENT))
807             es_fputs (" keyEncipherment", fp);
808           if ( (kusage & KSBA_KEYUSAGE_DATA_ENCIPHERMENT))
809             es_fputs (" dataEncipherment", fp);
810           if ( (kusage & KSBA_KEYUSAGE_KEY_AGREEMENT))
811             es_fputs (" keyAgreement", fp);
812           if ( (kusage & KSBA_KEYUSAGE_KEY_CERT_SIGN))
813             es_fputs (" certSign", fp);
814           if ( (kusage & KSBA_KEYUSAGE_CRL_SIGN))
815             es_fputs (" crlSign", fp);
816           if ( (kusage & KSBA_KEYUSAGE_ENCIPHER_ONLY))
817             es_fputs (" encipherOnly", fp);
818           if ( (kusage & KSBA_KEYUSAGE_DECIPHER_ONLY))
819             es_fputs (" decipherOnly", fp);
820         }
821       es_putc ('\n', fp);
822     }
823   else
824     es_fputs (" [none]\n", fp);
825
826   es_fputs ("  extKeyUsage: ", fp);
827   err = ksba_cert_get_ext_key_usages (cert, &string);
828   if (gpg_err_code (err) != GPG_ERR_NO_DATA)
829     {
830       if (err)
831         es_fprintf (fp, "[error: %s]", gpg_strerror (err));
832       else
833         {
834           p = string;
835           while (p && (pend=strchr (p, ':')))
836             {
837               *pend++ = 0;
838               for (i=0; key_purpose_map[i].oid; i++)
839                 if ( !strcmp (key_purpose_map[i].oid, p) )
840                   break;
841               es_fputs (key_purpose_map[i].oid?key_purpose_map[i].name:p, fp);
842               p = pend;
843               if (*p != 'C')
844                 es_fputs (" (suggested)", fp);
845               if ((p = strchr (p, '\n')))
846                 {
847                   p++;
848                   es_fputs ("\n               ", fp);
849                 }
850             }
851           xfree (string);
852         }
853       es_putc ('\n', fp);
854     }
855   else
856     es_fputs ("[none]\n", fp);
857
858
859   es_fputs ("     policies: ", fp);
860   err = ksba_cert_get_cert_policies (cert, &string);
861   if (gpg_err_code (err) != GPG_ERR_NO_DATA)
862     {
863       if (err)
864         es_fprintf (fp, "[error: %s]", gpg_strerror (err));
865       else
866         {
867           p = string;
868           while (p && (pend=strchr (p, ':')))
869             {
870               *pend++ = 0;
871               for (i=0; key_purpose_map[i].oid; i++)
872                 if ( !strcmp (key_purpose_map[i].oid, p) )
873                   break;
874               es_fputs (p, fp);
875               p = pend;
876               if (*p == 'C')
877                 es_fputs (" (critical)", fp);
878               if ((p = strchr (p, '\n')))
879                 {
880                   p++;
881                   es_fputs ("\n               ", fp);
882                 }
883             }
884           xfree (string);
885         }
886       es_putc ('\n', fp);
887     }
888   else
889     es_fputs ("[none]\n", fp);
890
891   es_fputs ("  chainLength: ", fp);
892   err = ksba_cert_is_ca (cert, &is_ca, &chainlen);
893   if (err || is_ca)
894     {
895       if (gpg_err_code (err) == GPG_ERR_NO_VALUE )
896         es_fprintf (fp, "[none]");
897       else if (err)
898         es_fprintf (fp, "[error: %s]", gpg_strerror (err));
899       else if (chainlen == -1)
900         es_fputs ("unlimited", fp);
901       else
902         es_fprintf (fp, "%d", chainlen);
903       es_putc ('\n', fp);
904     }
905   else
906     es_fputs ("not a CA\n", fp);
907
908
909   /* CRL distribution point */
910   for (idx=0; !(err=ksba_cert_get_crl_dist_point (cert, idx, &name, &name2,
911                                                   &reason)) ;idx++)
912     {
913       es_fputs ("        crlDP: ", fp);
914       print_names_raw (fp, 15, name);
915       if (reason)
916         {
917           es_fputs ("               reason: ", fp);
918           if ( (reason & KSBA_CRLREASON_UNSPECIFIED))
919             es_fputs (" unused", fp);
920           if ( (reason & KSBA_CRLREASON_KEY_COMPROMISE))
921             es_fputs (" keyCompromise", fp);
922           if ( (reason & KSBA_CRLREASON_CA_COMPROMISE))
923             es_fputs (" caCompromise", fp);
924           if ( (reason & KSBA_CRLREASON_AFFILIATION_CHANGED))
925             es_fputs (" affiliationChanged", fp);
926           if ( (reason & KSBA_CRLREASON_SUPERSEDED))
927             es_fputs (" superseded", fp);
928           if ( (reason & KSBA_CRLREASON_CESSATION_OF_OPERATION))
929             es_fputs (" cessationOfOperation", fp);
930           if ( (reason & KSBA_CRLREASON_CERTIFICATE_HOLD))
931             es_fputs (" certificateHold", fp);
932           es_putc ('\n', fp);
933         }
934       es_fputs ("               issuer: ", fp);
935       print_names_raw (fp, 23, name2);
936       ksba_name_release (name);
937       ksba_name_release (name2);
938     }
939   if (err && gpg_err_code (err) != GPG_ERR_EOF
940       && gpg_err_code (err) != GPG_ERR_NO_VALUE)
941     es_fputs ("        crlDP: [error]\n", fp);
942   else if (!idx)
943     es_fputs ("        crlDP: [none]\n", fp);
944
945
946   /* authorityInfoAccess. */
947   for (idx=0; !(err=ksba_cert_get_authority_info_access (cert, idx, &string,
948                                                          &name)); idx++)
949     {
950       es_fputs ("     authInfo: ", fp);
951       s = get_oid_desc (string, NULL);
952       es_fprintf (fp, "%s%s%s%s\n", string, s?" (":"", s?s:"", s?")":"");
953       print_names_raw (fp, -15, name);
954       ksba_name_release (name);
955       ksba_free (string);
956     }
957   if (err && gpg_err_code (err) != GPG_ERR_EOF
958       && gpg_err_code (err) != GPG_ERR_NO_VALUE)
959     es_fputs ("     authInfo: [error]\n", fp);
960   else if (!idx)
961     es_fputs ("     authInfo: [none]\n", fp);
962
963   /* subjectInfoAccess. */
964   for (idx=0; !(err=ksba_cert_get_subject_info_access (cert, idx, &string,
965                                                          &name)); idx++)
966     {
967       es_fputs ("  subjectInfo: ", fp);
968       s = get_oid_desc (string, NULL);
969       es_fprintf (fp, "%s%s%s%s\n", string, s?" (":"", s?s:"", s?")":"");
970       print_names_raw (fp, -15, name);
971       ksba_name_release (name);
972       ksba_free (string);
973     }
974   if (err && gpg_err_code (err) != GPG_ERR_EOF
975       && gpg_err_code (err) != GPG_ERR_NO_VALUE)
976     es_fputs ("     subjInfo: [error]\n", fp);
977   else if (!idx)
978     es_fputs ("     subjInfo: [none]\n", fp);
979
980
981   for (idx=0; !(err=ksba_cert_get_extension (cert, idx,
982                                              &oid, &i, &off, &len));idx++)
983     {
984       unsigned int flag;
985
986       s = get_oid_desc (oid, &flag);
987       if ((flag & OID_FLAG_SKIP))
988         continue;
989
990       es_fprintf (fp, "     %s: %s%s%s%s  [%d octets]\n",
991                   i? "critExtn":"    extn",
992                   oid, s?" (":"", s?s:"", s?")":"", (int)len);
993       if ((flag & OID_FLAG_UTF8))
994         {
995           if (!cert_der)
996             cert_der = ksba_cert_get_image (cert, NULL);
997           assert (cert_der);
998           print_utf8_extn_raw (fp, -15, cert_der+off, len);
999         }
1000     }
1001
1002
1003   if (with_validation)
1004     {
1005       err = gpgsm_validate_chain (ctrl, cert, "", NULL, 1, fp, 0, NULL);
1006       if (!err)
1007         es_fprintf (fp, "  [certificate is good]\n");
1008       else
1009         es_fprintf (fp, "  [certificate is bad: %s]\n", gpg_strerror (err));
1010     }
1011
1012   if (hd)
1013     {
1014       unsigned int blobflags;
1015
1016       err = keydb_get_flags (hd, KEYBOX_FLAG_BLOB, 0, &blobflags);
1017       if (err)
1018         es_fprintf (fp, "  [error getting keyflags: %s]\n",gpg_strerror (err));
1019       else if ((blobflags & KEYBOX_FLAG_BLOB_EPHEMERAL))
1020         es_fprintf (fp, "  [stored as ephemeral]\n");
1021     }
1022
1023 }
1024
1025
1026
1027
1028 /* List one certificate in standard mode */
1029 static void
1030 list_cert_std (ctrl_t ctrl, ksba_cert_t cert, estream_t fp, int have_secret,
1031                int with_validation)
1032 {
1033   gpg_error_t err;
1034   ksba_sexp_t sexp;
1035   char *dn;
1036   ksba_isotime_t t;
1037   int idx, i;
1038   int is_ca, chainlen;
1039   unsigned int kusage;
1040   char *string, *p, *pend;
1041   size_t off, len;
1042   const char *oid;
1043   const unsigned char *cert_der = NULL;
1044
1045
1046   es_fprintf (fp, "           ID: 0x%08lX\n",
1047               gpgsm_get_short_fingerprint (cert, NULL));
1048
1049   sexp = ksba_cert_get_serial (cert);
1050   es_fputs ("          S/N: ", fp);
1051   gpgsm_print_serial (fp, sexp);
1052   ksba_free (sexp);
1053   es_putc ('\n', fp);
1054
1055   dn = ksba_cert_get_issuer (cert, 0);
1056   es_fputs ("       Issuer: ", fp);
1057   gpgsm_es_print_name (fp, dn);
1058   ksba_free (dn);
1059   es_putc ('\n', fp);
1060   for (idx=1; (dn = ksba_cert_get_issuer (cert, idx)); idx++)
1061     {
1062       es_fputs ("          aka: ", fp);
1063       gpgsm_es_print_name (fp, dn);
1064       ksba_free (dn);
1065       es_putc ('\n', fp);
1066     }
1067
1068   dn = ksba_cert_get_subject (cert, 0);
1069   es_fputs ("      Subject: ", fp);
1070   gpgsm_es_print_name (fp, dn);
1071   ksba_free (dn);
1072   es_putc ('\n', fp);
1073   for (idx=1; (dn = ksba_cert_get_subject (cert, idx)); idx++)
1074     {
1075       es_fputs ("          aka: ", fp);
1076       gpgsm_es_print_name (fp, dn);
1077       ksba_free (dn);
1078       es_putc ('\n', fp);
1079     }
1080
1081   ksba_cert_get_validity (cert, 0, t);
1082   es_fputs ("     validity: ", fp);
1083   gpgsm_print_time (fp, t);
1084   es_fputs (" through ", fp);
1085   ksba_cert_get_validity (cert, 1, t);
1086   gpgsm_print_time (fp, t);
1087   es_putc ('\n', fp);
1088
1089
1090   {
1091     const char *algoname;
1092     unsigned int nbits;
1093
1094     algoname = gcry_pk_algo_name (gpgsm_get_key_algo_info (cert, &nbits));
1095     es_fprintf (fp, "     key type: %u bit %s\n",
1096                 nbits, algoname? algoname:"?");
1097   }
1098
1099
1100   err = ksba_cert_get_key_usage (cert, &kusage);
1101   if (gpg_err_code (err) != GPG_ERR_NO_DATA)
1102     {
1103       es_fputs ("    key usage:", fp);
1104       if (err)
1105         es_fprintf (fp, " [error: %s]", gpg_strerror (err));
1106       else
1107         {
1108           if ( (kusage & KSBA_KEYUSAGE_DIGITAL_SIGNATURE))
1109             es_fputs (" digitalSignature", fp);
1110           if ( (kusage & KSBA_KEYUSAGE_NON_REPUDIATION))
1111             es_fputs (" nonRepudiation", fp);
1112           if ( (kusage & KSBA_KEYUSAGE_KEY_ENCIPHERMENT))
1113             es_fputs (" keyEncipherment", fp);
1114           if ( (kusage & KSBA_KEYUSAGE_DATA_ENCIPHERMENT))
1115             es_fputs (" dataEncipherment", fp);
1116           if ( (kusage & KSBA_KEYUSAGE_KEY_AGREEMENT))
1117             es_fputs (" keyAgreement", fp);
1118           if ( (kusage & KSBA_KEYUSAGE_KEY_CERT_SIGN))
1119             es_fputs (" certSign", fp);
1120           if ( (kusage & KSBA_KEYUSAGE_CRL_SIGN))
1121             es_fputs (" crlSign", fp);
1122           if ( (kusage & KSBA_KEYUSAGE_ENCIPHER_ONLY))
1123             es_fputs (" encipherOnly", fp);
1124           if ( (kusage & KSBA_KEYUSAGE_DECIPHER_ONLY))
1125             es_fputs (" decipherOnly", fp);
1126         }
1127       es_putc ('\n', fp);
1128     }
1129
1130   err = ksba_cert_get_ext_key_usages (cert, &string);
1131   if (gpg_err_code (err) != GPG_ERR_NO_DATA)
1132     {
1133       es_fputs ("ext key usage: ", fp);
1134       if (err)
1135         es_fprintf (fp, "[error: %s]", gpg_strerror (err));
1136       else
1137         {
1138           p = string;
1139           while (p && (pend=strchr (p, ':')))
1140             {
1141               *pend++ = 0;
1142               for (i=0; key_purpose_map[i].oid; i++)
1143                 if ( !strcmp (key_purpose_map[i].oid, p) )
1144                   break;
1145               es_fputs (key_purpose_map[i].oid?key_purpose_map[i].name:p, fp);
1146               p = pend;
1147               if (*p != 'C')
1148                 es_fputs (" (suggested)", fp);
1149               if ((p = strchr (p, '\n')))
1150                 {
1151                   p++;
1152                   es_fputs (", ", fp);
1153                 }
1154             }
1155           xfree (string);
1156         }
1157       es_putc ('\n', fp);
1158     }
1159
1160   /* Print restrictions.  */
1161   for (idx=0; !(err=ksba_cert_get_extension (cert, idx,
1162                                              &oid, NULL, &off, &len));idx++)
1163     {
1164       if (!strcmp (oid, OIDSTR_restriction) )
1165         {
1166           if (!cert_der)
1167             cert_der = ksba_cert_get_image (cert, NULL);
1168           assert (cert_der);
1169           es_fputs ("  restriction: ", fp);
1170           print_utf8_extn (fp, 15, cert_der+off, len);
1171         }
1172     }
1173
1174   /* Print policies.  */
1175   err = ksba_cert_get_cert_policies (cert, &string);
1176   if (gpg_err_code (err) != GPG_ERR_NO_DATA)
1177     {
1178       es_fputs ("     policies: ", fp);
1179       if (err)
1180         es_fprintf (fp, "[error: %s]", gpg_strerror (err));
1181       else
1182         {
1183           for (p=string; *p; p++)
1184             {
1185               if (*p == '\n')
1186                 *p = ',';
1187             }
1188           es_write_sanitized (fp, string, strlen (string), NULL, NULL);
1189           xfree (string);
1190         }
1191       es_putc ('\n', fp);
1192     }
1193
1194   err = ksba_cert_is_ca (cert, &is_ca, &chainlen);
1195   if (err || is_ca)
1196     {
1197       es_fputs (" chain length: ", fp);
1198       if (gpg_err_code (err) == GPG_ERR_NO_VALUE )
1199         es_fprintf (fp, "none");
1200       else if (err)
1201         es_fprintf (fp, "[error: %s]", gpg_strerror (err));
1202       else if (chainlen == -1)
1203         es_fputs ("unlimited", fp);
1204       else
1205         es_fprintf (fp, "%d", chainlen);
1206       es_putc ('\n', fp);
1207     }
1208
1209   if (opt.with_md5_fingerprint)
1210     {
1211       dn = gpgsm_get_fingerprint_string (cert, GCRY_MD_MD5);
1212       es_fprintf (fp, "      md5 fpr: %s\n", dn?dn:"error");
1213       xfree (dn);
1214     }
1215
1216   dn = gpgsm_get_fingerprint_string (cert, 0);
1217   es_fprintf (fp, "  fingerprint: %s\n", dn?dn:"error");
1218   xfree (dn);
1219
1220   if (opt.with_keygrip)
1221     {
1222       dn = gpgsm_get_keygrip_hexstring (cert);
1223       if (dn)
1224         {
1225           es_fprintf (fp, "      keygrip: %s\n", dn);
1226           xfree (dn);
1227         }
1228     }
1229
1230   if (have_secret)
1231     {
1232       char *cardsn;
1233
1234       p = gpgsm_get_keygrip_hexstring (cert);
1235       if (!gpgsm_agent_keyinfo (ctrl, p, &cardsn) && cardsn)
1236         es_fprintf (fp, "     card s/n: %s\n", cardsn);
1237       xfree (cardsn);
1238       xfree (p);
1239     }
1240
1241   if (with_validation)
1242     {
1243       gpg_error_t tmperr;
1244       size_t buflen;
1245       char buffer[1];
1246
1247       err = gpgsm_validate_chain (ctrl, cert, "", NULL, 1, fp, 0, NULL);
1248       tmperr = ksba_cert_get_user_data (cert, "is_qualified",
1249                                         &buffer, sizeof (buffer), &buflen);
1250       if (!tmperr && buflen)
1251         {
1252           if (*buffer)
1253             es_fputs ("  [qualified]\n", fp);
1254         }
1255       else if (gpg_err_code (tmperr) == GPG_ERR_NOT_FOUND)
1256         ; /* Don't know - will not get marked as 'q' */
1257       else
1258         log_debug ("get_user_data(is_qualified) failed: %s\n",
1259                    gpg_strerror (tmperr));
1260
1261       if (!err)
1262         es_fprintf (fp, "  [certificate is good]\n");
1263       else
1264         es_fprintf (fp, "  [certificate is bad: %s]\n", gpg_strerror (err));
1265     }
1266 }
1267
1268
1269 /* Same as standard mode mode list all certifying certs too. */
1270 static void
1271 list_cert_chain (ctrl_t ctrl, KEYDB_HANDLE hd,
1272                  ksba_cert_t cert, int raw_mode,
1273                  estream_t fp, int with_validation)
1274 {
1275   ksba_cert_t next = NULL;
1276
1277   if (raw_mode)
1278     list_cert_raw (ctrl, hd, cert, fp, 0, with_validation);
1279   else
1280     list_cert_std (ctrl, cert, fp, 0, with_validation);
1281   ksba_cert_ref (cert);
1282   while (!gpgsm_walk_cert_chain (ctrl, cert, &next))
1283     {
1284       ksba_cert_release (cert);
1285       es_fputs ("Certified by\n", fp);
1286       if (raw_mode)
1287         list_cert_raw (ctrl, hd, next, fp, 0, with_validation);
1288       else
1289         list_cert_std (ctrl, next, fp, 0, with_validation);
1290       cert = next;
1291     }
1292   ksba_cert_release (cert);
1293   es_putc ('\n', fp);
1294 }
1295
1296
1297 \f
1298 /* List all internal keys or just the keys given as NAMES.  MODE is a
1299    bit vector to specify what keys are to be included; see
1300    gpgsm_list_keys (below) for details.  If RAW_MODE is true, the raw
1301    output mode will be used instead of the standard beautified one.
1302  */
1303 static gpg_error_t
1304 list_internal_keys (ctrl_t ctrl, strlist_t names, estream_t fp,
1305                     unsigned int mode, int raw_mode)
1306 {
1307   KEYDB_HANDLE hd;
1308   KEYDB_SEARCH_DESC *desc = NULL;
1309   strlist_t sl;
1310   int ndesc;
1311   ksba_cert_t cert = NULL;
1312   ksba_cert_t lastcert = NULL;
1313   gpg_error_t rc = 0;
1314   const char *lastresname, *resname;
1315   int have_secret;
1316   int want_ephemeral = ctrl->with_ephemeral_keys;
1317
1318   hd = keydb_new (0);
1319   if (!hd)
1320     {
1321       log_error ("keydb_new failed\n");
1322       rc = gpg_error (GPG_ERR_GENERAL);
1323       goto leave;
1324     }
1325
1326   if (!names)
1327     ndesc = 1;
1328   else
1329     {
1330       for (sl=names, ndesc=0; sl; sl = sl->next, ndesc++)
1331         ;
1332     }
1333
1334   desc = xtrycalloc (ndesc, sizeof *desc);
1335   if (!ndesc)
1336     {
1337       rc = gpg_error_from_syserror ();
1338       log_error ("out of core\n");
1339       goto leave;
1340     }
1341
1342   if (!names)
1343     desc[0].mode = KEYDB_SEARCH_MODE_FIRST;
1344   else
1345     {
1346       for (ndesc=0, sl=names; sl; sl = sl->next)
1347         {
1348           rc = classify_user_id (sl->d, desc+ndesc, 0);
1349           if (rc)
1350             {
1351               log_error ("key `%s' not found: %s\n",
1352                          sl->d, gpg_strerror (rc));
1353               rc = 0;
1354             }
1355           else
1356             ndesc++;
1357         }
1358
1359     }
1360
1361   /* If all specifications are done by fingerprint or keygrip, we
1362      switch to ephemeral mode so that _all_ currently available and
1363      matching certificates are listed.  */
1364   if (!want_ephemeral && names && ndesc)
1365     {
1366       int i;
1367
1368       for (i=0; (i < ndesc
1369                  && (desc[i].mode == KEYDB_SEARCH_MODE_FPR
1370                      || desc[i].mode == KEYDB_SEARCH_MODE_FPR20
1371                      || desc[i].mode == KEYDB_SEARCH_MODE_FPR16
1372                      || desc[i].mode == KEYDB_SEARCH_MODE_KEYGRIP)); i++)
1373         ;
1374       if (i == ndesc)
1375         want_ephemeral = 1;
1376     }
1377
1378   if (want_ephemeral)
1379     keydb_set_ephemeral (hd, 1);
1380
1381   /* It would be nice to see which of the given users did actually
1382      match one in the keyring.  To implement this we need to have a
1383      found flag for each entry in desc and to set this we must check
1384      all those entries after a match to mark all matched one -
1385      currently we stop at the first match.  To do this we need an
1386      extra flag to enable this feature so */
1387
1388   /* Suppress duplicates at least when they follow each other.  */
1389   lastresname = NULL;
1390   while (!(rc = keydb_search (hd, desc, ndesc)))
1391     {
1392       unsigned int validity;
1393
1394       if (!names)
1395         desc[0].mode = KEYDB_SEARCH_MODE_NEXT;
1396
1397       rc = keydb_get_flags (hd, KEYBOX_FLAG_VALIDITY, 0, &validity);
1398       if (rc)
1399         {
1400           log_error ("keydb_get_flags failed: %s\n", gpg_strerror (rc));
1401           goto leave;
1402         }
1403       rc = keydb_get_cert (hd, &cert);
1404       if (rc)
1405         {
1406           log_error ("keydb_get_cert failed: %s\n", gpg_strerror (rc));
1407           goto leave;
1408         }
1409       /* Skip duplicated certificates, at least if they follow each
1410          others.  This works best if a single key is searched for and
1411          expected.  FIXME: Non-sequential duplicates remain.  */
1412       if (gpgsm_certs_identical_p (cert, lastcert))
1413         {
1414           ksba_cert_release (cert);
1415           cert = NULL;
1416           continue;
1417         }
1418
1419       resname = keydb_get_resource_name (hd);
1420
1421       if (lastresname != resname )
1422         {
1423           int i;
1424
1425           if (ctrl->no_server)
1426             {
1427               es_fprintf (fp, "%s\n", resname );
1428               for (i=strlen(resname); i; i-- )
1429                 es_putc ('-', fp);
1430               es_putc ('\n', fp);
1431               lastresname = resname;
1432             }
1433         }
1434
1435       have_secret = 0;
1436       if (mode)
1437         {
1438           char *p = gpgsm_get_keygrip_hexstring (cert);
1439           if (p)
1440             {
1441               rc = gpgsm_agent_havekey (ctrl, p);
1442               if (!rc)
1443                 have_secret = 1;
1444               else if ( gpg_err_code (rc) != GPG_ERR_NO_SECKEY)
1445                 goto leave;
1446               rc = 0;
1447               xfree (p);
1448             }
1449         }
1450
1451       if (!mode
1452           || ((mode & 1) && !have_secret)
1453           || ((mode & 2) && have_secret)  )
1454         {
1455           if (ctrl->with_colons)
1456             list_cert_colon (ctrl, cert, validity, fp, have_secret);
1457           else if (ctrl->with_chain)
1458             list_cert_chain (ctrl, hd, cert,
1459                              raw_mode, fp, ctrl->with_validation);
1460           else
1461             {
1462               if (raw_mode)
1463                 list_cert_raw (ctrl, hd, cert, fp, have_secret,
1464                                ctrl->with_validation);
1465               else
1466                 list_cert_std (ctrl, cert, fp, have_secret,
1467                                ctrl->with_validation);
1468               es_putc ('\n', fp);
1469             }
1470         }
1471
1472       ksba_cert_release (lastcert);
1473       lastcert = cert;
1474       cert = NULL;
1475     }
1476   if (gpg_err_code (rc) == GPG_ERR_EOF || rc == -1 )
1477     rc = 0;
1478   if (rc)
1479     log_error ("keydb_search failed: %s\n", gpg_strerror (rc));
1480
1481  leave:
1482   ksba_cert_release (cert);
1483   ksba_cert_release (lastcert);
1484   xfree (desc);
1485   keydb_release (hd);
1486   return rc;
1487 }
1488
1489
1490
1491 static void
1492 list_external_cb (void *cb_value, ksba_cert_t cert)
1493 {
1494   struct list_external_parm_s *parm = cb_value;
1495
1496   if (keydb_store_cert (cert, 1, NULL))
1497     log_error ("error storing certificate as ephemeral\n");
1498
1499   if (parm->print_header)
1500     {
1501       const char *resname = "[external keys]";
1502       int i;
1503
1504       es_fprintf (parm->fp, "%s\n", resname );
1505       for (i=strlen(resname); i; i-- )
1506         es_putc('-', parm->fp);
1507       es_putc ('\n', parm->fp);
1508       parm->print_header = 0;
1509     }
1510
1511   if (parm->with_colons)
1512     list_cert_colon (parm->ctrl, cert, 0, parm->fp, 0);
1513   else if (parm->with_chain)
1514     list_cert_chain (parm->ctrl, NULL, cert, parm->raw_mode, parm->fp, 0);
1515   else
1516     {
1517       if (parm->raw_mode)
1518         list_cert_raw (parm->ctrl, NULL, cert, parm->fp, 0, 0);
1519       else
1520         list_cert_std (parm->ctrl, cert, parm->fp, 0, 0);
1521       es_putc ('\n', parm->fp);
1522     }
1523 }
1524
1525
1526 /* List external keys similar to internal one.  Note: mode does not
1527    make sense here because it would be unwise to list external secret
1528    keys */
1529 static gpg_error_t
1530 list_external_keys (ctrl_t ctrl, strlist_t names, estream_t fp, int raw_mode)
1531 {
1532   int rc;
1533   struct list_external_parm_s parm;
1534
1535   parm.fp = fp;
1536   parm.ctrl = ctrl,
1537   parm.print_header = ctrl->no_server;
1538   parm.with_colons = ctrl->with_colons;
1539   parm.with_chain = ctrl->with_chain;
1540   parm.raw_mode  = raw_mode;
1541
1542   rc = gpgsm_dirmngr_lookup (ctrl, names, 0, list_external_cb, &parm);
1543   if (gpg_err_code (rc) == GPG_ERR_EOF || rc == -1
1544       || gpg_err_code (rc) == GPG_ERR_NOT_FOUND)
1545     rc = 0; /* "Not found" is not an error here. */
1546   if (rc)
1547     log_error ("listing external keys failed: %s\n", gpg_strerror (rc));
1548   return rc;
1549 }
1550
1551 /* List all keys or just the key given as NAMES.
1552    MODE controls the operation mode:
1553     Bit 0-2:
1554       0 = list all public keys but don't flag secret ones
1555       1 = list only public keys
1556       2 = list only secret keys
1557       3 = list secret and public keys
1558     Bit 6: list internal keys
1559     Bit 7: list external keys
1560     Bit 8: Do a raw format dump.
1561  */
1562 gpg_error_t
1563 gpgsm_list_keys (ctrl_t ctrl, strlist_t names, estream_t fp,
1564                  unsigned int mode)
1565 {
1566   gpg_error_t err = 0;
1567
1568   if ((mode & (1<<6)))
1569     err = list_internal_keys (ctrl, names, fp, (mode & 3), (mode&256));
1570   if (!err && (mode & (1<<7)))
1571     err = list_external_keys (ctrl, names, fp, (mode&256));
1572   return err;
1573 }