Changeset 3115

Timestamp:

02/02/07 22:15:14 (2 years ago)

Author:

nils

Message:

implement support for SHA2 (still experimental)

Location:

trunk/src

Files:

• libopensc/card-cardos.c (modified) (1 diff)
• libopensc/card-incrypto34.c (modified) (1 diff)
• libopensc/internal.h (modified) (1 diff)
• libopensc/opensc.h (modified) (1 diff)
• libopensc/padding.c (modified) (12 diffs)
• libopensc/pkcs15-sec.c (modified) (10 diffs)
• pkcs11/framework-pkcs15.c (modified) (1 diff)
• pkcs11/openssl.c (modified) (3 diffs)
• pkcs11/pkcs11-display.c (modified) (2 diffs)
• pkcs11/pkcs11.h (modified) (2 diffs)
• tools/pkcs11-tool.c (modified) (3 diffs)
• tools/pkcs15-crypt.c (modified) (4 diffs)

trunk/src/libopensc/card-cardos.c

@@ -784 +784 @@
         r = sc_pkcs1_strip_01_padding(data, datalen, buf, &tmp_len);
         if (r != SC_SUCCESS) {
-                /* no pkcs1 bt01 padding => let's try zero padding */
+                const u8 *p = data;
+                /* no pkcs1 bt01 padding => let's try zero padding
+                 * This can only work if the data tbs doesn't have a
+                 * leading 0 byte.  */
                 tmp_len = buf_len;
-                r = sc_strip_zero_padding(data, datalen, buf, &tmp_len);
-                if (r != SC_SUCCESS)
-                        SC_FUNC_RETURN(ctx, 4, r);
+                while (*p == 0 && tmp_len != 0) {
+                        ++p;
+                        --tmp_len;
+                }
+                memcpy(buf, p, tmp_len);
         }
         sc_ctx_suppress_errors_on(ctx);

trunk/src/libopensc/card-incrypto34.c

@@ -569 +569 @@
         r = sc_pkcs1_strip_01_padding(data, datalen, buf, &tmp_len);
         if (r != SC_SUCCESS) {
-                /* no pkcs1 bt01 padding => let's try zero padding */
+                const u8 *p = data;
+                /* no pkcs1 bt01 padding => let's try zero padding.
+                 * This can only work if the data tbs doesn't have a
+                 * leading 0 byte. */
                 tmp_len = buf_len;
-                r = sc_strip_zero_padding(data, datalen, buf, &tmp_len);
-                if (r != SC_SUCCESS)
-                        SC_FUNC_RETURN(ctx, 4, r);
+                while (*p == 0 && tmp_len != 0) {
+                        ++p;
+                        --tmp_len;
+                }
+                memcpy(buf, p, tmp_len);
         }
         sc_ctx_suppress_errors_on(ctx);

trunk/src/libopensc/internal.h

@@ -124 +124 @@
 /********************************************************************/
 
-int sc_pkcs1_add_01_padding(const u8 *in, size_t in_len, u8 *out,
-                            size_t *out_len, size_t mod_length);
 int sc_pkcs1_strip_01_padding(const u8 *in_dat, size_t in_len, u8 *out_dat,
                               size_t *out_len);
 int sc_pkcs1_strip_02_padding(const u8 *data, size_t len, u8 *out_dat,
                               size_t *out_len);
-int sc_pkcs1_add_digest_info_prefix(unsigned int algorithm, const u8 *in_dat,
-                size_t in_len, u8 *out_dat, size_t *out_len);
 int sc_pkcs1_strip_digest_info_prefix(unsigned int *algorithm,
                 const u8 *in_dat, size_t in_len, u8 *out_dat, size_t *out_len);
