diff --git a/src/pkcs11/README b/src/pkcs11/README new file mode 100644 index 00000000..fa9b44e1 --- /dev/null +++ b/src/pkcs11/README @@ -0,0 +1,38 @@ +Installation +------------ + +Netscape: + Select menu: Communicator -> Tools -> Security Info + + Select Cryptographic Modules + + Click: Add + + Module name: descriptive name about module (eg. sc-pkcs11) + Module file: absolute path of libsc-pkcs11.so + + +Mozilla: + Make sure Personal Security Manager (PSM) is installed + (eg. mozilla-psm package is installed). + + Select menu: Edit -> Preferences + + Select category: Privacy & Security -> Certificates + + Click: Manage Security Devices + + Click: Load + + Module name: descriptive name about module (eg. sc-pkcs11) + Module file: absolute path of libsc-pkcs11.so + + +Notes +----- + +Netscape seems to show more information about the security module +than mozilla. Otherwise all stuff is untested. + +Please note that the library currently writes debug log to +/tmp/libsc-pkcs11.log. diff --git a/src/pkcs11/digestsign.c b/src/pkcs11/digestsign.c new file mode 100644 index 00000000..04da89d6 --- /dev/null +++ b/src/pkcs11/digestsign.c @@ -0,0 +1,85 @@ +#include "sc-pkcs11.h" + +CK_RV C_DigestInit(CK_SESSION_HANDLE hSession, /* the session's handle */ + CK_MECHANISM_PTR pMechanism) /* the digesting mechanism */ +{ + return CKR_FUNCTION_NOT_SUPPORTED; +} + +CK_RV C_Digest(CK_SESSION_HANDLE hSession, /* the session's handle */ + CK_BYTE_PTR pData, /* data to be digested */ + CK_ULONG ulDataLen, /* bytes of data to be digested */ + CK_BYTE_PTR pDigest, /* receives the message digest */ + CK_ULONG_PTR pulDigestLen) /* receives byte length of digest */ +{ + return CKR_FUNCTION_NOT_SUPPORTED; +} + +CK_RV C_DigestUpdate(CK_SESSION_HANDLE hSession, /* the session's handle */ + CK_BYTE_PTR pPart, /* data to be digested */ + CK_ULONG ulPartLen) /* bytes of data to be digested */ +{ + return CKR_FUNCTION_NOT_SUPPORTED; +} + +CK_RV C_DigestKey(CK_SESSION_HANDLE hSession, /* the session's handle */ + CK_OBJECT_HANDLE hKey) /* handle of secret key to digest */ +{ + return CKR_FUNCTION_NOT_SUPPORTED; +} + +CK_RV C_DigestFinal(CK_SESSION_HANDLE hSession, /* the session's handle */ + CK_BYTE_PTR pDigest, /* receives the message digest */ + CK_ULONG_PTR pulDigestLen) /* receives byte count of digest */ +{ + return CKR_FUNCTION_NOT_SUPPORTED; +} + +CK_RV C_SignInit(CK_SESSION_HANDLE hSession, /* the session's handle */ + CK_MECHANISM_PTR pMechanism, /* the signature mechanism */ + CK_OBJECT_HANDLE hKey) /* handle of the signature key */ +{ + return CKR_FUNCTION_NOT_SUPPORTED; +} + +CK_RV C_Sign(CK_SESSION_HANDLE hSession, /* the session's handle */ + CK_BYTE_PTR pData, /* the data (digest) to be signed */ + CK_ULONG ulDataLen, /* count of bytes to be signed */ + CK_BYTE_PTR pSignature, /* receives the signature */ + CK_ULONG_PTR pulSignatureLen) /* receives byte count of signature */ +{ + return CKR_FUNCTION_NOT_SUPPORTED; +} + +CK_RV C_SignUpdate(CK_SESSION_HANDLE hSession, /* the session's handle */ + CK_BYTE_PTR pPart, /* the data (digest) to be signed */ + CK_ULONG ulPartLen) /* count of bytes to be signed */ +{ + return CKR_FUNCTION_NOT_SUPPORTED; +} + +CK_RV C_SignFinal(CK_SESSION_HANDLE hSession, /* the session's handle */ + CK_BYTE_PTR pSignature, /* receives the signature */ + CK_ULONG_PTR pulSignatureLen) /* receives byte count of signature */ +{ + return CKR_FUNCTION_NOT_SUPPORTED; +} + +CK_RV C_SignRecoverInit(CK_SESSION_HANDLE hSession, /* the session's handle */ + CK_MECHANISM_PTR pMechanism, /* the signature mechanism */ + CK_OBJECT_HANDLE hKey) /* handle of the signature key */ +{ + return CKR_FUNCTION_NOT_SUPPORTED; +} + +CK_RV C_SignRecover(CK_SESSION_HANDLE hSession, /* the session's handle */ + CK_BYTE_PTR pData, /* the data (digest) to be signed */ + CK_ULONG ulDataLen, /* count of bytes to be signed */ + CK_BYTE_PTR pSignature, /* receives the signature */ + CK_ULONG_PTR pulSignatureLen) /* receives byte count of signature */ +{ + return CKR_FUNCTION_NOT_SUPPORTED; +} + + + diff --git a/src/pkcs11/endecrypt.c b/src/pkcs11/endecrypt.c new file mode 100644 index 00000000..1ff0c6bb --- /dev/null +++ b/src/pkcs11/endecrypt.c @@ -0,0 +1,68 @@ +#include "sc-pkcs11.h" + +CK_RV C_EncryptInit(CK_SESSION_HANDLE hSession, /* the session's handle */ + CK_MECHANISM_PTR pMechanism, /* the encryption mechanism */ + CK_OBJECT_HANDLE hKey) /* handle of encryption key */ +{ + return CKR_FUNCTION_NOT_SUPPORTED; +} + +CK_RV C_Encrypt(CK_SESSION_HANDLE hSession, /* the session's handle */ + CK_BYTE_PTR pData, /* the plaintext data */ + CK_ULONG ulDataLen, /* bytes of plaintext data */ + CK_BYTE_PTR pEncryptedData, /* receives encrypted data */ + CK_ULONG_PTR pulEncryptedDataLen) /* receives encrypted byte count */ +{ + return CKR_FUNCTION_NOT_SUPPORTED; +} + +CK_RV C_EncryptUpdate(CK_SESSION_HANDLE hSession, /* the session's handle */ + CK_BYTE_PTR pPart, /* the plaintext data */ + CK_ULONG ulPartLen, /* bytes of plaintext data */ + CK_BYTE_PTR pEncryptedPart, /* receives encrypted data */ + CK_ULONG_PTR pulEncryptedPartLen)/* receives encrypted byte count */ +{ + return CKR_FUNCTION_NOT_SUPPORTED; +} + +CK_RV C_EncryptFinal(CK_SESSION_HANDLE hSession, /* the session's handle */ + CK_BYTE_PTR pLastEncryptedPart, /* receives encrypted last part */ + CK_ULONG_PTR pulLastEncryptedPartLen) /* receives byte count */ +{ + return CKR_FUNCTION_NOT_SUPPORTED; +} + + +CK_RV C_DecryptInit(CK_SESSION_HANDLE hSession, /* the session's handle */ + CK_MECHANISM_PTR pMechanism, /* the decryption mechanism */ + CK_OBJECT_HANDLE hKey) /* handle of the decryption key */ +{ + return CKR_FUNCTION_NOT_SUPPORTED; +} + +CK_RV C_Decrypt(CK_SESSION_HANDLE hSession, /* the session's handle */ + CK_BYTE_PTR pEncryptedData, /* input encrypted data */ + CK_ULONG ulEncryptedDataLen, /* count of bytes of input */ + CK_BYTE_PTR pData, /* receives decrypted output */ + CK_ULONG_PTR pulDataLen) /* receives decrypted byte count */ +{ + return CKR_FUNCTION_NOT_SUPPORTED; +} + +CK_RV C_DecryptUpdate(CK_SESSION_HANDLE hSession, /* the session's handle */ + CK_BYTE_PTR pEncryptedPart, /* input encrypted data */ + CK_ULONG ulEncryptedPartLen, /* count of bytes of input */ + CK_BYTE_PTR pPart, /* receives decrypted output */ + CK_ULONG_PTR pulPartLen) /* receives decrypted byte count */ +{ + return CKR_FUNCTION_NOT_SUPPORTED; +} + +CK_RV C_DecryptFinal(CK_SESSION_HANDLE hSession, /* the session's handle */ + CK_BYTE_PTR pLastPart, /* receives decrypted output */ + CK_ULONG_PTR pulLastPartLen) /* receives decrypted byte count */ +{ + return CKR_FUNCTION_NOT_SUPPORTED; +} + + diff --git a/src/pkcs11/function_table.c b/src/pkcs11/function_table.c new file mode 100644 index 00000000..a54ee79f --- /dev/null +++ b/src/pkcs11/function_table.c @@ -0,0 +1,81 @@ +#include "sc-pkcs11.h" + +CK_FUNCTION_LIST function_list = { + { 2, 10 }, + // generic.c + C_Initialize, + C_Finalize, + C_GetInfo, + C_GetFunctionList, + C_GetSlotList, + C_GetSlotInfo, + C_GetTokenInfo, + C_GetMechanismList, + C_GetMechanismInfo, + C_InitToken, + C_InitPIN, + C_SetPIN, + // session.c + C_OpenSession, + C_CloseSession, + C_CloseAllSessions, + C_GetSessionInfo, + C_GetOperationState, + C_SetOperationState, + C_Login, + C_Logout, + // object.c + C_CreateObject, + C_CopyObject, + C_DestroyObject, + C_GetObjectSize, + C_GetAttributeValue, + C_SetAttributeValue, + C_FindObjectsInit, + C_FindObjects, + C_FindObjectsFinal, + // endecypt.c + C_EncryptInit, + C_Encrypt, + C_EncryptUpdate, + C_EncryptFinal, + C_DecryptInit, + C_Decrypt, + C_DecryptUpdate, + C_DecryptFinal, + // digestsign.c + C_DigestInit, + C_Digest, + C_DigestUpdate, + C_DigestKey, + C_DigestFinal, + C_SignInit, + C_Sign, + C_SignUpdate, + C_SignFinal, + C_SignRecoverInit, + C_SignRecover, + // verify.c + C_VerifyInit, + C_Verify, + C_VerifyUpdate, + C_VerifyFinal, + C_VerifyRecoverInit, + C_VerifyRecover, + // misc.c + C_DigestEncryptUpdate, + C_DecryptDigestUpdate, + C_SignEncryptUpdate, + C_DecryptVerifyUpdate, + C_GenerateKey, + C_GenerateKeyPair, + C_WrapKey, + C_UnwrapKey, + C_DeriveKey, + C_SeedRandom, + C_GenerateRandom, + C_GetFunctionStatus, + C_CancelFunction +}; + + diff --git a/src/pkcs11/generic.c b/src/pkcs11/generic.c new file mode 100644 index 00000000..ed611059 --- /dev/null +++ b/src/pkcs11/generic.c @@ -0,0 +1,179 @@ +#include +#include +#include + +#include + +#include "sc-pkcs11.h" + +SCARDCONTEXT sc_ctx; +int sc_num_readers; +char *sc_reader_name[16]; + +void LOG(char *format, ...) +{ + va_list valist; + FILE *out; + + out = fopen("/tmp/libsc-pkcs11.log", "a"); + if (out != NULL) { + va_start(valist, format); + vfprintf(out, format, valist); + va_end(valist); + fclose(out); + } +} + +CK_RV C_Initialize(CK_VOID_PTR pReserved) +{ + int reader_count, reader_buf_size, rv; + char *reader_buf, *p; + + LOG("C_Initialize(0x%x)\n", pReserved); + + rv = SCardEstablishContext(SCARD_SCOPE_SYSTEM, NULL, NULL, &sc_ctx); + if (rv != SCARD_S_SUCCESS) { + LOG("ERROR: Unable to connect to Resource Manager\n"); + return CKR_DEVICE_ERROR; + } + + // Fetch the list of readers + SCardListReaders(sc_ctx, NULL, NULL, (LPDWORD) &reader_buf_size); + reader_buf = (char*) malloc(reader_buf_size); + SCardListReaders(sc_ctx, NULL, reader_buf, (LPDWORD) &reader_buf_size); + p = reader_buf; + sc_num_readers = reader_count = 0; + do { + sc_reader_name[sc_num_readers++] = strdup(p); + while (*p++ != 0); + p++; + } while (p < reader_buf + reader_buf_size); + free(reader_buf); + + return CKR_OK; +} + +CK_RV C_Finalize(CK_VOID_PTR pReserved) +{ + int i; + + LOG("C_Finalize(0x%x)\n", pReserved); + + for (i = 0; i < sc_num_readers; i++) + free(sc_reader_name[i]); + + SCardReleaseContext(sc_ctx); + + return CKR_OK; +} + +CK_RV C_GetInfo(CK_INFO_PTR pInfo) +{ + LOG("C_GetInfo(0x%x)\n", pInfo); + memset(pInfo, 0, sizeof(CK_INFO)); + pInfo->cryptokiVersion.major = 2; + pInfo->cryptokiVersion.minor = 10; + strcpy(pInfo->manufacturerID, "Timo Teras & Juha Yrjola"); + strcpy(pInfo->libraryDescription, "PCSC PKCS#15 SmartCard reader"); + pInfo->libraryVersion.major = 0; + pInfo->libraryVersion.minor = 1; + return CKR_OK; +} + +CK_RV C_GetFunctionList(CK_FUNCTION_LIST_PTR_PTR ppFunctionList) +{ + LOG("C_GetFunctionList(0x%x)\n", ppFunctionList); + *ppFunctionList = &function_list; + return CKR_OK; +} + +CK_RV C_GetSlotList(CK_BBOOL tokenPresent, /* only slots with token present */ + CK_SLOT_ID_PTR pSlotList, /* receives the array of slot IDs */ + CK_ULONG_PTR pulCount) /* receives the number of slots */ +{ + int i, num; + + LOG("C_GetSlotList(%d, 0x%x, 0x%x)\n", tokenPresent, pSlotList, pulCount); + + if (pSlotList == NULL_PTR) { + *pulCount = sc_num_readers; + return CKR_OK; + } + + num = sc_num_readers > *pulCount ? *pulCount : sc_num_readers; + for (i = 0; i < num; i++) + pSlotList[i] = i; + *pulCount = num; + + return CKR_OK; +} + +CK_RV C_GetSlotInfo(CK_SLOT_ID slotID, CK_SLOT_INFO_PTR pInfo) +{ + LOG("C_GetSlotInfo(%d, 0x%x)\n", slotID, pInfo); + + if (slotID < 0 || slotID >= sc_num_readers) + return CKR_SLOT_ID_INVALID; + + memset(pInfo, 0, sizeof(CK_SLOT_INFO)); + strncpy(pInfo->slotDescription, sc_reader_name[slotID], + sizeof(pInfo->slotDescription)); + strcpy(pInfo->manufacturerID, "PCSC interface"); + pInfo->flags = CKF_REMOVABLE_DEVICE | CKF_HW_SLOT; + pInfo->hardwareVersion.major = 1; + pInfo->firmwareVersion.major = 1; + + return CKR_OK; +} + +CK_RV C_GetTokenInfo(CK_SLOT_ID slotID, CK_TOKEN_INFO_PTR pInfo) +{ + LOG("C_GetTokenInfo(%d, 0x%x)\n", slotID, pInfo); + return CKR_FUNCTION_NOT_SUPPORTED; +} + +CK_RV C_GetMechanismList(CK_SLOT_ID slotID, + CK_MECHANISM_TYPE_PTR pMechanismList, + CK_ULONG_PTR pulCount) +{ + LOG("C_GetMechanismList(%d, 0x%x, 0x%x)\n", slotID, pMechanismList, pulCount); + return CKR_FUNCTION_NOT_SUPPORTED; +} + +CK_RV C_GetMechanismInfo(CK_SLOT_ID slotID, + CK_MECHANISM_TYPE type, + CK_MECHANISM_INFO_PTR pInfo) +{ + LOG("C_GetMechanismInfo(%d, %d, 0x%x)\n", slotID, type, pInfo); + return CKR_FUNCTION_NOT_SUPPORTED; +} + +CK_RV C_InitToken(CK_SLOT_ID slotID, + CK_CHAR_PTR pPin, + CK_ULONG ulPinLen, + CK_CHAR_PTR pLabel) +{ + LOG("C_InitToken(%d, '%s', %d, '%s')\n", slotID, pPin, ulPinLen, pLabel); + return CKR_FUNCTION_NOT_SUPPORTED; +} + +CK_RV C_InitPIN(CK_SESSION_HANDLE hSession, + CK_CHAR_PTR pPin, + CK_ULONG ulPinLen) +{ + LOG("C_InitPIN(%d, '%s', %d)\n", hSession, pPin, ulPinLen); + return CKR_FUNCTION_NOT_SUPPORTED; +} + +CK_RV C_SetPIN(CK_SESSION_HANDLE hSession, + CK_CHAR_PTR pOldPin, + CK_ULONG ulOldLen, + CK_CHAR_PTR pNewPin, + CK_ULONG ulNewLen) +{ + LOG("C_SetPIN(%d, '%s', %d, '%s', %d)\n", hSession, pOldPin, ulOldLen, pNewPin, ulNewLen); + return CKR_FUNCTION_NOT_SUPPORTED; +} + + + diff --git a/src/pkcs11/misc.c b/src/pkcs11/misc.c new file mode 100644 index 00000000..efaea97b --- /dev/null +++ b/src/pkcs11/misc.c @@ -0,0 +1,116 @@ +#include "sc-pkcs11.h" + +CK_RV C_DigestEncryptUpdate(CK_SESSION_HANDLE hSession, /* the session's handle */ + CK_BYTE_PTR pPart, /* the plaintext data */ + CK_ULONG ulPartLen, /* bytes of plaintext data */ + CK_BYTE_PTR pEncryptedPart, /* receives encrypted data */ + CK_ULONG_PTR pulEncryptedPartLen) /* receives encrypted byte count */ +{ + return CKR_FUNCTION_NOT_SUPPORTED; +} + +CK_RV C_DecryptDigestUpdate(CK_SESSION_HANDLE hSession, /* the session's handle */ + CK_BYTE_PTR pEncryptedPart, /* input encrypted data */ + CK_ULONG ulEncryptedPartLen, /* count of bytes of input */ + CK_BYTE_PTR pPart, /* receives decrypted output */ + CK_ULONG_PTR pulPartLen) /* receives decrypted byte count */ +{ + return CKR_FUNCTION_NOT_SUPPORTED; +} + +CK_RV C_SignEncryptUpdate(CK_SESSION_HANDLE hSession, /* the session's handle */ + CK_BYTE_PTR pPart, /* the plaintext data */ + CK_ULONG ulPartLen, /* bytes of plaintext data */ + CK_BYTE_PTR pEncryptedPart, /* receives encrypted data */ + CK_ULONG_PTR pulEncryptedPartLen) /* receives encrypted byte count */ +{ + return CKR_FUNCTION_NOT_SUPPORTED; +} + +CK_RV C_DecryptVerifyUpdate(CK_SESSION_HANDLE hSession, /* the session's handle */ + CK_BYTE_PTR pEncryptedPart, /* input encrypted data */ + CK_ULONG ulEncryptedPartLen, /* count of byes of input */ + CK_BYTE_PTR pPart, /* receives decrypted output */ + CK_ULONG_PTR pulPartLen) /* receives decrypted byte count */ +{ + return CKR_FUNCTION_NOT_SUPPORTED; +} + +CK_RV C_GenerateKey(CK_SESSION_HANDLE hSession, /* the session's handle */ + CK_MECHANISM_PTR pMechanism, /* the key generation mechanism */ + CK_ATTRIBUTE_PTR pTemplate, /* template for the new key */ + CK_ULONG ulCount, /* number of attributes in template */ + CK_OBJECT_HANDLE_PTR phKey) /* receives handle of new key */ +{ + return CKR_FUNCTION_NOT_SUPPORTED; +} + +CK_RV C_GenerateKeyPair(CK_SESSION_HANDLE hSession, /* the session's handle */ + CK_MECHANISM_PTR pMechanism, /* the key gen. mech. */ + CK_ATTRIBUTE_PTR pPublicKeyTemplate, /* pub. attr. template */ + CK_ULONG ulPublicKeyAttributeCount, /* # of pub. attrs. */ + CK_ATTRIBUTE_PTR pPrivateKeyTemplate, /* priv. attr. template */ + CK_ULONG ulPrivateKeyAttributeCount, /* # of priv. attrs. */ + CK_OBJECT_HANDLE_PTR phPublicKey, /* gets pub. key handle */ + CK_OBJECT_HANDLE_PTR phPrivateKey) /* gets priv. key handle */ +{ + return CKR_FUNCTION_NOT_SUPPORTED; +} + +CK_RV C_WrapKey(CK_SESSION_HANDLE hSession, /* the session's handle */ + CK_MECHANISM_PTR pMechanism, /* the wrapping mechanism */ + CK_OBJECT_HANDLE hWrappingKey, /* handle of the wrapping key */ + CK_OBJECT_HANDLE hKey, /* handle of the key to be wrapped */ + CK_BYTE_PTR pWrappedKey, /* receives the wrapped key */ + CK_ULONG_PTR pulWrappedKeyLen)/* receives byte size of wrapped key */ +{ + return CKR_FUNCTION_NOT_SUPPORTED; +} + +CK_RV C_UnwrapKey(CK_SESSION_HANDLE hSession, /* the session's handle */ + CK_MECHANISM_PTR pMechanism, /* the unwrapping mechanism */ + CK_OBJECT_HANDLE hUnwrappingKey, /* handle of the unwrapping key */ + CK_BYTE_PTR pWrappedKey, /* the wrapped key */ + CK_ULONG ulWrappedKeyLen, /* bytes length of wrapped key */ + CK_ATTRIBUTE_PTR pTemplate, /* template for the new key */ + CK_ULONG ulAttributeCount, /* # of attributes in template */ + CK_OBJECT_HANDLE_PTR phKey) /* gets handle of recovered key */ +{ + return CKR_FUNCTION_NOT_SUPPORTED; +} + +CK_RV C_DeriveKey(CK_SESSION_HANDLE hSession, /* the session's handle */ + CK_MECHANISM_PTR pMechanism, /* the key derivation mechanism */ + CK_OBJECT_HANDLE hBaseKey, /* handle of the base key */ + CK_ATTRIBUTE_PTR pTemplate, /* template for the new key */ + CK_ULONG ulAttributeCount, /* # of attributes in template */ + CK_OBJECT_HANDLE_PTR phKey) /* gets handle of derived key */ +{ + return CKR_FUNCTION_NOT_SUPPORTED; +} + +CK_RV C_SeedRandom(CK_SESSION_HANDLE hSession, /* the session's handle */ + CK_BYTE_PTR pSeed, /* the seed material */ + CK_ULONG ulSeedLen) /* count of bytes of seed material */ +{ + return CKR_FUNCTION_NOT_SUPPORTED; +} + +CK_RV C_GenerateRandom(CK_SESSION_HANDLE hSession, /* the session's handle */ + CK_BYTE_PTR RandomData, /* receives the random data */ + CK_ULONG ulRandomLen) /* number of bytes to be generated */ +{ + return CKR_FUNCTION_NOT_SUPPORTED; +} + +CK_RV C_GetFunctionStatus(CK_SESSION_HANDLE hSession) /* the session's handle */ +{ + return CKR_FUNCTION_NOT_SUPPORTED; +} + +CK_RV C_CancelFunction(CK_SESSION_HANDLE hSession) /* the session's handle */ +{ + return CKR_FUNCTION_NOT_SUPPORTED; +} + + diff --git a/src/pkcs11/object.c b/src/pkcs11/object.c new file mode 100644 index 00000000..1d228dc5 --- /dev/null +++ b/src/pkcs11/object.c @@ -0,0 +1,69 @@ +#include "sc-pkcs11.h" + +CK_RV C_CreateObject(CK_SESSION_HANDLE hSession, /* the session's handle */ + CK_ATTRIBUTE_PTR pTemplate, /* the object's template */ + CK_ULONG ulCount, /* attributes in template */ + CK_OBJECT_HANDLE_PTR phObject) /* receives new object's handle. */ +{ + return CKR_FUNCTION_NOT_SUPPORTED; +} + +CK_RV C_CopyObject(CK_SESSION_HANDLE hSession, /* the session's handle */ + CK_OBJECT_HANDLE hObject, /* the object's handle */ + CK_ATTRIBUTE_PTR pTemplate, /* template for new object */ + CK_ULONG ulCount, /* attributes in template */ + CK_OBJECT_HANDLE_PTR phNewObject) /* receives handle of copy */ +{ + return CKR_FUNCTION_NOT_SUPPORTED; +} + +CK_RV C_DestroyObject(CK_SESSION_HANDLE hSession, /* the session's handle */ + CK_OBJECT_HANDLE hObject) /* the object's handle */ +{ + return CKR_FUNCTION_NOT_SUPPORTED; +} + +CK_RV C_GetObjectSize(CK_SESSION_HANDLE hSession, /* the session's handle */ + CK_OBJECT_HANDLE hObject, /* the object's handle */ + CK_ULONG_PTR pulSize) /* receives size of object */ +{ + return CKR_FUNCTION_NOT_SUPPORTED; +} + +CK_RV C_GetAttributeValue(CK_SESSION_HANDLE hSession, /* the session's handle */ + CK_OBJECT_HANDLE hObject, /* the object's handle */ + CK_ATTRIBUTE_PTR pTemplate, /* specifies attributes, gets values */ + CK_ULONG ulCount) /* attributes in template */ +{ + return CKR_FUNCTION_NOT_SUPPORTED; +} + +CK_RV C_SetAttributeValue(CK_SESSION_HANDLE hSession, /* the session's handle */ + CK_OBJECT_HANDLE hObject, /* the object's handle */ + CK_ATTRIBUTE_PTR pTemplate, /* specifies attributes and values */ + CK_ULONG ulCount) /* attributes in template */ +{ + return CKR_FUNCTION_NOT_SUPPORTED; +} + +CK_RV C_FindObjectsInit(CK_SESSION_HANDLE hSession, /* the session's handle */ + CK_ATTRIBUTE_PTR pTemplate, /* attribute values to match */ + CK_ULONG ulCount) /* attributes in search template */ +{ + return CKR_FUNCTION_NOT_SUPPORTED; +} + +CK_RV C_FindObjects(CK_SESSION_HANDLE hSession, /* the session's handle */ + CK_OBJECT_HANDLE_PTR phObject, /* receives object handle array */ + CK_ULONG ulMaxObjectCount, /* max handles to be returned */ + CK_ULONG_PTR pulObjectCount) /* actual number returned */ +{ + return CKR_FUNCTION_NOT_SUPPORTED; +} + +CK_RV C_FindObjectsFinal(CK_SESSION_HANDLE hSession) /* the session's handle */ +{ + return CKR_FUNCTION_NOT_SUPPORTED; +} + + diff --git a/src/pkcs11/sc-pkcs11.h b/src/pkcs11/sc-pkcs11.h new file mode 100644 index 00000000..a1711f66 --- /dev/null +++ b/src/pkcs11/sc-pkcs11.h @@ -0,0 +1,13 @@ +#ifndef __sc_pkcs11_h__ +#define __sc_pkcs11_h__ + +#include "pkcs11/pkcs11.h" +#include + +extern CK_FUNCTION_LIST function_list; +extern void LOG(char *format, ...); + +extern SCARDCONTEXT sc_ctx; + +#endif + diff --git a/src/pkcs11/session.c b/src/pkcs11/session.c new file mode 100644 index 00000000..17e29ef3 --- /dev/null +++ b/src/pkcs11/session.c @@ -0,0 +1,58 @@ +#include "sc-pkcs11.h" + + +CK_RV C_OpenSession(CK_SLOT_ID slotID, /* the slot's ID */ + CK_FLAGS flags, /* defined in CK_SESSION_INFO */ + CK_VOID_PTR pApplication, /* pointer passed to callback */ + CK_NOTIFY Notify, /* notification callback function */ + CK_SESSION_HANDLE_PTR phSession) /* receives new session handle */ +{ + return CKR_FUNCTION_NOT_SUPPORTED; +} + +CK_RV C_CloseSession(CK_SESSION_HANDLE hSession) /* the session's handle */ +{ + return CKR_FUNCTION_NOT_SUPPORTED; +} + +CK_RV C_CloseAllSessions(CK_SLOT_ID slotID) /* the token's slot */ +{ + return CKR_FUNCTION_NOT_SUPPORTED; +} + +CK_RV C_GetSessionInfo(CK_SESSION_HANDLE hSession, /* the session's handle */ + CK_SESSION_INFO_PTR pInfo) /* receives session information */ +{ + return CKR_FUNCTION_NOT_SUPPORTED; +} + +CK_RV C_GetOperationState(CK_SESSION_HANDLE hSession, /* the session's handle */ + CK_BYTE_PTR pOperationState, /* location receiving state */ + CK_ULONG_PTR pulOperationStateLen) /* location receiving state length */ +{ + return CKR_FUNCTION_NOT_SUPPORTED; +} + +CK_RV C_SetOperationState(CK_SESSION_HANDLE hSession, /* the session's handle */ + CK_BYTE_PTR pOperationState, /* the location holding the state */ + CK_ULONG ulOperationStateLen, /* location holding state length */ + CK_OBJECT_HANDLE hEncryptionKey, /* handle of en/decryption key */ + CK_OBJECT_HANDLE hAuthenticationKey) /* handle of sign/verify key */ +{ + return CKR_FUNCTION_NOT_SUPPORTED; +} + +CK_RV C_Login(CK_SESSION_HANDLE hSession, /* the session's handle */ + CK_USER_TYPE userType, /* the user type */ + CK_CHAR_PTR pPin, /* the user's PIN */ + CK_ULONG ulPinLen) /* the length of the PIN */ +{ + return CKR_FUNCTION_NOT_SUPPORTED; +} + +CK_RV C_Logout(CK_SESSION_HANDLE hSession) /* the session's handle */ +{ + return CKR_FUNCTION_NOT_SUPPORTED; +} + + diff --git a/src/pkcs11/verify.c b/src/pkcs11/verify.c new file mode 100644 index 00000000..f73f5159 --- /dev/null +++ b/src/pkcs11/verify.c @@ -0,0 +1,49 @@ +#include "sc-pkcs11.h" + +CK_RV C_VerifyInit(CK_SESSION_HANDLE hSession, /* the session's handle */ + CK_MECHANISM_PTR pMechanism, /* the verification mechanism */ + CK_OBJECT_HANDLE hKey) /* handle of the verification key */ +{ + return CKR_FUNCTION_NOT_SUPPORTED; +} + +CK_RV C_Verify(CK_SESSION_HANDLE hSession, /* the session's handle */ + CK_BYTE_PTR pData, /* plaintext data (digest) to compare */ + CK_ULONG ulDataLen, /* length of data (digest) in bytes */ + CK_BYTE_PTR pSignature, /* the signature to be verified */ + CK_ULONG ulSignatureLen) /* count of bytes of signature */ +{ + return CKR_FUNCTION_NOT_SUPPORTED; +} + +CK_RV C_VerifyUpdate(CK_SESSION_HANDLE hSession, /* the session's handle */ + CK_BYTE_PTR pPart, /* plaintext data (digest) to compare */ + CK_ULONG ulPartLen) /* length of data (digest) in bytes */ +{ + return CKR_FUNCTION_NOT_SUPPORTED; +} + +CK_RV C_VerifyFinal(CK_SESSION_HANDLE hSession, /* the session's handle */ + CK_BYTE_PTR pSignature, /* the signature to be verified */ + CK_ULONG ulSignatureLen) /* count of bytes of signature */ +{ + return CKR_FUNCTION_NOT_SUPPORTED; +} + +CK_RV C_VerifyRecoverInit(CK_SESSION_HANDLE hSession, /* the session's handle */ + CK_MECHANISM_PTR pMechanism, /* the verification mechanism */ + CK_OBJECT_HANDLE hKey) /* handle of the verification key */ +{ + return CKR_FUNCTION_NOT_SUPPORTED; +} + +CK_RV C_VerifyRecover(CK_SESSION_HANDLE hSession, /* the session's handle */ + CK_BYTE_PTR pSignature, /* the signature to be verified */ + CK_ULONG ulSignatureLen, /* count of bytes of signature */ + CK_BYTE_PTR pData, /* receives decrypted data (digest) */ + CK_ULONG_PTR pulDataLen) /* receives byte count of data */ +{ + return CKR_FUNCTION_NOT_SUPPORTED; +} + +