scd: Make SPRx32 pinpad work with PC/SC on Windows.
[gnupg.git] / scd / card.c
index 9c22867..a582c50 100644 (file)
@@ -5,7 +5,7 @@
  *
  * GnuPG is free software; you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation; either version 2 of the License, or
+ * the Free Software Foundation; either version 3 of the License, or
  * (at your option) any later version.
  *
  * GnuPG is distributed in the hope that it will be useful,
@@ -14,8 +14,7 @@
  * GNU General Public License for more details.
  *
  * You should have received a copy of the GNU General Public License
- * along with this program; if not, write to the Free Software
- * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
+ * along with this program; if not, see <http://www.gnu.org/licenses/>.
  */
 
 #include <config.h>
 #include <string.h>
 #include <time.h>
 
+#ifdef HAVE_OPENSC
 #include <opensc/pkcs15.h>
-#include <ksba.h>
+#endif
 
 #include "scdaemon.h"
+#include <ksba.h>
+
 #include "card-common.h"
 
 /* Map the SC error codes to the GNUPG ones */
-int
+gpg_error_t
 map_sc_err (int rc)
 {
+  gpg_err_code_t e;
+
   switch (rc)
     {
-    case 0: rc = 0; break;
-    case SC_ERROR_NOT_SUPPORTED:         rc = GNUPG_Not_Supported; break;
-    case SC_ERROR_PKCS15_APP_NOT_FOUND:  rc = GNUPG_No_PKCS15_App; break;
-    case SC_ERROR_OUT_OF_MEMORY:         rc = GNUPG_Out_Of_Core; break;
-    case SC_ERROR_CARD_NOT_PRESENT:      rc = GNUPG_Card_Not_Present; break;
-    case SC_ERROR_CARD_REMOVED:          rc = GNUPG_Card_Removed; break;
-    case SC_ERROR_INVALID_CARD:          rc = GNUPG_Invalid_Card; break;
-    default: rc = GNUPG_Card_Error; break;
+    case 0: e = 0; break;
+#ifdef HAVE_OPENSC
+    case SC_ERROR_NOT_SUPPORTED:         e = GPG_ERR_NOT_SUPPORTED; break;
+    case SC_ERROR_PKCS15_APP_NOT_FOUND:  e = GPG_ERR_NO_PKCS15_APP; break;
+    case SC_ERROR_OUT_OF_MEMORY:         e = GPG_ERR_ENOMEM; break;
+    case SC_ERROR_CARD_NOT_PRESENT:      e = GPG_ERR_CARD_NOT_PRESENT; break;
+    case SC_ERROR_CARD_REMOVED:          e = GPG_ERR_CARD_REMOVED; break;
+    case SC_ERROR_INVALID_CARD:          e = GPG_ERR_INV_CARD; break;
+#endif
+    default: e = GPG_ERR_CARD; break;
     }
-  return rc;
+  /* It does not make much sense to further distingusih the error
+     source between OpenSC and SCD.  Thus we use SCD as source
+     here. */
+  return gpg_err_make (GPG_ERR_SOURCE_SCD, e);
 }
 
 /* Get the keygrip from CERT, return 0 on success */
 int