+
+/**
+ * PKCS1 encodes the given data.
+ * @param  ctx     IN  sc_context_t object
+ * @param  flags   IN  the algorithm to use
+ * @param  in      IN  input buffer
+ * @param  inlen   IN  length of the input
+ * @param  out     OUT output buffer (in == out is allowed) 
+ * @param  outlen  OUT length of the output buffer
+ * @param  modlen  IN  length of the modulus in bytes
+ * @return SC_SUCCESS on success and an error code otherwise
+ */
 int sc_pkcs1_encode(sc_context_t *ctx, unsigned long flags,
-        const u8 *in, size_t in_len, u8 *out, size_t *out_len, size_t mod_len);
-int sc_strip_zero_padding(const u8 *in,size_t in_len, u8 *out, size_t *out_len);
+        const u8 *in, size_t inlen, u8 *out, size_t *outlen, size_t modlen);
+/**
+ * Get the necessary padding and sec. env. flags.
+ * @param  ctx     IN  sc_contex_t object
+ * @param  iflags  IN  the desired algorithms flags
+ * @param  caps    IN  the card / key capabilities
+ * @param  pflags  OUT the padding flags to use
+ * @param  salg    OUT the security env. algorithm flag to use
+ * @return SC_SUCCESS on success and an error code otherwise
+ */
+int sc_get_encoding_flags(sc_context_t *ctx,
+        unsigned long iflags, unsigned long caps,
+        unsigned long *pflags, unsigned long *salg);
 
 /********************************************************************/

trunk/src/libopensc/opensc.h

@@ -182 +182 @@
  * hash values, set these flags accordingly. */
 #define SC_ALGORITHM_RSA_HASH_NONE      0x00000010
-#define SC_ALGORITHM_RSA_HASHES         0x000001E0
 #define SC_ALGORITHM_RSA_HASH_SHA1      0x00000020
 #define SC_ALGORITHM_RSA_HASH_MD5       0x00000040
 #define SC_ALGORITHM_RSA_HASH_MD5_SHA1  0x00000080
 #define SC_ALGORITHM_RSA_HASH_RIPEMD160 0x00000100
+#define SC_ALGORITHM_RSA_HASH_SHA256    0x00000200
+#define SC_ALGORITHM_RSA_HASH_SHA384    0x00000400
+#define SC_ALGORITHM_RSA_HASH_SHA512    0x00000800
+#define SC_ALGORITHM_RSA_HASH_SHA224    0x00001000
+#define SC_ALGORITHM_RSA_HASHES         0x00001FE0
 
 /* Event masks for sc_wait_for_event() */

trunk/src/libopensc/padding.c

@@ -1 +1 @@
 /*
- * sc-padding.c: miscellaneous padding functions
+ * padding.c: miscellaneous padding functions
  *
  * Copyright (C) 2001, 2002  Juha YrjölÀ <juha.yrjola@iki.fi>
- * Copyright (C) 2003   Nils Larsch <larsch@trustcenter.de>
+ * Copyright (C) 2003 - 2007  Nils Larsch <larsch@trustcenter.de>
  *
  * This library is free software; you can redistribute it and/or
@@ -23 +23 @@
 #include <string.h>
 #include <stdlib.h>
-#include <assert.h>
 
 /* TODO doxygen comments */
@@ -38 +37 @@
         0x05, 0x00, 0x04, 0x14
 };
