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