-card_help_get_keygrip (KsbaCert cert, unsigned char *array)
+card_help_get_keygrip (ksba_cert_t cert, unsigned char *array)
 {
-  GCRY_SEXP s_pkey;
+  gcry_sexp_t s_pkey;
   int rc;
-  KsbaSexp p;
+  ksba_sexp_t p;
   size_t n;
-  
+
   p = ksba_cert_get_public_key (cert);
   if (!p)
     return -1; /* oops */
@@ -82,21 +91,25 @@ card_help_get_keygrip (KsbaCert cert, unsigned char *array)
 
 \f
 /* Create a new context for the card and figures out some basic
-   information of the card.  Detects whgether a PKCS_15 application is
+   information of the card.  Detects whether a PKCS_15 application is
    stored.
 
-   Common errors: GNUPG_Card_Not_Present */
+   Common errors: GPG_ERR_CARD_NOT_PRESENT */
 int
 card_open (CARD *rcard)
 {
+#ifdef HAVE_OPENSC
   CARD card;
   int rc;
 
+  if (opt.disable_opensc)
+    return gpg_error (GPG_ERR_NOT_SUPPORTED);
+
   card = xtrycalloc (1, sizeof *card);
   if (!card)
-    return GNUPG_Out_Of_Core;
+    return gpg_error (gpg_err_code_from_errno (errno));
   card->reader = 0;
-  
+
   rc = sc_establish_context (&card->ctx, "scdaemon");
   if (rc)
     {
@@ -107,7 +120,7 @@ card_open (CARD *rcard)
   if (card->reader >= card->ctx->reader_count)
     {
       log_error ("no card reader available\n");
-      rc = GNUPG_Card_Error;
+      rc = gpg_error (GPG_ERR_CARD);
       goto leave;
     }
   card->ctx->error_file = log_get_stream ();
@@ -116,7 +129,7 @@ card_open (CARD *rcard)
 
   if (sc_detect_card_presence (card->ctx->reader[card->reader], 0) != 1)
     {
-      rc = GNUPG_Card_Not_Present;
+      rc = gpg_error (GPG_ERR_CARD_NOT_PRESENT);
       goto leave;
     }
 
@@ -129,7 +142,7 @@ card_open (CARD *rcard)
       goto leave;
     }
   if (opt.verbose)
-    log_info ("connected to card in reader %d using driver `%s'\n",
+    log_info ("connected to card in reader %d using driver '%s'\n",
               card->reader, card->scard->driver->name);
 
   rc = sc_lock (card->scard);
@@ -141,13 +154,17 @@ card_open (CARD *rcard)
       goto leave;
     }
 
-    
+
  leave:
   if (rc)
     card_close (card);
   else
     *rcard = card;
+
   return rc;
+#else
+  return gpg_error (GPG_ERR_NOT_SUPPORTED);
+#endif
 }
 
 
@@ -157,11 +174,14 @@ card_close (CARD card)
 {
   if (card)
     {
+#ifdef HAVE_OPENSC
       if (card->p15card)
         {
           sc_pkcs15_unbind (card->p15card);
           card->p15card = NULL;
         }
+      if (card->p15priv)
+        p15_release_private_data (card);
       if (card->scard)
         {
           sc_unlock (card->scard);
@@ -173,14 +193,16 @@ card_close (CARD card)
           sc_release_context (card->ctx);
           card->ctx = NULL;
         }
+#endif
       xfree (card);
-    }      
+    }
 }
 
 /* Locate a simple TLV encoded data object in BUFFER of LENGTH and
    return a pointer to value as well as its length in NBYTES.  Return
    NULL if it was not found.  Note, that the function does not check
    whether the value fits into the provided buffer. */
+#ifdef HAVE_OPENSC
 static const char *
 find_simple_tlv (const unsigned char *buffer, size_t length,
                  int tag, size_t *nbytes)
@@ -188,7 +210,7 @@ find_simple_tlv (const unsigned char *buffer, size_t length,
   const char *s = buffer;
   size_t n = length;
   size_t len;
-    
+
   for (;;)
     {
       buffer = s;
@@ -213,11 +235,13 @@ find_simple_tlv (const unsigned char *buffer, size_t length,
       s += len; n -= len;
     }
 }
+#endif /*HAVE_OPENSC*/
 
 /* Find the ICC Serial Number within the provided BUFFER of LENGTH
    (which should contain the GDO file) and return it as a hex encoded
    string and allocated string in SERIAL.  Return an error code when
    the ICCSN was not found. */
+#ifdef HAVE_OPENSC
 static int
 find_iccsn (const unsigned char *buffer, size_t length, char **serial)
 {
@@ -227,7 +251,7 @@ find_iccsn (const unsigned char *buffer, size_t length, char **serial)
 
   s = find_simple_tlv (buffer, length, 0x5A, &n);
   if (!s)
-    return GNUPG_Card_Error;
+    return gpg_error (GPG_ERR_CARD);
   length -= s - buffer;
   if (n > length)
     {
@@ -242,20 +266,21 @@ find_iccsn (const unsigned char *buffer, size_t length, char **serial)
           n--;
         }
       else
-        return GNUPG_Card_Error; /* Bad encoding; does not fit into buffer. */
+        return gpg_error (GPG_ERR_CARD); /* Bad encoding; does
+                                           not fit into buffer. */
     }
   if (!n)
-    return GNUPG_Card_Error; /* Well, that is too short. */
+    return gpg_error (GPG_ERR_CARD); /* Well, that is too short. */
 
   *serial = p = xtrymalloc (2*n+1);
   if (!*serial)
-    return GNUPG_Out_Of_Core;
+    return gpg_error (gpg_err_code_from_errno (errno));
   for (; n; n--, p += 2, s++)
     sprintf (p, "%02X", *s);
   *p = 0;
   return 0;
 }