+static const u8 hdr_sha256[] = {
+        0x30, 0x31, 0x30, 0x0d, 0x06, 0x09, 0x60, 0x86, 0x48, 0x01, 0x65,
+        0x03, 0x04, 0x02, 0x01, 0x05, 0x00, 0x04, 0x20
+};
+static const u8 hdr_sha384[] = {
+        0x30, 0x41, 0x30, 0x0d, 0x06, 0x09, 0x60, 0x86, 0x48, 0x01, 0x65,
+        0x03, 0x04, 0x02, 0x02, 0x05, 0x00, 0x04, 0x30
+};
+static const u8 hdr_sha512[] = {
+        0x30, 0x51, 0x30, 0x0d, 0x06, 0x09, 0x60, 0x86, 0x48, 0x01, 0x65,
+        0x03, 0x04, 0x02, 0x03, 0x05, 0x00, 0x04, 0x40
+};
+static const u8 hdr_sha224[] = {
+        0x30, 0x2d, 0x30, 0x0d, 0x06, 0x09, 0x60, 0x86, 0x48, 0x01, 0x65,
+        0x03, 0x04, 0x02, 0x04, 0x05, 0x00, 0x04, 0x1c
+};
 static const u8 hdr_ripemd160[] = {
         0x30, 0x21, 0x30, 0x09, 0x06, 0x05, 0x2b, 0x24, 0x03, 0x02, 0x01,
@@ -44 +59 @@
 
 
-#define DIGEST_INFO_COUNT 6
 static const struct digest_info_prefix {
         unsigned int    algorithm;
@@ -50 +64 @@
         size_t          hdr_len;
         size_t          hash_len;
-} digest_info_prefix[DIGEST_INFO_COUNT] = {
+} digest_info_prefix[] = {
       { SC_ALGORITHM_RSA_HASH_NONE,     NULL,           0,                      0      },
       { SC_ALGORITHM_RSA_HASH_MD5,      hdr_md5,        sizeof(hdr_md5),        16      },
       { SC_ALGORITHM_RSA_HASH_SHA1,     hdr_sha1,       sizeof(hdr_sha1),       20      },
+      { SC_ALGORITHM_RSA_HASH_SHA256,   hdr_sha256,     sizeof(hdr_sha256),     32      },
+      { SC_ALGORITHM_RSA_HASH_SHA384,   hdr_sha384,     sizeof(hdr_sha384),     48      },
+      { SC_ALGORITHM_RSA_HASH_SHA512,   hdr_sha512,     sizeof(hdr_sha512),     64      },
+      { SC_ALGORITHM_RSA_HASH_SHA224,   hdr_sha224,     sizeof(hdr_sha224),     28      },
       { SC_ALGORITHM_RSA_HASH_RIPEMD160,hdr_ripemd160,  sizeof(hdr_ripemd160),  20      },
       { SC_ALGORITHM_RSA_HASH_MD5_SHA1, NULL,           0,                      36      },
@@ -61 +79 @@
 /* add/remove pkcs1 BT01 padding */
 
-int sc_pkcs1_add_01_padding(const u8 *in, size_t in_len, u8 *out,
-        size_t *out_len, size_t mod_length)
+static int sc_pkcs1_add_01_padding(const u8 *in, size_t in_len,
+        u8 *out, size_t *out_len, size_t mod_length)
 {
         size_t i;
@@ -83 +101 @@
 }
 
-int sc_pkcs1_strip_01_padding(const u8 *in_dat, size_t in_len, u8 *out,
-        size_t *out_len)
+int sc_pkcs1_strip_01_padding(const u8 *in_dat, size_t in_len,
+        u8 *out, size_t *out_len)
 {
         const u8 *tmp = in_dat;
@@ -91 +109 @@
         if (in_dat == NULL || in_len < 10)
                 return SC_ERROR_INTERNAL;
-        /* ignore leading zero byte */
+        /* skip leading zero byte */
         if (*tmp == 0) {
                 tmp++;
@@ -123 +141 @@
         if (data == NULL || len < 3)
                 return SC_ERROR_INTERNAL;
-        /* skip leading zero octet (not part of the pkcs1 BT02 padding) */
+        /* skip leading zero byte */
         if (*data == 0) {
                 data++;
@@ -148 +166 @@
 
 /* add/remove DigestInfo prefix */
-int sc_pkcs1_add_digest_info_prefix(unsigned int algorithm, const u8 *in,
-        size_t in_len, u8 *out, size_t *out_len)
+static int sc_pkcs1_add_digest_info_prefix(unsigned int algorithm,
+        const u8 *in, size_t in_len, u8 *out, size_t *out_len)
 {
         int i;
 
-        for (i = 0; i < DIGEST_INFO_COUNT; i++) {
+        for (i = 0; digest_info_prefix[i].algorithm != 0; i++) {
                 if (algorithm == digest_info_prefix[i].algorithm) {
                         const u8 *hdr      = digest_info_prefix[i].hdr;
@@ -176 +194 @@
         int i;
 
-        for (i = 0; i < DIGEST_INFO_COUNT; i++) {
+        for (i = 0; digest_info_prefix[i].algorithm != 0; i++) {
                 size_t    hdr_len  = digest_info_prefix[i].hdr_len,
                           hash_len = digest_info_prefix[i].hash_len;
@@ -240 +258 @@
 }
 
-/* strip leading zero padding (does only really work when a DigestInfo
- * value has been padded */
-int sc_strip_zero_padding(const u8 *in, size_t in_len, u8 *out,
-        size_t *out_len)
-{
-        while (*in == 0 && in_len) {
-                in++;
-                in_len--;
-        }
-
-        if (*out_len < in_len)
-                return SC_ERROR_INTERNAL;
-
-        memmove(out, in, in_len);
-        *out_len = in_len;
+int sc_get_encoding_flags(sc_context_t *ctx,
+        unsigned long iflags, unsigned long caps,
+        unsigned long *pflags, unsigned long *sflags)
+{
+        size_t i;
+
+        if (pflags == NULL || sflags == NULL)
+                return SC_ERROR_INVALID_ARGUMENTS;
+
+        for (i = 0; digest_info_prefix[i].algorithm != 0; i++) {
+                if (iflags & digest_info_prefix[i].algorithm) {
+                        if (digest_info_prefix[i].algorithm != SC_ALGORITHM_RSA_HASH_NONE &&
+                            caps & digest_info_prefix[i].algorithm)
+                                *sflags |= digest_info_prefix[i].algorithm;
+                        else
+                                *pflags |= digest_info_prefix[i].algorithm;
+                        break;
+                }
+        }
+
+        if (iflags & SC_ALGORITHM_RSA_PAD_PKCS1) {
+                if (caps & SC_ALGORITHM_RSA_PAD_PKCS1)
+                        *sflags |= SC_ALGORITHM_RSA_PAD_PKCS1;
+                else
+                        *pflags |= SC_ALGORITHM_RSA_PAD_PKCS1;
+        } else if ((iflags & SC_ALGORITHM_RSA_PADS) == SC_ALGORITHM_RSA_PAD_NONE) {
+                if (!(caps & SC_ALGORITHM_RSA_RAW)) {
+                        sc_error(ctx, "raw RSA is not supported");
+                        return SC_ERROR_NOT_SUPPORTED;
+                }
+                *sflags |= SC_ALGORITHM_RSA_RAW;
+                /* in case of raw RSA there is nothing to pad */
+                *pflags = 0;
+        } else {
+                sc_error(ctx, "unsupported algorithm");
+                return SC_ERROR_NOT_SUPPORTED;
+        }
 
         return SC_SUCCESS;

trunk/src/libopensc/pkcs15-sec.c

@@ -3 +3 @@
  *
  * Copyright (C) 2001, 2002  Juha YrjölÀ <juha.yrjola@iki.fi>
+ * Copyrigth (C) 2007        Nils Larsch <nils@larsch.net>
  *
  * This library is free software; you can redistribute it and/or
@@ -21 +22 @@
 #include "internal.h"
 #include "pkcs15.h"
-#include <assert.h>
 #include <string.h>
 #include <stdlib.h>
@@ -69 +69 @@
         sc_context_t *ctx = p15card->card->ctx;
         const struct sc_pkcs15_prkey_info *prkey = (const struct sc_pkcs15_prkey_info *) obj->data;
-        unsigned long pad_flags = 0;
+        unsigned long pad_flags = 0, sec_flags = 0;
 
         SC_FUNC_CALLED(ctx, 1);
@@ -88 +88 @@
         }
         senv.algorithm = SC_ALGORITHM_RSA;
-        senv.algorithm_flags = 0;
-
-        if (flags & SC_ALGORITHM_RSA_PAD_PKCS1) {
-                if (!(alg_info->flags & SC_ALGORITHM_RSA_PAD_PKCS1))
-                        pad_flags |= SC_ALGORITHM_RSA_PAD_PKCS1;
-                else
-                        senv.algorithm_flags |= SC_ALGORITHM_RSA_PAD_PKCS1;
-        } else if ((flags & SC_ALGORITHM_RSA_PAD_ANSI) ||
-                   (flags & SC_ALGORITHM_RSA_PAD_ISO9796)) {
-                sc_error(ctx, "Only PKCS #1 padding method supported\n");
-                return SC_ERROR_NOT_SUPPORTED;
-        } else {
-                if (!(alg_info->flags & SC_ALGORITHM_RSA_RAW)) {
-                        sc_error(ctx, "Card requires RSA padding\n");
-                        return SC_ERROR_NOT_SUPPORTED;
-                }
-                senv.algorithm_flags |= SC_ALGORITHM_RSA_RAW;
-        }
-
-        senv.operation = SC_SEC_OPERATION_DECIPHER;
-        senv.flags = 0;
+
+        r = sc_get_encoding_flags(ctx, flags, alg_info->flags, &pad_flags, &sec_flags);
+        if (r != SC_SUCCESS)
+                return r;
+
+        senv.algorithm_flags = sec_flags;
+        senv.operation       = SC_SEC_OPERATION_DECIPHER;
+        senv.flags           = 0;
         /* optional keyReference attribute (the default value is -1) */
         if (prkey->key_reference >= 0) {
@@ -141 +128 @@
         if (pad_flags & SC_ALGORITHM_RSA_PAD_PKCS1) {
                 r = sc_pkcs1_strip_02_padding(out, (size_t)r, out, (size_t *) &r);
-                        SC_TEST_RET(ctx, r, "Invalid PKCS#1 padding");
+                SC_TEST_RET(ctx, r, "Invalid PKCS#1 padding");
         }
 
@@ -157 +144 @@
         sc_algorithm_info_t *alg_info;
         const struct sc_pkcs15_prkey_info *prkey = (const struct sc_pkcs15_prkey_info *) obj->data;
-        u8 buf[512], *tmpin, *tmpout, *help;
-        size_t tmpoutlen;
-        unsigned long pad_flags = 0;
+        u8 buf[512], *tmp;
+        size_t modlen = prkey->modulus_length / 8;
+        unsigned long pad_flags = 0, sec_flags = 0;
 
         SC_FUNC_CALLED(ctx, 1);
@@ -181 +168 @@
 
         /* Probably never happens, but better make sure */
-        if (inlen > sizeof(buf))
+        if (inlen > sizeof(buf) || outlen < modlen)
                 return SC_ERROR_BUFFER_TOO_SMALL;
         memcpy(buf, in, inlen);
-        tmpin = buf;
-        if (outlen < (prkey->modulus_length + 7) / 8)
-                return SC_ERROR_BUFFER_TOO_SMALL;
-        tmpout = out;
+        tmp = buf;
 
         /* flags: the requested algo
@@ -198 +182 @@
             !(alg_info->flags & (SC_ALGORITHM_RSA_RAW | SC_ALGORITHM_RSA_HASH_NONE))) {
                 unsigned int algo;
-                tmpoutlen = sizeof(buf);
-                r = sc_pkcs1_strip_digest_info_prefix(&algo, tmpin, inlen, tmpout, &tmpoutlen);
-                if (r != SC_SUCCESS || algo == SC_ALGORITHM_RSA_HASH_NONE)
+                size_t tmplen = sizeof(buf);
+                r = sc_pkcs1_strip_digest_info_prefix(&algo, tmp, inlen, tmp, &tmplen);
+                if (r != SC_SUCCESS || algo == SC_ALGORITHM_RSA_HASH_NONE) {
+                        sc_mem_clear(buf, sizeof(buf));
                         return SC_ERROR_INVALID_DATA;
-                help = tmpin;
-                tmpin = tmpout;
-                tmpout = help;
-                inlen = tmpoutlen;
+                }
                 flags &= ~SC_ALGORITHM_RSA_HASH_NONE;
                 flags |= algo;
-        }
-
-        senv.algorithm_flags = 0;
-        if (flags & SC_ALGORITHM_RSA_HASH_SHA1) {
-                if (inlen != 20)
-                        SC_FUNC_RETURN(ctx, 0, SC_ERROR_WRONG_LENGTH);
-                if (!(alg_info->flags & SC_ALGORITHM_RSA_HASH_SHA1))
-                        pad_flags |= SC_ALGORITHM_RSA_HASH_SHA1;
-                else
-                        senv.algorithm_flags |= SC_ALGORITHM_RSA_HASH_SHA1;
-        } else if (flags & SC_ALGORITHM_RSA_HASH_MD5) {
-                if (inlen != 16)
-                        SC_FUNC_RETURN(ctx, 0, SC_ERROR_WRONG_LENGTH);
-                if (!(alg_info->flags & SC_ALGORITHM_RSA_HASH_MD5))
-                        pad_flags |= SC_ALGORITHM_RSA_HASH_MD5;
-                else
-                        senv.algorithm_flags |= SC_ALGORITHM_RSA_HASH_MD5;
-        } else if (flags & SC_ALGORITHM_RSA_HASH_RIPEMD160) {
-                if (inlen != 20)
-                        SC_FUNC_RETURN(ctx, 0, SC_ERROR_WRONG_LENGTH);
-                if (!(alg_info->flags & SC_ALGORITHM_RSA_HASH_RIPEMD160))
-                        pad_flags |= SC_ALGORITHM_RSA_HASH_RIPEMD160;
-                else
-                        senv.algorithm_flags |= SC_ALGORITHM_RSA_HASH_RIPEMD160;
-        } else if (flags & SC_ALGORITHM_RSA_HASH_MD5_SHA1) {
-                if (inlen != 36)
-                        SC_FUNC_RETURN(ctx, 0, SC_ERROR_WRONG_LENGTH);
-                if (!(alg_info->flags & SC_ALGORITHM_RSA_HASH_MD5_SHA1))
-                        pad_flags |= SC_ALGORITHM_RSA_HASH_MD5_SHA1;
-                else
-                        senv.algorithm_flags |= SC_ALGORITHM_RSA_HASH_MD5_SHA1;
-        } else if (flags & SC_ALGORITHM_RSA_HASH_NONE ||
-                   (flags & SC_ALGORITHM_RSA_HASHES) == 0) {
-                pad_flags |= SC_ALGORITHM_RSA_HASH_NONE;
-        }
-
-        if (flags & SC_ALGORITHM_RSA_PAD_PKCS1) {
-                if (!(alg_info->flags & SC_ALGORITHM_RSA_PAD_PKCS1))
-                        pad_flags |= SC_ALGORITHM_RSA_PAD_PKCS1;
-                else
-                        senv.algorithm_flags |= SC_ALGORITHM_RSA_PAD_PKCS1;
-        } else if ((flags & SC_ALGORITHM_RSA_PAD_ANSI) ||
-                   (flags & SC_ALGORITHM_RSA_PAD_ISO9796)) {
-                sc_error(ctx, "Only PKCS #1 padding method supported\n");
-                return SC_ERROR_NOT_SUPPORTED;
-        } else {
-                if (!(alg_info->flags & SC_ALGORITHM_RSA_RAW)) {
-                        sc_error(ctx, "Card requires RSA padding\n");
-                        return SC_ERROR_NOT_SUPPORTED;
-                }
-                senv.algorithm_flags |= SC_ALGORITHM_RSA_RAW;
-                pad_flags = 0;
-
-                /* Add zero-padding if input shorter than modulus */
-                if (inlen < prkey->modulus_length/8) {
-                        unsigned int    modulus_len = prkey->modulus_length/8;
-                        if (modulus_len > sizeof(buf))
+                inlen = tmplen;
+        }
+
+        r = sc_get_encoding_flags(ctx, flags, alg_info->flags, &pad_flags, &sec_flags);
+        if (r != SC_SUCCESS) {
+                sc_mem_clear(buf, sizeof(buf));
+                return r;
+        }
+        senv.algorithm_flags = sec_flags;
+
+        /* add the padding bytes (if necessary) */
+        if (pad_flags != 0) {
+                size_t tmplen = sizeof(buf);
+                r = sc_pkcs1_encode(ctx, pad_flags, tmp, inlen, tmp, &tmplen, modlen);
+                SC_TEST_RET(ctx, r, "Unable to add padding");
+                inlen = tmplen;
+        } else if ((flags & SC_ALGORITHM_RSA_PADS) == SC_ALGORITHM_RSA_PAD_NONE) {
+                /* Add zero-padding if input is shorter than the modulus */
+                if (inlen < modlen) {
+                        if (modlen > sizeof(buf))
                                 return SC_ERROR_BUFFER_TOO_SMALL;
-                        memset(tmpout, 0, sizeof(buf));
-                        memcpy(tmpout + modulus_len - inlen, tmpin, inlen);
-                        inlen = modulus_len;
-                        help = tmpin;
-                        tmpin = tmpout;
-                        tmpout = help;
-                }
-        }
-
-        if (pad_flags) {
-                tmpoutlen = sizeof(buf);
-                r = sc_pkcs1_encode(ctx, pad_flags, tmpin, inlen, tmpout, &tmpoutlen,
-                                    prkey->modulus_length/8);
-                SC_TEST_RET(ctx, r, "Unable to add padding");
-                help = tmpin;
-                tmpin = tmpout;
-                tmpout = help;
-                inlen = tmpoutlen;
+                        memmove(tmp+modlen-inlen, tmp, inlen);
+                        memset(tmp, 0, modlen-inlen);
+                }
         }
 
@@ -299 +229 @@
         SC_TEST_RET(ctx, r, "sc_lock() failed");
 
-        if (prkey->path.len != 0)
-        {
+        if (prkey->path.len != 0) {
                 r = select_key_file(p15card, prkey, &senv);
                 if (r < 0) {
@@ -314 +243 @@
         }
 
-        /* XXX: Should we adjust outlen to match the size of
-         * the signature we expect? CardOS for instance will
-         * barf if the LE value doesn't match the size of the
-         * signature exactly.
-         *
-         * Right now we work around this by assuming that eToken keys
-         * always have algorithm RSA_PURE_SIG so the input buffer
-         * is padded and has the same length as the signature. --okir 
-         */
-        if (tmpin == out) {
-                memcpy(tmpout, tmpin, inlen);
-                tmpin = tmpout;
-        }
-        r = sc_compute_signature(p15card->card, tmpin, inlen, out, outlen);
+        r = sc_compute_signature(p15card->card, tmp, inlen, out, outlen);
         sc_mem_clear(buf, sizeof(buf));
         sc_unlock(p15card->card);

trunk/src/pkcs11/framework-pkcs15.c

@@ -1948 +1948 @@
                 flags = SC_ALGORITHM_RSA_PAD_PKCS1 | SC_ALGORITHM_RSA_HASH_SHA1;
                 break;
+        case CKM_SHA256_RSA_PKCS:
+                flags = SC_ALGORITHM_RSA_PAD_PKCS1 | SC_ALGORITHM_RSA_HASH_SHA256;
+                break;
+        case CKM_SHA384_RSA_PKCS:
+                flags = SC_ALGORITHM_RSA_PAD_PKCS1 | SC_ALGORITHM_RSA_HASH_SHA384;
+                break;
+        case CKM_SHA512_RSA_PKCS:
+                flags = SC_ALGORITHM_RSA_PAD_PKCS1 | SC_ALGORITHM_RSA_HASH_SHA512;
+                break;
         case CKM_RIPEMD160_RSA_PKCS:
                 flags = SC_ALGORITHM_RSA_PAD_PKCS1 | SC_ALGORITHM_RSA_HASH_RIPEMD160;

trunk/src/pkcs11/openssl.c

@@ -13 +13 @@
 #include <openssl/rand.h>
 #include <openssl/rsa.h>
+#include <openssl/opensslv.h>
 
 static CK_RV    sc_pkcs11_openssl_md_init(sc_pkcs11_operation_t *);
@@ -31 +32 @@
 };
 
+#if OPENSSL_VERSION_NUMBER >= 0x00908000L
+static sc_pkcs11_mechanism_type_t openssl_sha256_mech = {
+        CKM_SHA256,
+        { 0, 0, CKF_DIGEST }, 0,
+        sizeof(struct sc_pkcs11_operation),
+        sc_pkcs11_openssl_md_release,
+        sc_pkcs11_openssl_md_init,
+        sc_pkcs11_openssl_md_update,
+        sc_pkcs11_openssl_md_final
+};
+
+static sc_pkcs11_mechanism_type_t openssl_sha384_mech = {
+        CKM_SHA384,
+        { 0, 0, CKF_DIGEST }, 0,
+        sizeof(struct sc_pkcs11_operation),
+        sc_pkcs11_openssl_md_release,
+        sc_pkcs11_openssl_md_init,
+        sc_pkcs11_openssl_md_update,
+        sc_pkcs11_openssl_md_final
+};
+
+static sc_pkcs11_mechanism_type_t openssl_sha512_mech = {
+        CKM_SHA512,
+        { 0, 0, CKF_DIGEST }, 0,
+        sizeof(struct sc_pkcs11_operation),
+        sc_pkcs11_openssl_md_release,
+        sc_pkcs11_openssl_md_init,
+        sc_pkcs11_openssl_md_update,
+        sc_pkcs11_openssl_md_final
+};
+#endif
+
 static sc_pkcs11_mechanism_type_t openssl_md5_mech = {
         CKM_MD5,