Changeset 3310

Timestamp:

01/03/08 08:59:14 (12 months ago)

Author:

ludovic.rousseau

Message:

new patch for ruToken support

Thanks to Andrew V. Stepanov
http://www.opensc-project.org/pipermail/opensc-devel/2007-December/010631.html

Location:

trunk/src

Files:

• libopensc/Makefile.am (modified) (1 diff)
• libopensc/card-rutoken.c (modified) (34 diffs)
• libopensc/cardctl.h (modified) (3 diffs)
• libopensc/pkcs15-rutoken.c (modified) (5 diffs)
• pkcs11/framework-pkcs15.c (modified) (2 diffs)
• pkcs15init/Makefile.am (modified) (1 diff)
• pkcs15init/rutoken.profile (modified) (1 diff)
• tools/rutoken-tool.c (modified) (3 diffs)

trunk/src/libopensc/Makefile.am

@@ -37 +37 @@
         pkcs15-tcos.c pkcs15-esteid.c pkcs15-postecert.c pkcs15-gemsafeGPK.c \
         pkcs15-actalis.c pkcs15-atrust-acos.c pkcs15-tccardos.c pkcs15-piv.c \
-        compression.c p15card-helper.c pkcs15-rutoken.c
+        pkcs15-rutoken.c pkcs15-prkey-rutoken.c \
+        compression.c p15card-helper.c
 libopensc_la_LDFLAGS = -version-info @OPENSC_LT_CURRENT@:@OPENSC_LT_REVISION@:@OPENSC_LT_AGE@
 libopensc_la_LIBADD = @LIBSCCONF@ $(OPENSSL_LIBS) $(OPENCT_LIBS) $(PCSC_LIBS) $(LTLIB_LIBS)

trunk/src/libopensc/card-rutoken.c

@@ -21 +21 @@
 #include "internal.h"
 #include "cardctl.h"
+#include <sys/types.h>
 #include <ctype.h>
 #include <string.h>
@@ -37 +38 @@
 #endif
 
-
-
 #define FDESCR_DF           0x38    /*00111000b*/
 #define FDESCR_EF           0x01
@@ -44 +43 @@
 #define ID_RESERVED_CURDF   0x3FFF      /*Reserved ID for current DF*/
 
-int get_prkey_from_bin(u8* data, int len, struct sc_pkcs15_prkey **key);
+#ifdef HAVE_OPENSSL
+int get_prkey_from_bin(const u8 *data, size_t len, struct sc_pkcs15_prkey **key);
+#endif
 
 #ifdef BIG_ENDIAN_RUTOKEN
@@ -51 +52 @@
 #define MF_PATH             "\x00\x3F"
 #endif
+
 struct auth_senv {
         unsigned int algorithm;
-        int key_file_id;
-        size_t key_size;
-        unsigned int algorithm_flags;
-        sc_path_t path;
 };
 typedef struct auth_senv auth_senv_t;
 
 static const sc_SecAttrV2_t default_sec_attr = {
-        0x40, 
-        0, 0, 0, 0, 0, 0, 1,
-        0, 0, 0, 0, 0, 0, 2
+        0x42,
+        0, 1, 0, 0, 0, 0, 1,
+        0, 2, 0, 0, 0, 0, 2
 };
 
 static const struct sc_card_operations *iso_ops = NULL;
 
-struct sc_card_operations rutoken_ops;
+static struct sc_card_operations rutoken_ops;
+
 static struct sc_card_driver rutoken_drv = {
         "ruToken driver",
@@ -81 +80 @@
 };
 