-
+#endif /*HAVE_OPENSC*/
 
 /* Retrieve the serial number and the time of the last update of the
    card.  The serial number is returned as a malloced string (hex
@@ -265,25 +290,28 @@ find_iccsn (const unsigned char *buffer, size_t length, char **serial)
    returned if this value is not availbale.  For non-PKCS-15 cards a
    serial number is constructed by other means. Caller must free
    SERIAL unless the function returns an error. */
-int 
+int
 card_get_serial_and_stamp (CARD card, char **serial, time_t *stamp)
 {
+#ifdef HAVE_OPENSC
   int rc;
   struct sc_path path;
   struct sc_file *file;
   unsigned char buf[256];
   int buflen;
+#endif
 
   if (!card || !serial || !stamp)
-    return GNUPG_Invalid_Value;
+    return gpg_error (GPG_ERR_INV_VALUE);
 
   *serial = NULL;
   *stamp = 0; /* not available */
 
+#ifdef HAVE_OPENSC
   if (!card->fnc.initialized)
     {
       card->fnc.initialized = 1;
-      /* The first use of this card tries to figure out the type of the card 
+      /* The first use of this card tries to figure out the type of the card
          and sets up the function pointers. */
       rc = sc_pkcs15_bind (card->scard, &card->p15card);
       if (rc)
@@ -296,11 +324,9 @@ card_get_serial_and_stamp (CARD card, char **serial, time_t *stamp)
         }
       if (card->p15card)
         card_p15_bind (card);
-      else
-        card_dinsig_bind (card);
       card->fnc.initialized = 1;
     }
-      
+
 
   /* We should lookup the iso 7812-1 and 8583-3 - argh ISO
      practice is suppressing innovation - IETF rules!  So we
@@ -312,39 +338,39 @@ card_get_serial_and_stamp (CARD card, char **serial, time_t *stamp)
   if (rc)
     {
       log_error ("sc_select_file failed: %s\n", sc_strerror (rc));
-      return GNUPG_Card_Error;
+      return gpg_error (GPG_ERR_CARD);
     }
   if (file->type != SC_FILE_TYPE_WORKING_EF
       || file->ef_structure != SC_FILE_EF_TRANSPARENT)
     {
       log_error ("wrong type or structure of GDO file\n");
       sc_file_free (file);
-      return GNUPG_Card_Error;
+      return gpg_error (GPG_ERR_CARD);
     }
 
   if (!file->size || file->size >= DIM(buf) )
     { /* FIXME: Use a real parser */
       log_error ("unsupported size of GDO file (%d)\n", file->size);
       sc_file_free (file);
-      return GNUPG_Card_Error;
+      return gpg_error (GPG_ERR_CARD);
     }
   buflen = file->size;
-      
+
   rc = sc_read_binary (card->scard, 0, buf, buflen, 0);
   sc_file_free (file);
-  if (rc < 0) 
+  if (rc < 0)
     {
       log_error ("error reading GDO file: %s\n", sc_strerror (rc));
-      return GNUPG_Card_Error;
+      return gpg_error (GPG_ERR_CARD);
     }
   if (rc != buflen)
     {
       log_error ("short read on GDO file\n");
-      return GNUPG_Card_Error;
+      return gpg_error (GPG_ERR_CARD);
     }
 
   rc = find_iccsn (buf, buflen, serial);
