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