-static int make_le_path(u8 *hPath, size_t len);
-static int rutoken_get_do_info(sc_card_t *card, sc_DO_INFO_t * pInfo);
-
 const char *hexdump(const void *data, size_t len)
 {
@@ -124 +120 @@
 {
         int ret = SC_ERROR_MEMORY_FAILURE;
-#ifdef DEBUG
-        /*  if(!card->ctx->debug) card->ctx->debug = 1;  */
-#endif
-        SC_FUNC_CALLED(card->ctx, 1);
+
+        SC_FUNC_CALLED(card->ctx, 1);
+
         card->name = "rutoken card";
         card->drv_data = malloc(sizeof(auth_senv_t));
@@ -138 +133 @@
         /* add algorithm 
         TODO: may nid som other flag  */
-        unsigned int flags = SC_ALGORITHM_RSA_RAW | SC_ALGORITHM_RSA_PAD_PKCS1; /* SC_ALGORITHM_RSA_RAW | SC_ALGORITHM_RSA_HASH_SHA1 | SC_ALGORITHM_RSA_HASH_MD5_SHA1 | SC_ALGORITHM_RSA_PAD_NONE*/
+        unsigned int flags = SC_ALGORITHM_RSA_RAW | SC_ALGORITHM_RSA_PAD_PKCS1;
+                                /* SC_ALGORITHM_RSA_RAW | SC_ALGORITHM_RSA_HASH_SHA1
+                                | SC_ALGORITHM_RSA_HASH_MD5_SHA1
+                                | SC_ALGORITHM_RSA_PAD_NONE */
 
         _sc_card_add_rsa_alg(card, 256, flags, 0);
@@ -146 +144 @@
         _sc_card_add_rsa_alg(card, 2048, flags, 0);
         sc_algorithm_info_t info;
-        flags = SC_ALGORITHM_GOST_CRYPT_PZ | SC_ALGORITHM_GOST_CRYPT_GAMM | SC_ALGORITHM_GOST_CRYPT_GAMMOS;
+        flags = SC_ALGORITHM_GOST_CRYPT_PZ | SC_ALGORITHM_GOST_CRYPT_GAMM
+                | SC_ALGORITHM_GOST_CRYPT_GAMMOS;
         memset(&info, 0, sizeof(info));
         info.algorithm = SC_ALGORITHM_GOST;
@@ -221 +220 @@
         for (i = 0; i < err_count; i++) {
                 if (rutoken_errors[i].SWs == ((sw1 << 8) | sw2)) {
-                        if ( rutoken_errors[i].errorstr ) sc_debug(card->ctx, rutoken_errors[i].errorstr);
+                        if ( rutoken_errors[i].errorstr )
+                                sc_debug(card->ctx, rutoken_errors[i].errorstr);
                         /*SC_FUNC_RETURN(card->ctx, 1, rutoken_errors[i].errorno);*/
                         return rutoken_errors[i].errorno;
@@ -231 +231 @@
 }
 
-int rutoken_dir_up(sc_card_t *card)
+static int rutoken_dir_up(sc_card_t *card)
 {
     u8 rbuf[256];
@@ -252 +252 @@
 }
 
+/* make little endian path from normal path.
+   return 1 if right len, otherwise 0  */
+static int make_le_path(u8 *hPath, size_t len)
+{
+#ifdef BIG_ENDIAN_RUTOKEN
+        /*   we don't need it any more  */
+        return 1;
+#else
+        int i, ret = (len > 1) && !(len & 1);  /*  && (len <= SC_MAX_PATH_SIZE);  */
+        if (ret)
+        {
+                for(i = 0; i < len; i += 2)
+                {
+                        u8 b = hPath[i];
+                        hPath[i] = hPath[i+1];
+                        hPath[i+1] =  b;
+                }
+        }
+        return ret;
+#endif
+}
 
 static int rutoken_list_files(sc_card_t *card, u8 *buf, size_t buflen)
@@ -288 +309 @@
         
         /*  00 a4 00 02 02 prev id - next  */
-        while(1){
+        while(1)
+        {
             sc_format_apdu(card, &apdu, SC_APDU_CASE_4_SHORT, 0xA4, 0x00, 0x06);
             apdu.cla = 0x00;
@@ -318 +340 @@
 }
 
-/*  make little endian path from normal path.
-  return 1 if right len, otherwise 0  */
-static int make_le_path(u8 *hPath, size_t len)
-{
-#ifdef BIG_ENDIAN_RUTOKEN
-        /*   we don't need it any more  */
-  return 1;
-#else
-        int i, ret = (len > 1) && !(len & 1);  /*  && (len <= SC_MAX_PATH_SIZE);  */
-        if (ret)
-        {
-                for(i = 0; i < len; i += 2)
-                {
-                        u8 b = hPath[i];
-                        hPath[i] = hPath[i+1];
-                        hPath[i+1] =  b;
-                }
-        }
-        return ret;
-#endif
-}
-
-void rutoken_process_fcp(sc_card_t *card, u8 *pIn, sc_file_t *file)
+static void rutoken_process_fcp(sc_card_t *card, u8 *pIn, sc_file_t *file)
 {
 #ifdef BIG_ENDIAN_RUTOKEN
@@ -466 +466 @@
 {
         int ret = SC_ERROR_NOT_SUPPORTED;
-
         return ret;
 }
 */
 
-static int rutoken_construct_fcp(sc_card_t *card, const sc_file_t *file,
-        u8 *out)
+static int rutoken_construct_fcp(sc_card_t *card, const sc_file_t *file, u8 *out)
 {
         SC_FUNC_CALLED(card->ctx, 1);
@@ -494 +492 @@
                 out[4] = 0x01;
                 /*   set the length (write to wBodyLen)  */
-                /*  *((unsigned short int*)(out) + 1) = (unsigned short int)file->size; */
 #ifdef BIG_ENDIAN_RUTOKEN
                 out[2] = file->size / 256;
@@ -508 +505 @@
         }
         /*   set file ID  */
-        /*  *((unsigned short int*)(out) + 3) = (unsigned short int)file->id;  */
 #ifdef BIG_ENDIAN_RUTOKEN
         out[6] = file->id / 256;
@@ -522 +518 @@
                 memcpy(out + 17, &default_sec_attr, SEC_ATTR_SIZE);
         
-        
         SC_FUNC_RETURN(card->ctx, 1, SC_NO_ERROR);
 }
@@ -579 +574 @@
 }
 
+static int rutoken_verify(sc_card_t *card, unsigned int type, int ref_qualifier,
+                        const u8 *data, size_t data_len, int *tries_left)
+{
+        int ret = SC_ERROR_CARD_CMD_FAILED;
+        sc_apdu_t apdu;
+
+        SC_FUNC_CALLED(card->ctx, 1);
+        sc_format_apdu(card, &apdu, SC_APDU_CASE_3_SHORT, 0x20, 0x00, ref_qualifier);
+        apdu.lc = data_len;
+        apdu.datalen = data_len;
+        apdu.data = data;
+        if(sc_transmit_apdu(card, &apdu) >= 0)
+        {
+                ret = rutoken_check_sw(card, apdu.sw1, apdu.sw2);
+                if(ret == SC_ERROR_PIN_CODE_INCORRECT  &&  tries_left)
+                {
+                        sc_format_apdu(card, &apdu, SC_APDU_CASE_1, 0x20, 0x00,
+                                        ref_qualifier);
+                        ret = sc_transmit_apdu(card, &apdu);
+                        if(ret >= 0)
+                        {
+                                ret = rutoken_check_sw(card, apdu.sw1, apdu.sw2);
+                                if(ret == SC_ERROR_PIN_CODE_INCORRECT)
+                                        *tries_left = (int)(apdu.sw2 & 0x0f);
+                        }
+                }
+        }
+        SC_FUNC_RETURN(card->ctx, 1, ret);
+}
+
 static int rutoken_logout(sc_card_t *card)
 {
@@ -585 +610 @@
         sc_path_t path;
 
+        SC_FUNC_CALLED(card->ctx, 1);
         sc_format_path("3F00", &path);
         if (rutoken_select_file(card, &path, NULL) == SC_SUCCESS)
@@ -596 +622 @@
 }
 
+static int rutoken_change_reference_data(sc_card_t *card, unsigned int type,
+                        int ref_qualifier, const u8 *old, size_t oldlen,
+                        const u8 *newref, size_t newlen, int *tries_left)
+{
+        int left;
+        int ret = SC_ERROR_CARD_CMD_FAILED;
+        sc_apdu_t apdu;
+
+        SC_FUNC_CALLED(card->ctx, 1);
+        
+        if(old && oldlen)
+        {
+                sc_format_apdu(card, &apdu, SC_APDU_CASE_1, 0x20, 0x00, ref_qualifier);
+                if(sc_transmit_apdu(card, &apdu) >= 0
+                                &&  apdu.sw1 != 0x90  &&  apdu.sw2 != 0x00)
+                {
+                        rutoken_logout(card);
+                        rutoken_verify(card, type, ref_qualifier, old, oldlen, &left);
+                }
+        }
+        sc_format_apdu(card, &apdu, SC_APDU_CASE_3_SHORT, 0x24, 0x01, ref_qualifier);
+        apdu.lc = newlen;
+        apdu.datalen = newlen;
+        apdu.data = newref;
+        if(sc_transmit_apdu(card, &apdu) >= 0)
+        {
+                ret = rutoken_check_sw(card, apdu.sw1, apdu.sw2);
+                if(ret == SC_ERROR_PIN_CODE_INCORRECT  &&  tries_left)
+                        *tries_left = (int)(apdu.sw2 & 0x0f);
+        }
+        SC_FUNC_RETURN(card->ctx, 1, ret);
+}
+
+static int rutoken_reset_retry_counter(sc_card_t *card, unsigned int type,
+                        int ref_qualifier, const u8 *puk, size_t puklen,
+                        const u8 *newref, size_t newlen)
+{
+#ifdef FORCE_VERIFY_RUTOKEN
+        int left;
+#endif
+        int ret = SC_ERROR_CARD_CMD_FAILED;
+        sc_apdu_t apdu;
+
+        SC_FUNC_CALLED(card->ctx, 1);
+#ifdef FORCE_VERIFY_RUTOKEN
+        if(puk && puklen)
+        {
+                sc_format_apdu(card, &apdu, SC_APDU_CASE_1, 0x20, 0x00, ref_qualifier);
+                if(sc_transmit_apdu(card, &apdu) >= 0
+                                &&  apdu.sw1 != 0x90  &&  apdu.sw2 != 0x00)
+                {
+                        rutoken_logout(card);
+                        rutoken_verify(card, type, ref_qualifier, puk, puklen, &left);
+                }
+        }
+#endif
+        sc_format_apdu(card, &apdu, SC_APDU_CASE_1, 0x2c, 0x03, ref_qualifier);
+        if(sc_transmit_apdu(card, &apdu) >= 0)
+                ret = rutoken_check_sw(card, apdu.sw1, apdu.sw2);
+        SC_FUNC_RETURN(card->ctx, 1, ret);
+}
+
 static int rutoken_restore_security_env(sc_card_t *card, int se_num)
 {
         int ret = SC_ERROR_CARD_CMD_FAILED;
         sc_apdu_t apdu;
-        SC_FUNC_CALLED(card->ctx, 1);
-        
+
+        SC_FUNC_CALLED(card->ctx, 1);
         sc_format_apdu(card, &apdu, SC_APDU_CASE_1, 0x22, 3, se_num);
         if(sc_transmit_apdu(card, &apdu) >= 0)
                 ret = rutoken_check_sw(card, apdu.sw1, apdu.sw2);
-
-        SC_FUNC_RETURN(card->ctx, 1, ret);
-}
-
-int rutoken_set_security_env(sc_card_t *card,
+        SC_FUNC_RETURN(card->ctx, 1, ret);
+}
+
+static int rutoken_set_security_env(sc_card_t *card, 
                          const sc_security_env_t *env,
                          int se_num)
@@ -621 +708 @@
         if(env->algorithm == SC_ALGORITHM_RSA)
         {
-                const char PRK_DF[] = "3F0000000000FF001001";
-                sc_debug(card->ctx, "RSA\n");
                 senv->algorithm = SC_ALGORITHM_RSA_RAW;
-                if(env->operation == SC_SEC_OPERATION_DECIPHER || env->operation == SC_SEC_OPERATION_SIGN)
-                {
-                        sc_format_path(PRK_DF, &senv->path);
-                        sc_append_path(&senv->path, &env->file_ref);
-                }
-                else ret = SC_ERROR_INVALID_ARGUMENTS;
                 return ret;
         }
         else
                 senv->algorithm = SC_ALGORITHM_GOST;
+
         if (env->key_ref_len != 1)
         {
@@ -672 +752 @@
                         ret = rutoken_check_sw(card, apdu.sw1, apdu.sw2);
         }
-        /*  set driver data  */
-        if (ret == SC_NO_ERROR)
-        {
-                /*  TODO: add check  */
-                senv->algorithm = SC_ALGORITHM_GOST;
-                senv->algorithm_flags = env->algorithm_flags;
-                senv->key_file_id = env->key_ref[0];
-                senv->key_size = 256;
-        }
-        SC_FUNC_RETURN(card->ctx, 1, ret);
-}
-
-void rutoken_set_do_hdr(u8 *data, sc_DOHdrV2_t *pHdr)
+        SC_FUNC_RETURN(card->ctx, 1, ret);
+}
+
+static void rutoken_set_do_hdr(u8 *data, sc_DOHdrV2_t *pHdr)
 {
         if(data)
         {
+#ifdef BIG_ENDIAN_RUTOKEN
+                data[0] = (u8)(pHdr->wDOBodyLen / 0x100);
+                data[1] = (u8)(pHdr->wDOBodyLen % 0x100);
+#else
                 data[0] = (u8)(pHdr->wDOBodyLen % 0x100);
                 data[1] = (u8)(pHdr->wDOBodyLen / 0x100);
+#endif
                 data[2] = (u8)(pHdr->OTID.byObjectType);
                 data[3] = (u8)(pHdr->OTID.byObjectID);
@@ -699 +775 @@
                 memcpy(data + 17, pHdr->SA_V2, SEC_ATTR_SIZE);
         }
-}
-
-void rutoken_set_do(u8 *data, sc_DO_V2_t * pDO)
-{
-        rutoken_set_do_hdr(data, &pDO->HDR);
-        memcpy(data + SC_RUTOKEN_DO_HDR_LEN, pDO->abyDOBody, pDO->HDR.wDOBodyLen);
 }
 
@@ -762 +832 @@
         else
         {
-                rutoken_set_do(data, pDO);
+                rutoken_set_do_hdr(data, &pDO->HDR);
+                memcpy(data + SC_RUTOKEN_DO_HDR_LEN, pDO->abyDOBody, pDO->HDR.wDOBodyLen);
                 
                 sc_format_apdu(card, &apdu, SC_APDU_CASE_3_SHORT, 0xda, 0x01, 0x62);
@@ -865 +936 @@
                    u8 * out, size_t outlen, int p1, int p2, int isIV)
 {
-        sc_apdu_t apdu;
-        int rv = SC_NO_ERROR;
-        
-        sc_debug(card->ctx,": crgram_len %i;  outlen %i\n", crgram_len, outlen);
-        if (!out || !outlen) 
+        const size_t cipher_chunk = 248;  /* cipher_chunk <= SC_MAX_APDU_BUFFER_SIZE  */
+        size_t len, outlen_tail = outlen;
+        u8 *buf;
+        int ret;
+        sc_apdu_t apdu;
+        
+        SC_FUNC_CALLED(card->ctx, 1);
+        sc_debug(card->ctx, ": crgram_len %i; outlen %i\n", crgram_len, outlen);
+
+        if (!out)
                 return SC_ERROR_INVALID_ARGUMENTS;
+        if (crgram_len < 16 || ((crgram_len) % 8))
+                return SC_ERROR_WRONG_LENGTH;
+
+        buf = malloc(cipher_chunk);
+        if (!buf)
+                return SC_ERROR_OUT_OF_MEMORY;
         
         sc_format_apdu(card, &apdu, SC_APDU_CASE_4_SHORT, 0x2A, p1, p2);
-        
-        apdu.resp = (u8*)malloc(SC_MAX_APDU_BUFFER_SIZE);
-        if (!apdu.resp)
-                return SC_ERROR_OUT_OF_MEMORY;
-        apdu.resplen = SC_MAX_APDU_BUFFER_SIZE;
-        if (crgram_len < 16 || ((crgram_len) % 8))  
-                rv = SC_ERROR_WRONG_LENGTH;
-        size_t cur_len = 0;
-        unsigned char is_first = 1;
-        unsigned int cur_data_len;      
-        
-        while( (rv == SC_NO_ERROR) && (cur_len != crgram_len) && (outlen > cur_len))
-        {
-                cur_data_len = (crgram_len - cur_len) % 248;
-                if(!cur_data_len) cur_data_len = 248;
-                
-                apdu.data = crgram + cur_len;
-                apdu.lc = apdu.datalen = cur_data_len;
-                apdu.cla = crgram_len - cur_len - cur_data_len > 0 ? 0x10 : 0x00;
-                apdu.le = apdu.resplen = 248;
-                
-                if((rv = sc_transmit_apdu(card, &apdu)) >= 0 &&
-                   (rv = rutoken_check_sw(card, apdu.sw1, apdu.sw2)) == SC_NO_ERROR) 
+        do
+        {
+                len = (crgram_len > cipher_chunk) ? cipher_chunk : crgram_len;
+                apdu.lc = len;
+                apdu.datalen = len;
+                apdu.data = crgram;
+                crgram += len;
+                crgram_len -= len;
+
+                apdu.cla = (crgram_len == 0) ? 0x00 : 0x10;
+                apdu.le = len;
+                apdu.resplen = len;
+                apdu.resp = buf;
+        
+                if (sc_transmit_apdu(card, &apdu) >= 0)
+                        ret = rutoken_check_sw(card, apdu.sw1, apdu.sw2);
+                else
+                        ret = SC_ERROR_CARD_CMD_FAILED;
+                if (ret == SC_NO_ERROR)
                 {
-                        if(isIV && is_first)
+                        if (isIV)
                         {
-                                /*  break initialization vector  */
-                                memcpy(out, apdu.resp + 8, apdu.resplen - 8);
-                                out += apdu.resplen - 8;
-                                cur_len += apdu.resplen;
-                                is_first = 0;
+                                apdu.resp += 8;
+                                apdu.resplen -= 8;
+                                isIV = 0;
                         }
+                        if (apdu.resplen > outlen_tail)
+                                ret = SC_ERROR_BUFFER_TOO_SMALL;
                         else
                         {
-                                /*  memcpy(out + cur_len, apdu.resp, apdu.resplen);  */
                                 memcpy(out, apdu.resp, apdu.resplen);
-                                cur_len += apdu.resplen;
                                 out += apdu.resplen;
+                                outlen_tail -= apdu.resplen;
                         }
                 }
-        }
-        if (rv == SC_NO_ERROR) rv = (cur_len == crgram_len) ? isIV ? cur_len - 8 : cur_len : SC_ERROR_BUFFER_TOO_SMALL;
-        
-        if (apdu.resp)
-                free(apdu.resp);
-        
-        sc_debug(card->ctx, "return decipher len %d\n", rv);
-        return rv;
+        } while (ret == SC_NO_ERROR  &&  crgram_len != 0);
+        
+        free(buf);
+        
+        sc_debug(card->ctx, "len out cipher %d\n", outlen - outlen_tail);
+        if (ret == SC_NO_ERROR)
+                ret = (outlen_tail == 0) ? (int)outlen : SC_ERROR_WRONG_LENGTH;
+
+        SC_FUNC_RETURN(card->ctx, 1, ret);
 }
 
 /*  Launcher for chipher  */
-static int rutoken_decipher(sc_card_t *card, struct sc_rutoken_decipherinfo *ptr)
-{
-        return rutoken_cipher_p(card, ptr->inbuf, ptr->inlen, ptr->outbuf, ptr->outlen, 0x80, 0x86, 1);
-}
-
-/*  Launcher for chipher  */
-
-static int rutoken_encipher(sc_card_t *card, struct sc_rutoken_decipherinfo *ptr)
-{
-        return rutoken_cipher_p(card, ptr->inbuf, ptr->inlen, ptr->outbuf, ptr->outlen, 0x86, 0x80, 0);
-}
-
-int rutoken_read_file(sc_card_t *card, sc_path_t *path, u8 **out, int *len)
+
+static int rutoken_cipher_gost(sc_card_t *card, 
+                struct sc_rutoken_decipherinfo *ptr, char is_enchiper)
+{
+        int ret;
+
+        if (is_enchiper)
+                ret = rutoken_cipher_p(card, ptr->inbuf, ptr->inlen, 
+                                ptr->outbuf, ptr->outlen, 0x86, 0x80, 0);
+        else
+                ret = rutoken_cipher_p(card, ptr->inbuf, ptr->inlen, 
+                                ptr->outbuf, ptr->outlen, 0x80, 0x86, 1);
+        if (ret > 0)
+        {
+                if ((size_t)ret == ptr->outlen)
+                        ret = SC_SUCCESS;
+                else
+                        ret = SC_ERROR_INTERNAL; /* SC_ERROR_DECRYPT_FAILED; */
+        }
+        return ret;
+
+}
+
+static int rutoken_compute_mac_gost(sc_card_t *card, 
+                        const u8 *in, size_t ilen, 
+                        u8 *out, size_t olen)
+{
+        const size_t signing_chunk = 248;
+        size_t len;
+        int ret;
+        sc_apdu_t apdu;
+
+        SC_FUNC_CALLED(card->ctx, 1);
+
+        if (!in || !out || olen != 4 || ilen == 0)
+                return SC_ERROR_INVALID_ARGUMENTS;
+        do
+        {
+                sc_format_apdu(card, &apdu,
+                                ilen > signing_chunk ?
+                                SC_APDU_CASE_3_SHORT : SC_APDU_CASE_4_SHORT,
+                                0x2A, 0x90, 0x80);
+                len = (ilen > signing_chunk) ? signing_chunk : ilen;
+                apdu.lc = len;
+                apdu.datalen = len;
+                apdu.data = in;
+                in += len;
+                ilen -= len;
+                if (ilen == 0)
+        {
+                        apdu.cla = 0x00;
+                        apdu.le = olen;
+                        apdu.resplen = olen;
+                        apdu.resp = out;
+        }
+        else
+                        apdu.cla = 0x10;
+                if (sc_transmit_apdu(card, &apdu) >= 0)
+                        ret = rutoken_check_sw(card, apdu.sw1, apdu.sw2);
+                else
+                        ret = SC_ERROR_CARD_CMD_FAILED;
+        } while (ret == SC_NO_ERROR  &&  ilen != 0);
+        
+        SC_FUNC_RETURN(card->ctx, 1, ret);
+}
+        
+/*  RSA emulation  */
+
+#ifdef HAVE_OPENSSL
+
+static int rutoken_get_current_fileid(sc_card_t *card, u8 id[2])
+{
+        sc_apdu_t apdu;
+        int ret = SC_ERROR_CARD_CMD_FAILED;
+
+        sc_format_apdu(card, &apdu, SC_APDU_CASE_2_SHORT, 0xca, 0x01, 0x11);
+        apdu.resp = id;
+        apdu.resplen = sizeof(id);
+        apdu.le = 2;
+        if(sc_transmit_apdu(card, &apdu) >= 0)
+                ret = rutoken_check_sw(card, apdu.sw1, apdu.sw2);
+        SC_FUNC_RETURN(card->ctx, 1, ret);
+}</