-  if (rc == GNUPG_Card_Error)
+  if (gpg_err_code (rc) == GPG_ERR_CARD)
     log_error ("invalid structure of GDO file\n");
   if (!rc && card->p15card && !strcmp (*serial, "D27600000000000000000000"))
     { /* This is a German card with a silly serial number.  Try to get
@@ -355,12 +381,12 @@ card_get_serial_and_stamp (CARD card, char **serial, time_t *stamp)
 
       if (!efser)
         efser = "";
-        
+
       xfree (*serial);
       *serial = NULL;
       p = xtrymalloc (strlen (efser) + 7);
       if (!p)
-          rc = GNUPG_Out_Of_Core;
+          rc = gpg_error (gpg_err_code_from_errno (errno));
       else
         {
           strcpy (p, "FF0100");
@@ -376,7 +402,7 @@ card_get_serial_and_stamp (CARD card, char **serial, time_t *stamp)
         {
           xfree (*serial);
           *serial = NULL;
-          rc = GNUPG_Out_Of_Core;
+          rc = gpg_error (gpg_err_code_from_errno (errno));
         }
       else
         {
@@ -387,6 +413,9 @@ card_get_serial_and_stamp (CARD card, char **serial, time_t *stamp)
         }
     }
   return rc;
+#else
+  return gpg_error (GPG_ERR_NOT_SUPPORTED);
+#endif
 }
 
 
@@ -396,7 +425,7 @@ card_get_serial_and_stamp (CARD card, char **serial, time_t *stamp)
    the KEYGRIP of the keypair.  If KEYID is not NULL, it returns the
    ID field of the key in allocated memory; this is a string without
    spaces.  The function returns -1 when all keys have been
-   enumerated.  Note that the error GNUPG_Missing_Certificate may be
+   enumerated.  Note that the error GPG_ERR_MISSING_CERTIFICATE may be
    returned if there is just the private key but no public key (ie.e a
    certificate) available.  Applications might want to continue
    enumerating after this error.*/
@@ -411,21 +440,55 @@ card_enum_keypairs (CARD card, int idx,
     *keyid = NULL;
 
   if (!card || !keygrip)
-    return GNUPG_Invalid_Value;
+    return gpg_error (GPG_ERR_INV_VALUE);
   if (idx < 0)
-    return GNUPG_Invalid_Index;
+    return gpg_error (GPG_ERR_INV_INDEX);
   if (!card->fnc.initialized)
-    return GNUPG_Card_Not_Initialized;
+    return gpg_error (GPG_ERR_CARD_NOT_INITIALIZED);
   if (!card->fnc.enum_keypairs)
-    return GNUPG_Unsupported_Operation;
+    return gpg_error (GPG_ERR_UNSUPPORTED_OPERATION);
   rc = card->fnc.enum_keypairs (card, idx, keygrip, keyid);
   if (opt.verbose)
     log_info ("card operation enum_keypairs result: %s\n",
-              gnupg_strerror (rc));
+              gpg_strerror (rc));
+  return rc;
+}
+
+
+/* Enumerate all trusted certificates available on the card, return
+   their ID in CERT and the type in CERTTYPE.  Types of certificates
+   are:
+      0   := Unknown
+      100 := Regular X.509 cert
+      101 := Trusted X.509 cert
+      102 := Useful X.509 cert
+      110 := Root CA cert (DINSIG)
+ */
+int
+card_enum_certs (CARD card, int idx, char **certid, int *certtype)
+{
+  int rc;
+
+  if (certid)
+    *certid = NULL;
+
+  if (!card)
+    return gpg_error (GPG_ERR_INV_VALUE);
+  if (idx < 0)
+    return gpg_error (GPG_ERR_INV_INDEX);
+  if (!card->fnc.initialized)
+    return gpg_error (GPG_ERR_CARD_NOT_INITIALIZED);
+  if (!card->fnc.enum_certs)
+    return gpg_error (GPG_ERR_UNSUPPORTED_OPERATION);
+  rc = card->fnc.enum_certs (card, idx, certid, certtype);
+  if (opt.verbose)
+    log_info ("card operation enum_certs result: %s\n",
+              gpg_strerror (rc));
   return rc;
 }
 
 
+
 /* Read the certificate identified by CERTIDSTR which is the
    hexadecimal encoded ID of the certificate, prefixed with the string
    "3F005015.". The certificate is return in DER encoded form in CERT
@@ -437,14 +500,14 @@ card_read_cert (CARD card, const char *certidstr,
   int rc;
 
   if (!card || !certidstr || !cert || !ncert)
-    return GNUPG_Invalid_Value;
+    return gpg_error (GPG_ERR_INV_VALUE);
   if (!card->fnc.initialized)
-    return GNUPG_Card_Not_Initialized;
+    return gpg_error (GPG_ERR_CARD_NOT_INITIALIZED);
   if (!card->fnc.read_cert)
-    return GNUPG_Unsupported_Operation;
+    return gpg_error (GPG_ERR_UNSUPPORTED_OPERATION);
   rc = card->fnc.read_cert (card, certidstr, cert, ncert);
   if (opt.verbose)
-    log_info ("card operation read_cert result: %s\n", gnupg_strerror (rc));
+    log_info ("card operation read_cert result: %s\n", gpg_strerror (rc));
   return rc;
 }
 
@@ -452,27 +515,27 @@ card_read_cert (CARD card, const char *certidstr,
 /* Create the signature and return the allocated result in OUTDATA.
    If a PIN is required the PINCB will be used to ask for the PIN; it
    should return the PIN in an allocated buffer and put it into PIN.  */
-int 
+int
 card_sign (CARD card, const char *keyidstr, int hashalgo,
            int (pincb)(void*, const char *, char **),
            void *pincb_arg,
            const void *indata, size_t indatalen,
-           void **outdata, size_t *outdatalen )
+           unsigned char **outdata, size_t *outdatalen )
 {
   int rc;
 
   if (!card || !indata || !indatalen || !outdata || !outdatalen || !pincb)
-    return GNUPG_Invalid_Value;
+    return gpg_error (GPG_ERR_INV_VALUE);
   if (!card->fnc.initialized)
-    return GNUPG_Card_Not_Initialized;
+    return gpg_error (GPG_ERR_CARD_NOT_INITIALIZED);
   if (!card->fnc.sign)
-    return GNUPG_Unsupported_Operation;
+    return gpg_error (GPG_ERR_UNSUPPORTED_OPERATION);
   rc =  card->fnc.sign (card, keyidstr, hashalgo,
                         pincb, pincb_arg,
                         indata, indatalen,
                         outdata, outdatalen);
   if (opt.verbose)
-    log_info ("card operation sign result: %s\n", gnupg_strerror (rc));
+    log_info ("card operation sign result: %s\n", gpg_strerror (rc));
   return rc;
 }
 
@@ -480,26 +543,26 @@ card_sign (CARD card, const char *keyidstr, int hashalgo,
 /* Create the signature and return the allocated result in OUTDATA.
    If a PIN is required the PINCB will be used to ask for the PIN; it
    should return the PIN in an allocated buffer and put it into PIN.  */
-int 
+int
 card_decipher (CARD card, const char *keyidstr,
                int (pincb)(void*, const char *, char **),
                void *pincb_arg,
                const void *indata, size_t indatalen,
-               void **outdata, size_t *outdatalen )
+               unsigned char **outdata, size_t *outdatalen )
 {
   int rc;
 
   if (!card || !indata || !indatalen || !outdata || !outdatalen || !pincb)
-    return GNUPG_Invalid_Value;
+    return gpg_error (GPG_ERR_INV_VALUE);
   if (!card->fnc.initialized)
-    return GNUPG_Card_Not_Initialized;
+    return gpg_error (GPG_ERR_CARD_NOT_INITIALIZED);
   if (!card->fnc.decipher)
-    return GNUPG_Unsupported_Operation;
+    return gpg_error (GPG_ERR_UNSUPPORTED_OPERATION);
   rc =  card->fnc.decipher (card, keyidstr,
                             pincb, pincb_arg,
                             indata, indatalen,
                             outdata, outdatalen);
   if (opt.verbose)
-    log_info ("card operation decipher result: %s\n", gnupg_strerror (rc));
+    log_info ("card operation decipher result: %s\n", gpg_strerror (rc));
   return rc;
 }