mirror of
https://github.com/guanzhi/GmSSL.git
synced 2026-08-08 06:03:47 +08:00
first step of v2 final release
This commit is contained in:
Zhi Guan
@@ -1,2 +1,2 @@
|
||||
LIBS=../../libcrypto
|
||||
SOURCE[../../libcrypto]=skf_err.c skf_lib.c skf_meth.c
|
||||
SOURCE[../../libcrypto]=skf_err.c skf_lib.c skf_meth.c skf_ext.c skf_wisec.c
|
||||
|
||||
@@ -1,972 +0,0 @@
|
||||
/* ====================================================================
|
||||
* Copyright (c) 2014 - 2017 The GmSSL Project. All rights reserved.
|
||||
*
|
||||
* Redistribution and use in source and binary forms, with or without
|
||||
* modification, are permitted provided that the following conditions
|
||||
* are met:
|
||||
*
|
||||
* 1. Redistributions of source code must retain the above copyright
|
||||
* notice, this list of conditions and the following disclaimer.
|
||||
*
|
||||
* 2. Redistributions in binary form must reproduce the above copyright
|
||||
* notice, this list of conditions and the following disclaimer in
|
||||
* the documentation and/or other materials provided with the
|
||||
* distribution.
|
||||
*
|
||||
* 3. All advertising materials mentioning features or use of this
|
||||
* software must display the following acknowledgment:
|
||||
* "This product includes software developed by the GmSSL Project.
|
||||
* (http://gmssl.org/)"
|
||||
*
|
||||
* 4. The name "GmSSL Project" must not be used to endorse or promote
|
||||
* products derived from this software without prior written
|
||||
* permission. For written permission, please contact
|
||||
* guanzhi1980@gmail.com.
|
||||
*
|
||||
* 5. Products derived from this software may not be called "GmSSL"
|
||||
* nor may "GmSSL" appear in their names without prior written
|
||||
* permission of the GmSSL Project.
|
||||
*
|
||||
* 6. Redistributions of any form whatsoever must retain the following
|
||||
* acknowledgment:
|
||||
* "This product includes software developed by the GmSSL Project
|
||||
* (http://gmssl.org/)"
|
||||
*
|
||||
* THIS SOFTWARE IS PROVIDED BY THE GmSSL PROJECT ``AS IS'' AND ANY
|
||||
* EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
|
||||
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
|
||||
* PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE GmSSL PROJECT OR
|
||||
* ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
|
||||
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
|
||||
* NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
|
||||
* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
|
||||
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
|
||||
* STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
|
||||
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
|
||||
* OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
* ====================================================================
|
||||
*/
|
||||
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
#include <openssl/skf.h>
|
||||
|
||||
static char *hDeviceHandle = "hDeviceHandle";
|
||||
static char *hApplication = "hApplication";
|
||||
static char *hContainer = "hContainer";
|
||||
static char *hAgreementHandle = "AgreementHandle";
|
||||
static char *hKeyHandle = "KeyHandle";
|
||||
static char *hHashHandle = "HashHandle";
|
||||
static char *hMacHandle = "MacHandle";
|
||||
|
||||
ULONG DEVAPI SKF_WaitForDevEvent(
|
||||
LPSTR szDevName,
|
||||
ULONG *pulDevNameLen,
|
||||
ULONG *pulEvent)
|
||||
{
|
||||
return SAR_OK;
|
||||
}
|
||||
|
||||
ULONG DEVAPI SKF_CancelWaitForDevEvent(
|
||||
void)
|
||||
{
|
||||
return SAR_OK;
|
||||
}
|
||||
|
||||
ULONG DEVAPI SKF_EnumDev(BOOL bPresent,
|
||||
LPSTR szNameList,
|
||||
ULONG *pulSize)
|
||||
{
|
||||
char *dev_list = "dev1\0dev2\0";
|
||||
if (!szNameList || !pulSize) {
|
||||
return SAR_INVALIDPARAMERR;
|
||||
}
|
||||
strcpy((char *)szNameList, dev_list);
|
||||
*pulSize = sizeof(dev_list);
|
||||
return SAR_OK;
|
||||
}
|
||||
|
||||
ULONG DEVAPI SKF_ConnectDev(
|
||||
LPSTR szName,
|
||||
DEVHANDLE *phDev)
|
||||
{
|
||||
if (!phDev) {
|
||||
return SAR_INVALIDPARAMERR;
|
||||
}
|
||||
*phDev = hDeviceHandle;
|
||||
return SAR_OK;
|
||||
}
|
||||
|
||||
ULONG DEVAPI SKF_DisConnectDev(
|
||||
DEVHANDLE hDev)
|
||||
{
|
||||
return SAR_OK;
|
||||
}
|
||||
|
||||
ULONG DEVAPI SKF_GetDevState(
|
||||
LPSTR szDevName,
|
||||
ULONG *pulDevState)
|
||||
{
|
||||
*pulDevState = 0;
|
||||
return SAR_OK;
|
||||
}
|
||||
|
||||
ULONG DEVAPI SKF_SetLabel(
|
||||
DEVHANDLE hDev,
|
||||
LPSTR szLabel)
|
||||
{
|
||||
return SAR_OK;
|
||||
}
|
||||
|
||||
ULONG DEVAPI SKF_GetDevInfo(
|
||||
DEVHANDLE hDev,
|
||||
DEVINFO *pDevInfo)
|
||||
{
|
||||
return SAR_OK;
|
||||
}
|
||||
|
||||
ULONG DEVAPI SKF_GetDevInfo(DEVHANDLE hDev,
|
||||
DEVINFO *pDevInfo)
|
||||
{
|
||||
DEVINFO devInfo;
|
||||
|
||||
if (!pDevInfo) {
|
||||
SKFerr(SKF_F_SKF_GETDEVINFO, SKF_R_NULL_ARGUMENT);
|
||||
return SAR_INVALIDPARAMERR;
|
||||
}
|
||||
|
||||
memset(&devInfo, 0, sizeof(devInfo));
|
||||
devInfo.Version.major = 1;
|
||||
devInfo.Version.minor = 0;
|
||||
strcpy((char *)&devInfo.Manufacturer, "GmSSL Project (http://gmssl.org)");
|
||||
strcpy((char *)&devInfo.Issuer, "GmSSL Project (http://gmssl.org)");
|
||||
strcpy((char *)&devInfo.Label, "SKF Softotken");
|
||||
strcpy((char *)&devInfo.SerialNumber, "1");
|
||||
devInfo.HWVersion.major = 1;
|
||||
devInfo.HWVersion.minor = 0;
|
||||
devInfo.FirmwareVersion.major = 1;
|
||||
devInfo.FirmwareVersion.minor = 0;
|
||||
devInfo.AlgSymCap = 0x0000041F;
|
||||
devInfo.AlgAsymCap = 0x00030700;
|
||||
devInfo.AlgHashCap = 0x00000007;
|
||||
devInfo.DevAuthAlgId = SGD_SM4_CBC;
|
||||
devInfo.TotalSpace = 0;
|
||||
devInfo.FreeSpace = 0;
|
||||
devInfo.MaxECCBufferSize = 0; /* FIXME: max inlen of ECC encrypt */
|
||||
devInfo.MaxBufferSize = 0; /* FIXME: max inlen of SM4 encrypt */
|
||||
|
||||
memcpy(pDevInfo, &devInfo, sizeof(DEVINFO));
|
||||
return SAR_OK;
|
||||
}
|
||||
|
||||
ULONG DEVAPI SKF_LockDev(
|
||||
DEVHANDLE hDev,
|
||||
ULONG ulTimeOut)
|
||||
{
|
||||
return SAR_OK;
|
||||
}
|
||||
|
||||
ULONG DEVAPI SKF_UnlockDev(
|
||||
DEVHANDLE hDev)
|
||||
{
|
||||
return SAR_OK;
|
||||
}
|
||||
|
||||
ULONG DEVAPI SKF_Transmit(
|
||||
DEVHANDLE hDev,
|
||||
BYTE *pbCommand,
|
||||
ULONG ulCommandLen,
|
||||
BYTE *pbData,
|
||||
ULONG *pulDataLen)
|
||||
{
|
||||
if (!pbData || !pulDataLen) {
|
||||
return SAR_INVALIDPARAMERR;
|
||||
}
|
||||
memcpy(pbData, pbCommand, ulCommandLen);
|
||||
*pulDataLen = ulCommandLen;
|
||||
return SAR_OK;
|
||||
}
|
||||
|
||||
ULONG DEVAPI SKF_ChangeDevAuthKey(
|
||||
DEVHANDLE hDev,
|
||||
BYTE *pbKeyValue,
|
||||
ULONG ulKeyLen)
|
||||
{
|
||||
return SAR_OK;
|
||||
}
|
||||
|
||||
ULONG DEVAPI SKF_DevAuth(
|
||||
DEVHANDLE hDev,
|
||||
BYTE *pbAuthData,
|
||||
ULONG ulLen)
|
||||
{
|
||||
return SAR_OK;
|
||||
}
|
||||
|
||||
ULONG DEVAPI SKF_ChangePIN(
|
||||
HAPPLICATION hApplication,
|
||||
ULONG ulPINType,
|
||||
LPSTR szOldPin,
|
||||
LPSTR szNewPin,
|
||||
ULONG *pulRetryCount)
|
||||
{
|
||||
if (!pulRetryCount) {
|
||||
return SAR_INVALIDPARAMERR;
|
||||
}
|
||||
*pulRetryCount = 100;
|
||||
return SAR_OK;
|
||||
}
|
||||
|
||||
LONG DEVAPI SKF_GetPINInfo(
|
||||
HAPPLICATION hApplication,
|
||||
ULONG ulPINType,
|
||||
ULONG *pulMaxRetryCount,
|
||||
ULONG *pulRemainRetryCount,
|
||||
BOOL *pbDefaultPin)
|
||||
{
|
||||
if (!pulMaxRetryCount || !pulRemainRetryCount || !pbDefaultPin) {
|
||||
return SAR_INVALIDPARAMERR;
|
||||
}
|
||||
*pulMaxRetryCount = 100;
|
||||
*pulRemainRetryCount = 100;
|
||||
*pbDefaultPin = 0;
|
||||
return SAR_OK;
|
||||
}
|
||||
|
||||
ULONG DEVAPI SKF_VerifyPIN(
|
||||
HAPPLICATION hApplication,
|
||||
ULONG ulPINType,
|
||||
LPSTR szPIN,
|
||||
ULONG *pulRetryCount)
|
||||
{
|
||||
if (!pulRetryCount) {
|
||||
return SAR_INVALIDPARAMERR;
|
||||
}
|
||||
*pulRetryCount = 100;
|
||||
return SAR_OK;
|
||||
}
|
||||
|
||||
ULONG DEVAPI SKF_UnblockPIN(
|
||||
HAPPLICATION hApplication,
|
||||
LPSTR szAdminPIN,
|
||||
LPSTR szNewUserPIN,
|
||||
ULONG *pulRetryCount)
|
||||
{
|
||||
if (!pulRetryCount) {
|
||||
return SAR_INVALIDPARAMERR;
|
||||
}
|
||||
*pulRetryCount = 100;
|
||||
return SAR_OK;
|
||||
}
|
||||
|
||||
ULONG DEVAPI SKF_ClearSecureState(
|
||||
HAPPLICATION hApplication)
|
||||
{
|
||||
return SAR_OK;
|
||||
}
|
||||
|
||||
ULONG DEVAPI SKF_CreateApplication(
|
||||
DEVHANDLE hDev,
|
||||
LPSTR szAppName,
|
||||
LPSTR szAdminPin,
|
||||
DWORD dwAdminPinRetryCount,
|
||||
LPSTR szUserPin,
|
||||
DWORD dwUserPinRetryCount,
|
||||
DWORD dwCreateFileRights,
|
||||
HAPPLICATION *phApplication)
|
||||
{
|
||||
if (!phApplication) {
|
||||
return SAR_INVALIDPARAMERR;
|
||||
}
|
||||
*phApplication = hApplication;
|
||||
return SAR_OK;
|
||||
}
|
||||
|
||||
ULONG DEVAPI SKF_EnumApplication(DEVHANDLE hDev,
|
||||
LPSTR szAppName,
|
||||
ULONG *pulSize)
|
||||
{
|
||||
char *app_list = "app1\0app2\0";
|
||||
if (!szAppName || !pulSize) {
|
||||
return SAR_INVALIDPARAMERR;
|
||||
}
|
||||
strcpy((char *)szAppName, app_list);
|
||||
*pulSize = strlen(app_list);
|
||||
return SAR_OK;
|
||||
}
|
||||
|
||||
ULONG DEVAPI SKF_DeleteApplication(
|
||||
DEVHANDLE hDev,
|
||||
LPSTR szAppName)
|
||||
{
|
||||
return SAR_OK;
|
||||
}
|
||||
|
||||
ULONG DEVAPI SKF_OpenApplication(
|
||||
DEVHANDLE hDev,
|
||||
LPSTR szAppName,
|
||||
HAPPLICATION *phApplication)
|
||||
{
|
||||
if (!phApplication) {
|
||||
return SAR_INVALIDPARAMERR;
|
||||
}
|
||||
*phApplication = hApplication;
|
||||
return SAR_OK;
|
||||
}
|
||||
|
||||
ULONG DEVAPI SKF_CloseApplication(
|
||||
HAPPLICATION hApplication)
|
||||
{
|
||||
return SAR_OK;
|
||||
}
|
||||
|
||||
ULONG DEVAPI SKF_CreateFile(
|
||||
HAPPLICATION hApplication,
|
||||
LPSTR szFileName,
|
||||
ULONG ulFileSize,
|
||||
ULONG ulReadRights,
|
||||
ULONG ulWriteRights)
|
||||
{
|
||||
return SAR_OK;
|
||||
}
|
||||
|
||||
ULONG DEVAPI SKF_DeleteFile(
|
||||
HAPPLICATION hApplication,
|
||||
LPSTR szFileName)
|
||||
{
|
||||
return SAR_OK;
|
||||
}
|
||||
|
||||
ULONG DEVAPI SKF_EnumFiles(
|
||||
HAPPLICATION hApplication,
|
||||
LPSTR szFileList,
|
||||
ULONG *pulSize)
|
||||
{
|
||||
char *file_list = "file1.txt\0file2.txt\0";
|
||||
if (!pulSize) {
|
||||
return SAR_INVALIDPARAMERR;
|
||||
}
|
||||
strcpy((char *)szFileList, file_list);
|
||||
*pulSize = strlen(file_list);
|
||||
return SAR_OK;
|
||||
}
|
||||
|
||||
ULONG DEVAPI SKF_GetFileInfo(
|
||||
HAPPLICATION hApplication,
|
||||
LPSTR szFileName,
|
||||
FILEATTRIBUTE *pFileInfo)
|
||||
{
|
||||
if (!pFileInfo) {
|
||||
return SAR_INVALIDPARAMERR;
|
||||
}
|
||||
//TODO: set pFileInfo;
|
||||
return SAR_OK;
|
||||
}
|
||||
|
||||
ULONG DEVAPI SKF_ReadFile(
|
||||
HAPPLICATION hApplication,
|
||||
LPSTR szFileName,
|
||||
ULONG ulOffset,
|
||||
ULONG ulSize,
|
||||
BYTE *pbOutData,
|
||||
ULONG *pulOutLen)
|
||||
{
|
||||
if (!pbOutData || !pulOutLen) {
|
||||
return SAR_INVALIDPARAMERR;
|
||||
}
|
||||
*pulOutLen = ulSize;
|
||||
return SAR_OK;
|
||||
}
|
||||
|
||||
ULONG DEVAPI SKF_WriteFile(
|
||||
HAPPLICATION hApplication,
|
||||
LPSTR szFileName,
|
||||
ULONG ulOffset,
|
||||
BYTE *pbData,
|
||||
ULONG ulSize)
|
||||
{
|
||||
return SAR_OK;
|
||||
}
|
||||
|
||||
ULONG DEVAPI SKF_CreateContainer(
|
||||
HAPPLICATION hApplication,
|
||||
LPSTR szContainerName,
|
||||
HCONTAINER *phContainer)
|
||||
{
|
||||
if (!phContainer) {
|
||||
return SAR_INVALIDPARAMERR;
|
||||
}
|
||||
*phContainer = hContainer;
|
||||
return SAR_OK;
|
||||
}
|
||||
|
||||
ULONG DEVAPI SKF_DeleteContainer(
|
||||
HAPPLICATION hApplication,
|
||||
LPSTR szContainerName)
|
||||
{
|
||||
return SAR_OK;
|
||||
}
|
||||
|
||||
ULONG DEVAPI SKF_EnumContainer(
|
||||
HAPPLICATION hApplication,
|
||||
LPSTR szContainerName,
|
||||
ULONG *pulSize)
|
||||
{
|
||||
char *cont_list = "container1\0container2\0";
|
||||
if (!szContainerName || !pulSize) {
|
||||
return SAR_INVALIDPARAMERR;
|
||||
}
|
||||
strcpy((char *)szContainerName, cont_list);
|
||||
*pulSize = strlen(cont_list);
|
||||
return SAR_OK;
|
||||
}
|
||||
|
||||
ULONG DEVAPI SKF_OpenContainer(
|
||||
HAPPLICATION hApplication,
|
||||
LPSTR szContainerName,
|
||||
HCONTAINER *phContainer)
|
||||
{
|
||||
if (!phContainer) {
|
||||
return SAR_INVALIDPARAMERR;
|
||||
}
|
||||
*phContainer = hContainer;
|
||||
return SAR_OK;
|
||||
}
|
||||
|
||||
ULONG DEVAPI SKF_CloseContainer(
|
||||
HCONTAINER hContainer)
|
||||
{
|
||||
return SAR_OK;
|
||||
}
|
||||
|
||||
ULONG DEVAPI SKF_GetContainerType(
|
||||
HCONTAINER hContainer,
|
||||
ULONG *pulContainerType)
|
||||
{
|
||||
if (!pulContainerType) {
|
||||
return SAR_INVALIDPARAMERR;
|
||||
}
|
||||
*pulContainerType = 0;
|
||||
return SAR_OK;
|
||||
}
|
||||
|
||||
ULONG DEVAPI SKF_ImportCertificate(
|
||||
HCONTAINER hContainer,
|
||||
BOOL bExportSignKey,
|
||||
BYTE *pbCert,
|
||||
ULONG ulCertLen)
|
||||
{
|
||||
return SAR_OK;
|
||||
}
|
||||
|
||||
ULONG DEVAPI SKF_ExportCertificate(
|
||||
HCONTAINER hContainer,
|
||||
BOOL bSignFlag,
|
||||
BYTE *pbCert,
|
||||
ULONG *pulCertLen)
|
||||
{
|
||||
if (!pbCert || !pulCertLen) {
|
||||
return SAR_INVALIDPARAMERR;
|
||||
}
|
||||
memset(pbCert, 'c', 512);
|
||||
*pulCertLen = 512;
|
||||
return SAR_OK;
|
||||
}
|
||||
|
||||
ULONG DEVAPI SKF_ExportPublicKey(
|
||||
HCONTAINER hContainer,
|
||||
BOOL bSignFlag,
|
||||
BYTE *pbBlob,
|
||||
ULONG *pulBlobLen)
|
||||
{
|
||||
if (!pbBlob || !pulBlobLen) {
|
||||
return SAR_INVALIDPARAMERR;
|
||||
}
|
||||
*pulBlobLen = 1024;
|
||||
return SAR_OK;
|
||||
}
|
||||
|
||||
ULONG DEVAPI SKF_GenRandom(
|
||||
DEVHANDLE hDev,
|
||||
BYTE *pbRandom,
|
||||
ULONG ulRandomLen)
|
||||
{
|
||||
if (!pbRandom) {
|
||||
return SAR_INVALIDPARAMERR;
|
||||
}
|
||||
memset(pbRandom, 'r', ulRandomLen);
|
||||
return SAR_OK;
|
||||
}
|
||||
|
||||
ULONG DEVAPI SKF_GenExtRSAKey(
|
||||
DEVHANDLE hDev,
|
||||
ULONG ulBitsLen,
|
||||
RSAPRIVATEKEYBLOB *pBlob)
|
||||
{
|
||||
if (!pBlob) {
|
||||
return SAR_INVALIDPARAMERR;
|
||||
}
|
||||
return SAR_OK;
|
||||
}
|
||||
|
||||
ULONG DEVAPI SKF_GenRSAKeyPair(
|
||||
HCONTAINER hContainer,
|
||||
ULONG ulBitsLen,
|
||||
RSAPUBLICKEYBLOB *pBlob)
|
||||
{
|
||||
if (!pBlob) {
|
||||
return SAR_INVALIDPARAMERR;
|
||||
}
|
||||
return SAR_OK;
|
||||
}
|
||||
|
||||
ULONG DEVAPI SKF_ImportRSAKeyPair(
|
||||
HCONTAINER hContainer,
|
||||
ULONG ulSymAlgId,
|
||||
BYTE *pbWrappedKey,
|
||||
ULONG ulWrappedKeyLen,
|
||||
BYTE *pbEncryptedData,
|
||||
ULONG ulEncryptedDataLen)
|
||||
{
|
||||
return SAR_OK;
|
||||
}
|
||||
|
||||
ULONG DEVAPI SKF_RSASignData(
|
||||
HCONTAINER hContainer,
|
||||
BYTE *pbData,
|
||||
ULONG ulDataLen,
|
||||
BYTE *pbSignature,
|
||||
ULONG *pulSignLen)
|
||||
{
|
||||
if (!pbSignature || !pulSignLen) {
|
||||
return SAR_INVALIDPARAMERR;
|
||||
}
|
||||
*pulSignLen = 256;
|
||||
return SAR_OK;
|
||||
}
|
||||
|
||||
ULONG DEVAPI SKF_RSAVerify(
|
||||
DEVHANDLE hDev,
|
||||
RSAPUBLICKEYBLOB *pRSAPubKeyBlob,
|
||||
BYTE *pbData,
|
||||
ULONG ulDataLen,
|
||||
BYTE *pbSignature,
|
||||
ULONG ulSignLen)
|
||||
{
|
||||
return SAR_OK;
|
||||
}
|
||||
|
||||
ULONG DEVAPI SKF_RSAExportSessionKey(
|
||||
HCONTAINER hContainer,
|
||||
ULONG ulAlgId,
|
||||
RSAPUBLICKEYBLOB *pPubKey,
|
||||
BYTE *pbData,
|
||||
ULONG *pulDataLen,
|
||||
HANDLE *phSessionKey);
|
||||
|
||||
ULONG DEVAPI SKF_ExtRSAPubKeyOperation(
|
||||
DEVHANDLE hDev,
|
||||
RSAPUBLICKEYBLOB *pRSAPubKeyBlob,
|
||||
BYTE *pbInput,
|
||||
ULONG ulInputLen,
|
||||
BYTE *pbOutput,
|
||||
ULONG *pulOutputLen)
|
||||
{
|
||||
if (!pbOutput || !pulOutputLen) {
|
||||
return SAR_INVALIDPARAMERR;
|
||||
}
|
||||
*pulOutputLen = 256;
|
||||
return SAR_OK;
|
||||
}
|
||||
|
||||
ULONG DEVAPI SKF_ExtRSAPriKeyOperation(
|
||||
DEVHANDLE hDev,
|
||||
RSAPRIVATEKEYBLOB *pRSAPriKeyBlob,
|
||||
BYTE *pbInput,
|
||||
ULONG ulInputLen,
|
||||
BYTE *pbOutput,
|
||||
ULONG *pulOutputLen)
|
||||
{
|
||||
if (!pbOutput || !pulOutputLen) {
|
||||
return SAR_INVALIDPARAMERR;
|
||||
}
|
||||
*pulOutputLen = 256;
|
||||
return SAR_OK;
|
||||
}
|
||||
|
||||
ULONG DEVAPI SKF_GenECCKeyPair(
|
||||
HCONTAINER hContainer,
|
||||
ULONG ulAlgId,
|
||||
ECCPUBLICKEYBLOB *pBlob)
|
||||
{
|
||||
if (!pBlob) {
|
||||
return SAR_INVALIDPARAMERR;
|
||||
}
|
||||
return SAR_OK;
|
||||
}
|
||||
|
||||
ULONG DEVAPI SKF_ImportECCKeyPair(
|
||||
HCONTAINER hContainer,
|
||||
ENVELOPEDKEYBLOB *pEnvelopedKeyBlob)
|
||||
{
|
||||
return SAR_OK;
|
||||
}
|
||||
|
||||
ULONG DEVAPI SKF_ECCSignData(
|
||||
HCONTAINER hContainer,
|
||||
BYTE *pbDigest,
|
||||
ULONG ulDigestLen,
|
||||
ECCSIGNATUREBLOB *pSignature)
|
||||
{
|
||||
if (!pSignature) {
|
||||
return SAR_INVALIDPARAMERR;
|
||||
}
|
||||
return SAR_OK;
|
||||
}
|
||||
|
||||
ULONG DEVAPI SKF_ECCVerify(
|
||||
DEVHANDLE hDev,
|
||||
ECCPUBLICKEYBLOB *pECCPubKeyBlob,
|
||||
BYTE *pbData,
|
||||
ULONG ulDataLen,
|
||||
ECCSIGNATUREBLOB *pSignature)
|
||||
{
|
||||
return SAR_OK;
|
||||
}
|
||||
|
||||
ULONG DEVAPI SKF_ECCExportSessionKey(
|
||||
HCONTAINER hContainer,
|
||||
ULONG ulAlgId,
|
||||
ECCPUBLICKEYBLOB *pPubKey,
|
||||
ECCCIPHERBLOB *pData,
|
||||
HANDLE *phSessionKey)
|
||||
{
|
||||
if (!phSessionKey) {
|
||||
return SAR_INVALIDPARAMERR;
|
||||
}
|
||||
*phSessionKey = hKeyHandle;
|
||||
return SAR_OK;
|
||||
}
|
||||
|
||||
ULONG DEVAPI SKF_ExtECCEncrypt(
|
||||
DEVHANDLE hDev,
|
||||
ECCPUBLICKEYBLOB *pECCPubKeyBlob,
|
||||
BYTE *pbPlainText,
|
||||
ULONG ulPlainTextLen,
|
||||
ECCCIPHERBLOB *pCipherText)
|
||||
{
|
||||
return SAR_OK;
|
||||
}
|
||||
|
||||
ULONG DEVAPI SKF_ExtECCDecrypt(
|
||||
DEVHANDLE hDev,
|
||||
ECCPRIVATEKEYBLOB *pECCPriKeyBlob,
|
||||
ECCCIPHERBLOB *pCipherText,
|
||||
BYTE *pbPlainText,
|
||||
ULONG *pulPlainTextLen)
|
||||
{
|
||||
return SAR_OK;
|
||||
}
|
||||
|
||||
ULONG DEVAPI SKF_ExtECCSign(
|
||||
DEVHANDLE hDev,
|
||||
ECCPRIVATEKEYBLOB *pECCPriKeyBlob,
|
||||
BYTE *pbData,
|
||||
ULONG ulDataLen,
|
||||
ECCSIGNATUREBLOB *pSignature)
|
||||
{
|
||||
if (!pSignature) {
|
||||
return SAR_INVALIDPARAMERR;
|
||||
}
|
||||
return SAR_OK;
|
||||
}
|
||||
|
||||
ULONG DEVAPI SKF_ExtECCVerify(
|
||||
DEVHANDLE hDev,
|
||||
ECCPUBLICKEYBLOB *pECCPubKeyBlob,
|
||||
BYTE *pbData,
|
||||
ULONG ulDataLen,
|
||||
ECCSIGNATUREBLOB *pSignature)
|
||||
{
|
||||
return SAR_OK;
|
||||
}
|
||||
|
||||
ULONG DEVAPI SKF_GenerateAgreementDataWithECC(
|
||||
HCONTAINER hContainer,
|
||||
ULONG ulAlgId,
|
||||
ECCPUBLICKEYBLOB *pTempECCPubKeyBlob,
|
||||
BYTE *pbID,
|
||||
ULONG ulIDLen,
|
||||
HANDLE *phAgreementHandle)
|
||||
{
|
||||
if (!phAgreementHandle) {
|
||||
return SAR_INVALIDPARAMERR;
|
||||
}
|
||||
*phAgreementHandle = hAgreementHandle;
|
||||
return SAR_OK;
|
||||
}
|
||||
|
||||
ULONG DEVAPI SKF_GenerateAgreementDataAndKeyWithECC(
|
||||
HANDLE hContainer,
|
||||
ULONG ulAlgId,
|
||||
ECCPUBLICKEYBLOB *pSponsorECCPubKeyBlob,
|
||||
ECCPUBLICKEYBLOB *pSponsorTempECCPubKeyBlob,
|
||||
ECCPUBLICKEYBLOB *pTempECCPubKeyBlob,
|
||||
BYTE *pbID,
|
||||
ULONG ulIDLen,
|
||||
BYTE *pbSponsorID,
|
||||
ULONG ulSponsorIDLen,
|
||||
HANDLE *phKeyHandle)
|
||||
{
|
||||
if (!phKeyHandle) {
|
||||
return SAR_INVALIDPARAMERR;
|
||||
}
|
||||
*phKeyHandle = hKeyHandle;
|
||||
return SAR_OK;
|
||||
}
|
||||
|
||||
ULONG DEVAPI SKF_GenerateKeyWithECC(
|
||||
HANDLE hAgreementHandle,
|
||||
ECCPUBLICKEYBLOB *pECCPubKeyBlob,
|
||||
ECCPUBLICKEYBLOB *pTempECCPubKeyBlob,
|
||||
BYTE *pbID,
|
||||
ULONG ulIDLen,
|
||||
HANDLE *phKeyHandle)
|
||||
{
|
||||
if (!phKeyHandle) {
|
||||
return SAR_INVALIDPARAMERR;
|
||||
}
|
||||
*phKeyHandle = hKeyHandle;
|
||||
return SAR_OK;
|
||||
}
|
||||
|
||||
ULONG DEVAPI SKF_ImportSessionKey(
|
||||
HCONTAINER hContainer,
|
||||
ULONG ulAlgId,
|
||||
BYTE *pbWrapedData,
|
||||
ULONG ulWrapedLen,
|
||||
HANDLE *phKey)
|
||||
{
|
||||
if (!phKey) {
|
||||
return SAR_INVALIDPARAMERR;
|
||||
}
|
||||
*phKey = hKeyHandle;
|
||||
return SAR_OK;
|
||||
}
|
||||
|
||||
ULONG DEVAPI SKF_SetSymmKey(
|
||||
DEVHANDLE hDev,
|
||||
BYTE *pbKey,
|
||||
ULONG ulAlgID,
|
||||
HANDLE *phKey)
|
||||
{
|
||||
if (!phKey) {
|
||||
return SAR_INVALIDPARAMERR;
|
||||
}
|
||||
*phKey = hKeyHandle;
|
||||
return SAR_OK;
|
||||
}
|
||||
|
||||
ULONG DEVAPI SKF_EncryptInit(
|
||||
HANDLE hKey,
|
||||
BLOCKCIPHERPARAM EncryptParam)
|
||||
{
|
||||
return SAR_OK;
|
||||
}
|
||||
|
||||
ULONG DEVAPI SKF_Encrypt(
|
||||
HANDLE hKey,
|
||||
BYTE *pbData,
|
||||
ULONG ulDataLen,
|
||||
BYTE *pbEncryptedData,
|
||||
ULONG *pulEncryptedLen)
|
||||
{
|
||||
if (!pbData || !pbEncryptedData || !pulEncryptedLen) {
|
||||
return SAR_INVALIDPARAMERR;
|
||||
}
|
||||
memcpy(pbEncryptedData, pbData, ulDataLen);
|
||||
*pulEncryptedLen = ulDataLen;
|
||||
return SAR_OK;
|
||||
}
|
||||
|
||||
ULONG DEVAPI SKF_EncryptUpdate(
|
||||
HANDLE hKey,
|
||||
BYTE *pbData,
|
||||
ULONG ulDataLen,
|
||||
BYTE *pbEncryptedData,
|
||||
ULONG *pulEncryptedLen)
|
||||
{
|
||||
if (!pbData || !pbEncryptedData || !pulEncryptedLen) {
|
||||
return SAR_INVALIDPARAMERR;
|
||||
}
|
||||
memcpy(pbEncryptedData, pbData, ulDataLen);
|
||||
*pulEncryptedLen = ulDataLen;
|
||||
return SAR_OK;
|
||||
}
|
||||
|
||||
ULONG DEVAPI SKF_EncryptFinal(
|
||||
HANDLE hKey,
|
||||
BYTE *pbEncryptedData,
|
||||
ULONG *pulEncryptedDataLen)
|
||||
{
|
||||
if (!pbEncryptedData || !pulEncryptedDataLen) {
|
||||
return SAR_INVALIDPARAMERR;
|
||||
}
|
||||
*pulEncryptedDataLen = 0;
|
||||
return SAR_OK;
|
||||
}
|
||||
|
||||
ULONG DEVAPI SKF_DecryptInit(
|
||||
HANDLE hKey,
|
||||
BLOCKCIPHERPARAM DecryptParam)
|
||||
{
|
||||
return SAR_OK;
|
||||
}
|
||||
|
||||
ULONG DEVAPI SKF_Decrypt(
|
||||
HANDLE hKey,
|
||||
BYTE *pbEncryptedData,
|
||||
ULONG ulEncryptedLen,
|
||||
BYTE *pbData,
|
||||
ULONG *pulDataLen)
|
||||
{
|
||||
if (!pbEncryptedData || !pbData || !pulDataLen) {
|
||||
return SAR_INVALIDPARAMERR;
|
||||
}
|
||||
memcpy(pbData, pbEncryptedData, ulEncryptedLen);
|
||||
*pulDataLen = ulEncryptedLen;
|
||||
return SAR_OK;
|
||||
}
|
||||
|
||||
ULONG DEVAPI SKF_DecryptUpdate(
|
||||
HANDLE hKey,
|
||||
BYTE *pbEncryptedData,
|
||||
ULONG ulEncryptedLen,
|
||||
BYTE *pbData,
|
||||
ULONG *pulDataLen)
|
||||
{
|
||||
if (!pbEncryptedData || !pbData || !pulDataLen) {
|
||||
return SAR_INVALIDPARAMERR;
|
||||
}
|
||||
memcpy(pbData, pbEncryptedData, ulEncryptedLen);
|
||||
*pulDataLen = ulEncryptedLen;
|
||||
return SAR_OK;
|
||||
}
|
||||
|
||||
ULONG DEVAPI SKF_DecryptFinal(
|
||||
HANDLE hKey,
|
||||
BYTE *pbDecryptedData,
|
||||
ULONG *pulDecryptedDataLen)
|
||||
{
|
||||
if (!pulDecryptedDataLen) {
|
||||
return SAR_INVALIDPARAMERR;
|
||||
}
|
||||
*pulDecryptedDataLen = 0;
|
||||
return SAR_OK;
|
||||
}
|
||||
|
||||
ULONG DEVAPI SKF_DigestInit(
|
||||
DEVHANDLE hDev,
|
||||
ULONG ulAlgID,
|
||||
ECCPUBLICKEYBLOB *pPubKey,
|
||||
BYTE *pbID,
|
||||
ULONG ulIDLen,
|
||||
HANDLE *phHash)
|
||||
{
|
||||
if (!phHash) {
|
||||
return SAR_INVALIDPARAMERR;
|
||||
}
|
||||
*phHash = hHashHandle;
|
||||
return SAR_OK;
|
||||
}
|
||||
|
||||
ULONG DEVAPI SKF_Digest(
|
||||
HANDLE hHash,
|
||||
BYTE *pbData,
|
||||
ULONG ulDataLen,
|
||||
BYTE *pbHashData,
|
||||
ULONG *pulHashLen)
|
||||
{
|
||||
if (!pbHashData || !pulHashLen) {
|
||||
return SAR_INVALIDPARAMERR;
|
||||
}
|
||||
memset(pbHashData, 'h', 32);
|
||||
*pulHashLen = 32;
|
||||
return SAR_OK;
|
||||
}
|
||||
|
||||
ULONG DEVAPI SKF_DigestUpdate(
|
||||
HANDLE hHash,
|
||||
BYTE *pbData,
|
||||
ULONG ulDataLen)
|
||||
{
|
||||
return SAR_OK;
|
||||
}
|
||||
|
||||
ULONG DEVAPI SKF_DigestFinal(
|
||||
HANDLE hHash,
|
||||
BYTE *pbHashData,
|
||||
ULONG *pulHashLen)
|
||||
{
|
||||
if (!pbHashData || !pulHashLen) {
|
||||
return SAR_INVALIDPARAMERR;
|
||||
}
|
||||
memset(pbHashData, 'h', 32);
|
||||
*pulHashLen = 32;
|
||||
return SAR_OK;
|
||||
}
|
||||
|
||||
ULONG DEVAPI SKF_MacInit(
|
||||
HANDLE hKey,
|
||||
BLOCKCIPHERPARAM *pMacParam,
|
||||
HANDLE *phMac)
|
||||
{
|
||||
if (!phMac) {
|
||||
return SAR_INVALIDPARAMERR;
|
||||
}
|
||||
*phMac = hMacHandle;
|
||||
return SAR_OK;
|
||||
}
|
||||
|
||||
ULONG DEVAPI SKF_Mac(
|
||||
HANDLE hMac,
|
||||
BYTE *pbData,
|
||||
ULONG ulDataLen,
|
||||
BYTE *pbMacData,
|
||||
ULONG *pulMacLen)
|
||||
{
|
||||
if (!pbMacData || !pulMacLen) {
|
||||
return SAR_INVALIDPARAMERR;
|
||||
}
|
||||
memset(pbMacData, 'm', 32);
|
||||
*pulMacLen = 32;
|
||||
return SAR_OK;
|
||||
}
|
||||
|
||||
ULONG DEVAPI SKF_MacUpdate(
|
||||
HANDLE hMac,
|
||||
BYTE *pbData,
|
||||
ULONG ulDataLen)
|
||||
{
|
||||
return SAR_OK;
|
||||
}
|
||||
|
||||
ULONG DEVAPI SKF_MacFinal(
|
||||
HANDLE hMac,
|
||||
BYTE *pbMacData,
|
||||
ULONG *pulMacDataLen)
|
||||
{
|
||||
if (!pbMacData || !pulMacDataLen) {
|
||||
return SAR_INVALIDPARAMERR;
|
||||
}
|
||||
memset(pbMacData, 'm', 32);
|
||||
*pulMacDataLen = 32;
|
||||
return SAR_OK;
|
||||
}
|
||||
|
||||
ULONG DEVAPI SKF_CloseHandle(
|
||||
HANDLE hHandle)
|
||||
{
|
||||
return SAR_OK;
|
||||
}
|
||||
@@ -19,12 +19,180 @@
|
||||
# define ERR_REASON(reason) ERR_PACK(ERR_LIB_SKF,0,reason)
|
||||
|
||||
static ERR_STRING_DATA SKF_str_functs[] = {
|
||||
{ERR_FUNC(SKF_F_SKF_CANCELWAITFORDEVEVENT), "SKF_CancelWaitForDevEvent"},
|
||||
{ERR_FUNC(SKF_F_SKF_CHANGEDEVAUTHKEY), "SKF_ChangeDevAuthKey"},
|
||||
{ERR_FUNC(SKF_F_SKF_CHANGEPIN), "SKF_ChangePIN"},
|
||||
{ERR_FUNC(SKF_F_SKF_CLEARSECURESTATE), "SKF_ClearSecureState"},
|
||||
{ERR_FUNC(SKF_F_SKF_CLOSEAPPLICATION), "SKF_CloseApplication"},
|
||||
{ERR_FUNC(SKF_F_SKF_CLOSECONTAINER), "SKF_CloseContainer"},
|
||||
{ERR_FUNC(SKF_F_SKF_CLOSEHANDLE), "SKF_CloseHandle"},
|
||||
{ERR_FUNC(SKF_F_SKF_CONNECTDEV), "SKF_ConnectDev"},
|
||||
{ERR_FUNC(SKF_F_SKF_CREATEAPPLICATION), "SKF_CreateApplication"},
|
||||
{ERR_FUNC(SKF_F_SKF_CREATECONTAINER), "SKF_CreateContainer"},
|
||||
{ERR_FUNC(SKF_F_SKF_CREATEFILE), "SKF_CreateFile"},
|
||||
{ERR_FUNC(SKF_F_SKF_DECRYPT), "SKF_Decrypt"},
|
||||
{ERR_FUNC(SKF_F_SKF_DECRYPTFINAL), "SKF_DecryptFinal"},
|
||||
{ERR_FUNC(SKF_F_SKF_DECRYPTINIT), "SKF_DecryptInit"},
|
||||
{ERR_FUNC(SKF_F_SKF_DECRYPTUPDATE), "SKF_DecryptUpdate"},
|
||||
{ERR_FUNC(SKF_F_SKF_DELETEAPPLICATION), "SKF_DeleteApplication"},
|
||||
{ERR_FUNC(SKF_F_SKF_DELETECONTAINER), "SKF_DeleteContainer"},
|
||||
{ERR_FUNC(SKF_F_SKF_DELETEFILE), "SKF_DeleteFile"},
|
||||
{ERR_FUNC(SKF_F_SKF_DEVAUTH), "SKF_DevAuth"},
|
||||
{ERR_FUNC(SKF_F_SKF_DIGEST), "SKF_Digest"},
|
||||
{ERR_FUNC(SKF_F_SKF_DIGESTFINAL), "SKF_DigestFinal"},
|
||||
{ERR_FUNC(SKF_F_SKF_DIGESTINIT), "SKF_DigestInit"},
|
||||
{ERR_FUNC(SKF_F_SKF_DIGESTUPDATE), "SKF_DigestUpdate"},
|
||||
{ERR_FUNC(SKF_F_SKF_DISCONNECTDEV), "SKF_DisConnectDev"},
|
||||
{ERR_FUNC(SKF_F_SKF_ECCDECRYPT), "SKF_ECCDecrypt"},
|
||||
{ERR_FUNC(SKF_F_SKF_ECCEXPORTSESSIONKEY), "SKF_ECCExportSessionKey"},
|
||||
{ERR_FUNC(SKF_F_SKF_ECCSIGNDATA), "SKF_ECCSignData"},
|
||||
{ERR_FUNC(SKF_F_SKF_ECCVERIFY), "SKF_ECCVerify"},
|
||||
{ERR_FUNC(SKF_F_SKF_ENCRYPT), "SKF_Encrypt"},
|
||||
{ERR_FUNC(SKF_F_SKF_ENCRYPTFINAL), "SKF_EncryptFinal"},
|
||||
{ERR_FUNC(SKF_F_SKF_ENCRYPTINIT), "SKF_EncryptInit"},
|
||||
{ERR_FUNC(SKF_F_SKF_ENCRYPTUPDATE), "SKF_EncryptUpdate"},
|
||||
{ERR_FUNC(SKF_F_SKF_ENUMAPPLICATION), "SKF_EnumApplication"},
|
||||
{ERR_FUNC(SKF_F_SKF_ENUMCONTAINER), "SKF_EnumContainer"},
|
||||
{ERR_FUNC(SKF_F_SKF_ENUMDEV), "SKF_EnumDev"},
|
||||
{ERR_FUNC(SKF_F_SKF_ENUMFILES), "SKF_EnumFiles"},
|
||||
{ERR_FUNC(SKF_F_SKF_EXPORTCERTIFICATE), "SKF_ExportCertificate"},
|
||||
{ERR_FUNC(SKF_F_SKF_EXPORTPUBLICKEY), "SKF_ExportPublicKey"},
|
||||
{ERR_FUNC(SKF_F_SKF_EXTECCDECRYPT), "SKF_ExtECCDecrypt"},
|
||||
{ERR_FUNC(SKF_F_SKF_EXTECCENCRYPT), "SKF_ExtECCEncrypt"},
|
||||
{ERR_FUNC(SKF_F_SKF_EXTECCSIGN), "SKF_ExtECCSign"},
|
||||
{ERR_FUNC(SKF_F_SKF_EXTECCVERIFY), "SKF_ExtECCVerify"},
|
||||
{ERR_FUNC(SKF_F_SKF_EXTRSAPRIKEYOPERATION), "SKF_ExtRSAPriKeyOperation"},
|
||||
{ERR_FUNC(SKF_F_SKF_EXTRSAPUBKEYOPERATION), "SKF_ExtRSAPubKeyOperation"},
|
||||
{ERR_FUNC(SKF_F_SKF_GENECCKEYPAIR), "SKF_GenECCKeyPair"},
|
||||
{ERR_FUNC(SKF_F_SKF_GENERATEAGREEMENTDATAANDKEYWITHECC),
|
||||
"SKF_GenerateAgreementDataAndKeyWithECC"},
|
||||
{ERR_FUNC(SKF_F_SKF_GENERATEAGREEMENTDATAWITHECC),
|
||||
"SKF_GenerateAgreementDataWithECC"},
|
||||
{ERR_FUNC(SKF_F_SKF_GENERATEKEYWITHECC), "SKF_GenerateKeyWithECC"},
|
||||
{ERR_FUNC(SKF_F_SKF_GENEXTRSAKEY), "SKF_GenExtRSAKey"},
|
||||
{ERR_FUNC(SKF_F_SKF_GENRANDOM), "SKF_GenRandom"},
|
||||
{ERR_FUNC(SKF_F_SKF_GENRSAKEYPAIR), "SKF_GenRSAKeyPair"},
|
||||
{ERR_FUNC(SKF_F_SKF_GETCONTAINERTYPE), "SKF_GetContainerType"},
|
||||
{ERR_FUNC(SKF_F_SKF_GETDEVINFO), "SKF_GetDevInfo"},
|
||||
{ERR_FUNC(SKF_F_SKF_GETDEVSTATE), "SKF_GetDevState"},
|
||||
{ERR_FUNC(SKF_F_SKF_GETFILEINFO), "SKF_GetFileInfo"},
|
||||
{ERR_FUNC(SKF_F_SKF_GETPININFO), "SKF_GetPINInfo"},
|
||||
{ERR_FUNC(SKF_F_SKF_IMPORTCERTIFICATE), "SKF_ImportCertificate"},
|
||||
{ERR_FUNC(SKF_F_SKF_IMPORTECCKEYPAIR), "SKF_ImportECCKeyPair"},
|
||||
{ERR_FUNC(SKF_F_SKF_IMPORTECCPRIVATEKEY), "SKF_ImportECCPrivateKey"},
|
||||
{ERR_FUNC(SKF_F_SKF_IMPORTRSAKEYPAIR), "SKF_ImportRSAKeyPair"},
|
||||
{ERR_FUNC(SKF_F_SKF_IMPORTSESSIONKEY), "SKF_ImportSessionKey"},
|
||||
{ERR_FUNC(SKF_F_SKF_LOADLIBRARY), "SKF_LoadLibrary"},
|
||||
{ERR_FUNC(SKF_F_SKF_LOCKDEV), "SKF_LockDev"},
|
||||
{ERR_FUNC(SKF_F_SKF_MAC), "SKF_Mac"},
|
||||
{ERR_FUNC(SKF_F_SKF_MACFINAL), "SKF_MacFinal"},
|
||||
{ERR_FUNC(SKF_F_SKF_MACINIT), "SKF_MacInit"},
|
||||
{ERR_FUNC(SKF_F_SKF_MACUPDATE), "SKF_MacUpdate"},
|
||||
{ERR_FUNC(SKF_F_SKF_METHOD_LOAD_LIBRARY), "SKF_METHOD_load_library"},
|
||||
{ERR_FUNC(SKF_F_SKF_NEWECCCIPHER), "SKF_NewECCCipher"},
|
||||
{ERR_FUNC(SKF_F_SKF_NEWENVELOPEDKEY), "SKF_NewEnvelopedKey"},
|
||||
{ERR_FUNC(SKF_F_SKF_OPENAPPLICATION), "SKF_OpenApplication"},
|
||||
{ERR_FUNC(SKF_F_SKF_OPENCONTAINER), "SKF_OpenContainer"},
|
||||
{ERR_FUNC(SKF_F_SKF_READFILE), "SKF_ReadFile"},
|
||||
{ERR_FUNC(SKF_F_SKF_RSAEXPORTSESSIONKEY), "SKF_RSAExportSessionKey"},
|
||||
{ERR_FUNC(SKF_F_SKF_RSASIGNDATA), "SKF_RSASignData"},
|
||||
{ERR_FUNC(SKF_F_SKF_RSAVERIFY), "SKF_RSAVerify"},
|
||||
{ERR_FUNC(SKF_F_SKF_SETLABEL), "SKF_SetLabel"},
|
||||
{ERR_FUNC(SKF_F_SKF_SETSYMMKEY), "SKF_SetSymmKey"},
|
||||
{ERR_FUNC(SKF_F_SKF_TRANSMIT), "SKF_Transmit"},
|
||||
{ERR_FUNC(SKF_F_SKF_UNBLOCKPIN), "SKF_UnblockPIN"},
|
||||
{ERR_FUNC(SKF_F_SKF_UNLOCKDEV), "SKF_UnlockDev"},
|
||||
{ERR_FUNC(SKF_F_SKF_VERIFYPIN), "SKF_VerifyPIN"},
|
||||
{ERR_FUNC(SKF_F_SKF_W), "SKF_WaitForDevEvent"},
|
||||
{ERR_FUNC(SKF_F_SKF_WAITFORDEVEVENT), "SKF_WaitForDevEvent"},
|
||||
{ERR_FUNC(SKF_F_SKF_WRITEFILE), "SKF_WriteFile"},
|
||||
{0, NULL}
|
||||
};
|
||||
|
||||
static ERR_STRING_DATA SKF_str_reasons[] = {
|
||||
{ERR_REASON(SKF_R_APPLICATION_ALREADY_EXIST),
|
||||
"application already exist"},
|
||||
{ERR_REASON(SKF_R_APPLICATION_NOT_EXISAT), "application not exisat"},
|
||||
{ERR_REASON(SKF_R_APPLICATION_NOT_EXIST), "application not exist"},
|
||||
{ERR_REASON(SKF_R_BUFFER_TOO_SMALL), "buffer too small"},
|
||||
{ERR_REASON(SKF_R_CERTIFICATE_NOT_FOUND), "certificate not found"},
|
||||
{ERR_REASON(SKF_R_CSP_IMPORT_PUBLIC_KEY_ERROR),
|
||||
"csp import public key error"},
|
||||
{ERR_REASON(SKF_R_DECRYPT_INVALID_PADDING), "decrypt invalid padding"},
|
||||
{ERR_REASON(SKF_R_DEVICE_REMOVED), "device removed"},
|
||||
{ERR_REASON(SKF_R_DIGEST_ERROR), "digest error"},
|
||||
{ERR_REASON(SKF_R_DSO_LOAD_FAILURE), "dso load failure"},
|
||||
{ERR_REASON(SKF_R_ENVELOPE_PRVATE_KEY_FAILURE),
|
||||
"envelope prvate key failure"},
|
||||
{ERR_REASON(SKF_R_EXPORT_FAILED), "export failed"},
|
||||
{ERR_REASON(SKF_R_FAILURE), "failure"},
|
||||
{ERR_REASON(SKF_R_FILE_ALREADY_EXIST), "file already exist"},
|
||||
{ERR_REASON(SKF_R_FILE_ERROR), "file error"},
|
||||
{ERR_REASON(SKF_R_FILE_NOT_EXIST), "file not exist"},
|
||||
{ERR_REASON(SKF_R_FUNCTION_NOT_SUPPORTED), "function not supported"},
|
||||
{ERR_REASON(SKF_R_HASH_NOT_EQUAL), "hash not equal"},
|
||||
{ERR_REASON(SKF_R_IMPORT_ENVELOPED_ECC_PRIVATE_KEY_FAILURE),
|
||||
"import enveloped ecc private key failure"},
|
||||
{ERR_REASON(SKF_R_INVALID_APPLICATION_NAME), "invalid application name"},
|
||||
{ERR_REASON(SKF_R_INVALID_CONTAINER_TYPE), "invalid container type"},
|
||||
{ERR_REASON(SKF_R_INVALID_DIGEST_HANDLE), "invalid digest handle"},
|
||||
{ERR_REASON(SKF_R_INVALID_HANDLE), "invalid handle"},
|
||||
{ERR_REASON(SKF_R_INVALID_INPUT_LENGTH), "invalid input length"},
|
||||
{ERR_REASON(SKF_R_INVALID_INPUT_VALUE), "invalid input value"},
|
||||
{ERR_REASON(SKF_R_INVALID_KEY_INFO_TYPE), "invalid key info type"},
|
||||
{ERR_REASON(SKF_R_INVALID_KEY_USAGE), "invalid key usage"},
|
||||
{ERR_REASON(SKF_R_INVALID_MAC_LENGTH), "invalid mac length"},
|
||||
{ERR_REASON(SKF_R_INVALID_MODULUS_LENGTH), "invalid modulus length"},
|
||||
{ERR_REASON(SKF_R_INVALID_NAME_LENGTH), "invalid name length"},
|
||||
{ERR_REASON(SKF_R_INVALID_OBJECT), "invalid object"},
|
||||
{ERR_REASON(SKF_R_INVALID_PARAMETER), "invalid parameter"},
|
||||
{ERR_REASON(SKF_R_INVALID_PIN), "invalid pin"},
|
||||
{ERR_REASON(SKF_R_INVALID_PIN_LENGTH), "invalid pin length"},
|
||||
{ERR_REASON(SKF_R_INVALID_RSA_MODULUS_LENGTH),
|
||||
"invalid rsa modulus length"},
|
||||
{ERR_REASON(SKF_R_INVALID_USER_TYPE), "invalid user type"},
|
||||
{ERR_REASON(SKF_R_KEY_NOT_FOUND), "key not found"},
|
||||
{ERR_REASON(SKF_R_LOAD_LIBRARY_FAILURE), "load library failure"},
|
||||
{ERR_REASON(SKF_R_MEMORY_ERROR), "memory error"},
|
||||
{ERR_REASON(SKF_R_NOT_INITIALIZED), "not initialized"},
|
||||
{ERR_REASON(SKF_R_NOT_SUPPORTED_CIPHER_ALGOR),
|
||||
"not supported cipher algor"},
|
||||
{ERR_REASON(SKF_R_NOT_SUPPORTED_DIGEST_ALGOR),
|
||||
"not supported digest algor"},
|
||||
{ERR_REASON(SKF_R_NOT_SUPPORTED_PKEY_ALGOR), "not supported pkey algor"},
|
||||
{ERR_REASON(SKF_R_NO_EVENT), "no event"},
|
||||
{ERR_REASON(SKF_R_NO_SPACE), "no space"},
|
||||
{ERR_REASON(SKF_R_NULL_ARGUMENT), "null argument"},
|
||||
{ERR_REASON(SKF_R_OPERATION_NOT_SUPPORTED), "operation not supported"},
|
||||
{ERR_REASON(SKF_R_PIN_INCORRECT), "pin incorrect"},
|
||||
{ERR_REASON(SKF_R_PIN_LOCKED), "pin locked"},
|
||||
{ERR_REASON(SKF_R_RANDOM_GENERATION_FAILED), "random generation failed"},
|
||||
{ERR_REASON(SKF_R_READ_FILE_FAILURE), "read file failure"},
|
||||
{ERR_REASON(SKF_R_RSA_DECRYPTION_FAILURE), "rsa decryption failure"},
|
||||
{ERR_REASON(SKF_R_RSA_ENCRYPTION_FAILURE), "rsa encryption failure"},
|
||||
{ERR_REASON(SKF_R_RSA_KEY_GENERATION_FAILURE),
|
||||
"rsa key generation failure"},
|
||||
{ERR_REASON(SKF_R_SKF_METHOD_NOT_INITIALIZED),
|
||||
"skf method not initialized"},
|
||||
{ERR_REASON(SKF_R_SUCCESS), "success"},
|
||||
{ERR_REASON(SKF_R_TIMEOUT), "timeout"},
|
||||
{ERR_REASON(SKF_R_UNKNOWN_ERROR), "unknown error"},
|
||||
{ERR_REASON(SKF_R_UNKNOWN_VENDOR), "unknown vendor"},
|
||||
{ERR_REASON(SKF_R_USER_ALREADY_LOGGED_IN), "user already logged in"},
|
||||
{ERR_REASON(SKF_R_USER_NOT_LOGGED_IN), "user not logged in"},
|
||||
{ERR_REASON(SKF_R_USER_PIN_NOT_INITIALIZED), "user pin not initialized"},
|
||||
{ERR_REASON(SKF_R_WISEC_AUTH_BLOCKED), "wisec auth blocked"},
|
||||
{ERR_REASON(SKF_R_WISEC_CERTNOUSAGEERR), "wisec certnousageerr"},
|
||||
{ERR_REASON(SKF_R_WISEC_CERTUSAGEERR), "wisec certusageerr"},
|
||||
{ERR_REASON(SKF_R_WISEC_CONTAINER_EXISTS), "wisec container exists"},
|
||||
{ERR_REASON(SKF_R_WISEC_CONTAINER_NOT_EXISTS),
|
||||
"wisec container not exists"},
|
||||
{ERR_REASON(SKF_R_WISEC_DEVNOAUTH), "wisec devnoauth"},
|
||||
{ERR_REASON(SKF_R_WISEC_FILEATTRIBUTEERR), "wisec fileattributeerr"},
|
||||
{ERR_REASON(SKF_R_WISEC_INVALIDCONTAINERERR),
|
||||
"wisec invalidcontainererr"},
|
||||
{ERR_REASON(SKF_R_WISEC_KEYNOUSAGEERR), "wisec keynousageerr"},
|
||||
{ERR_REASON(SKF_R_WRITE_FILE_FAILURE), "write file failure"},
|
||||
{0, NULL}
|
||||
};
|
||||
|
||||
|
||||
350
crypto/skf/skf_ext.c
Normal file
350
crypto/skf/skf_ext.c
Normal file
@@ -0,0 +1,350 @@
|
||||
/* ====================================================================
|
||||
* Copyright (c) 2014 - 2017 The GmSSL Project. All rights reserved.
|
||||
*
|
||||
* Redistribution and use in source and binary forms, with or without
|
||||
* modification, are permitted provided that the following conditions
|
||||
* are met:
|
||||
*
|
||||
* 1. Redistributions of source code must retain the above copyright
|
||||
* notice, this list of conditions and the following disclaimer.
|
||||
*
|
||||
* 2. Redistributions in binary form must reproduce the above copyright
|
||||
* notice, this list of conditions and the following disclaimer in
|
||||
* the documentation and/or other materials provided with the
|
||||
* distribution.
|
||||
*
|
||||
* 3. All advertising materials mentioning features or use of this
|
||||
* software must display the following acknowledgment:
|
||||
* "This product includes software developed by the GmSSL Project.
|
||||
* (http://gmssl.org/)"
|
||||
*
|
||||
* 4. The name "GmSSL Project" must not be used to endorse or promote
|
||||
* products derived from this software without prior written
|
||||
* permission. For written permission, please contact
|
||||
* guanzhi1980@gmail.com.
|
||||
*
|
||||
* 5. Products derived from this software may not be called "GmSSL"
|
||||
* nor may "GmSSL" appear in their names without prior written
|
||||
* permission of the GmSSL Project.
|
||||
*
|
||||
* 6. Redistributions of any form whatsoever must retain the following
|
||||
* acknowledgment:
|
||||
* "This product includes software developed by the GmSSL Project
|
||||
* (http://gmssl.org/)"
|
||||
*
|
||||
* THIS SOFTWARE IS PROVIDED BY THE GmSSL PROJECT ``AS IS'' AND ANY
|
||||
* EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
|
||||
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
|
||||
* PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE GmSSL PROJECT OR
|
||||
* ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
|
||||
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
|
||||
* NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
|
||||
* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
|
||||
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
|
||||
* STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
|
||||
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
|
||||
* OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
* ====================================================================
|
||||
*/
|
||||
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
#include <limits.h>
|
||||
#include <openssl/err.h>
|
||||
#include <openssl/gmskf.h>
|
||||
#include "internal/skf_int.h"
|
||||
#include "../../e_os.h"
|
||||
|
||||
|
||||
static void print_str(const char *name, const char *value)
|
||||
{
|
||||
(void)printf("%-17s: %s\n", name, value);
|
||||
}
|
||||
|
||||
static void print_int(const char *name, ULONG value)
|
||||
{
|
||||
(void)printf("%-17s: ", name);
|
||||
if (value == UINT_MAX) {
|
||||
puts("(unlimited)");
|
||||
} else {
|
||||
printf("%u\n", value);
|
||||
}
|
||||
}
|
||||
|
||||
static void print_buf(const char *name, BYTE *value, size_t len)
|
||||
{
|
||||
size_t i;
|
||||
(void)printf("%-17s : ", name);
|
||||
for (i = 0; i < len; i++) {
|
||||
(void)printf("%02X", value[i]);
|
||||
}
|
||||
putchar('\n');
|
||||
}
|
||||
|
||||
static char *skf_algor_name(ULONG ulAlgID)
|
||||
{
|
||||
switch (ulAlgID) {
|
||||
case SGD_SM1_ECB: return "sm1-ecb";
|
||||
case SGD_SM1_CBC: return "sm1-cbc";
|
||||
case SGD_SM1_CFB: return "sm1-cfb";
|
||||
case SGD_SM1_OFB: return "sm1-ofb128";
|
||||
case SGD_SM1_MAC: return "sm1-mac";
|
||||
case SGD_SM4_ECB: return "sms4-ecb";
|
||||
case SGD_SM4_CBC: return "sms4-cbc";
|
||||
case SGD_SM4_CFB: return "sms4-cfb";
|
||||
case SGD_SM4_OFB: return "sms4-ofb128";
|
||||
case SGD_SM4_MAC: return "sms4-mac";
|
||||
case SGD_SSF33_ECB: return "ssf33-ecb";
|
||||
case SGD_SSF33_CBC: return "ssf33-cbc";
|
||||
case SGD_SSF33_CFB: return "ssf33-cfb";
|
||||
case SGD_SSF33_OFB: return "ssf33-ofb128";
|
||||
case SGD_SSF33_MAC: return "ssf33-mac";
|
||||
case SGD_RSA: return "rsa";
|
||||
case SGD_SM2_1: return "sm2sign";
|
||||
case SGD_SM2_2: return "sm2encrypt";
|
||||
case SGD_SM2_3: return "sm2keyagreement";
|
||||
case SGD_SM3: return "sm3";
|
||||
case SGD_SHA1: return "sha1";
|
||||
case SGD_SHA256: return "sha256";
|
||||
}
|
||||
return NULL;
|
||||
}
|
||||
|
||||
ULONG SKF_GetDevStateName(ULONG ulDevState, LPSTR *szDevStateName)
|
||||
{
|
||||
if (!szDevStateName) {
|
||||
return SAR_INDATALENERR;
|
||||
}
|
||||
|
||||
switch (ulDevState) {
|
||||
case SKF_DEV_STATE_ABSENT:
|
||||
*szDevStateName = (LPSTR)"Absent";
|
||||
break;
|
||||
case SKF_DEV_STATE_PRESENT:
|
||||
*szDevStateName = (LPSTR)"Present";
|
||||
break;
|
||||
case SKF_DEV_STATE_UNKNOW:
|
||||
*szDevStateName = (LPSTR)"Unknown";
|
||||
break;
|
||||
default:
|
||||
*szDevStateName = (LPSTR)"(Error)";
|
||||
return SAR_INDATALENERR;
|
||||
}
|
||||
|
||||
return SAR_OK;
|
||||
}
|
||||
|
||||
ULONG SKF_GetContainerTypeName(ULONG ulContainerType, LPSTR *szName)
|
||||
{
|
||||
switch (ulContainerType) {
|
||||
case SKF_CONTAINER_TYPE_UNDEF:
|
||||
*szName = (LPSTR)"(undef)";
|
||||
break;
|
||||
case SKF_CONTAINER_TYPE_RSA:
|
||||
*szName = (LPSTR)"RSA";
|
||||
break;
|
||||
case SKF_CONTAINER_TYPE_ECC:
|
||||
*szName = (LPSTR)"EC";
|
||||
break;
|
||||
default:
|
||||
*szName = (LPSTR)"(unknown)";
|
||||
}
|
||||
/* always success for help functions */
|
||||
return SAR_OK;
|
||||
}
|
||||
|
||||
typedef struct {
|
||||
ULONG id;
|
||||
char *name;
|
||||
} table_item_t;
|
||||
|
||||
static table_item_t skf_cipher_caps[] = {
|
||||
{ SGD_SM1_ECB, "sm1-ecb" },
|
||||
{ SGD_SM1_CBC, "sm1-cbc" },
|
||||
{ SGD_SM1_CFB, "sm1-cfb" },
|
||||
{ SGD_SM1_OFB, "sm1-ofb128" },
|
||||
{ SGD_SM1_MAC, "cbcmac-sm1" },
|
||||
{ SGD_SSF33_ECB, "ssf33-ecb" },
|
||||
{ SGD_SSF33_CBC, "ssf33-cbc" },
|
||||
{ SGD_SSF33_CFB, "ssf33-cfb" },
|
||||
{ SGD_SSF33_OFB, "ssf33-ofb128" },
|
||||
{ SGD_SSF33_MAC, "cbcmac-ssf33" },
|
||||
{ SGD_SM4_ECB, "sms4-ecb" },
|
||||
{ SGD_SM4_CBC, "sms4-cbc" },
|
||||
{ SGD_SM4_CFB, "sms4-cfb" },
|
||||
{ SGD_SM4_OFB, "sms4-ofb128" },
|
||||
{ SGD_SM4_MAC, "cbcmac-sms4" },
|
||||
{ SGD_ZUC_EEA3, "zuc_128eea3" },
|
||||
{ SGD_ZUC_EIA3, "zuc_128eia3" }
|
||||
};
|
||||
|
||||
static table_item_t skf_digest_caps[] = {
|
||||
{ SGD_SM3, "sm3" },
|
||||
{ SGD_SHA1, "sha1" },
|
||||
{ SGD_SHA256, "sha256" },
|
||||
};
|
||||
|
||||
static table_item_t skf_pkey_caps[] = {
|
||||
{ SGD_RSA_SIGN, "rsa" },
|
||||
{ SGD_RSA_ENC, "rsaEncryption" },
|
||||
{ SGD_SM2_1, "sm2sign" },
|
||||
{ SGD_SM2_2, "sm2exchange" },
|
||||
{ SGD_SM2_3, "sm2encrypt" }
|
||||
};
|
||||
|
||||
ULONG SKF_PrintDevInfo(DEVINFO *devInfo)
|
||||
{
|
||||
int i, n;
|
||||
|
||||
printf(" Version : %d.%d\n", devInfo->Version.major,
|
||||
devInfo->Version.minor);
|
||||
printf(" Manufacturer : %s\n", devInfo->Manufacturer);
|
||||
printf(" Issuer : %s\n", devInfo->Issuer);
|
||||
printf(" Label : %s\n", devInfo->Label);
|
||||
print_buf(" Serial Number", devInfo->SerialNumber, strlen((char *)devInfo->SerialNumber));
|
||||
printf(" Hardware Version : %d.%d\n", devInfo->HWVersion.major,
|
||||
devInfo->HWVersion.minor);
|
||||
printf(" Firmware Version : %d.%d\n", devInfo->FirmwareVersion.major,
|
||||
devInfo->FirmwareVersion.minor);
|
||||
printf(" Ciphers : ");
|
||||
for (i = n = 0; i < OSSL_NELEM(skf_cipher_caps); i++) {
|
||||
if ((devInfo->AlgSymCap & skf_cipher_caps[i].id) ==
|
||||
skf_cipher_caps[i].id) {
|
||||
printf("%s%s", n ? ", " : "", skf_cipher_caps[i].name);
|
||||
n++;
|
||||
}
|
||||
}
|
||||
printf("\n");
|
||||
printf(" Public Keys : ");
|
||||
for (i = n = 0; i < OSSL_NELEM(skf_pkey_caps); i++) {
|
||||
if ((devInfo->AlgAsymCap & skf_pkey_caps[i].id) ==
|
||||
skf_pkey_caps[i].id) {
|
||||
printf("%s%s", n ? ", " : "", skf_pkey_caps[i].name);
|
||||
n++;
|
||||
}
|
||||
}
|
||||
printf("\n");
|
||||
printf(" Digests : ");
|
||||
for (i = n = 0; i < OSSL_NELEM(skf_digest_caps); i++) {
|
||||
if ((devInfo->AlgHashCap & skf_digest_caps[i].id) ==
|
||||
skf_digest_caps[i].id) {
|
||||
printf("%s%s", n ? ", " : "", skf_digest_caps[i].name);
|
||||
n++;
|
||||
}
|
||||
}
|
||||
printf("\n");
|
||||
printf(" Auth Cipher : ");
|
||||
for (i = 0; i < OSSL_NELEM(skf_cipher_caps); i++) {
|
||||
if (devInfo->DevAuthAlgId == skf_cipher_caps[i].id) {
|
||||
printf("%s\n", skf_cipher_caps[i].name);
|
||||
break;
|
||||
}
|
||||
}
|
||||
if (i == OSSL_NELEM(skf_cipher_caps)) {
|
||||
printf("(unknown)\n");
|
||||
}
|
||||
print_int(" Total Sapce ", devInfo->TotalSpace);
|
||||
print_int(" Free Space ", devInfo->FreeSpace);
|
||||
print_int(" MAX ECC Input", devInfo->MaxECCBufferSize);
|
||||
print_int(" MAX Cipher Input", devInfo->MaxBufferSize);
|
||||
|
||||
return SAR_OK;
|
||||
}
|
||||
|
||||
ULONG SKF_PrintRSAPublicKey(RSAPUBLICKEYBLOB *blob)
|
||||
{
|
||||
print_str("AlgID", skf_algor_name(blob->AlgID));
|
||||
print_int("BitLen", blob->BitLen);
|
||||
print_buf("Modulus", blob->Modulus, MAX_RSA_MODULUS_LEN);
|
||||
print_buf("PublicExponent", blob->PublicExponent, MAX_RSA_EXPONENT_LEN);
|
||||
return SAR_OK;
|
||||
}
|
||||
|
||||
ULONG SKF_PrintRSAPrivateKey(RSAPRIVATEKEYBLOB *blob)
|
||||
{
|
||||
print_str("AlgID", skf_algor_name(blob->AlgID));
|
||||
print_int("BitLen", blob->BitLen);
|
||||
print_buf("Modulus", blob->Modulus, MAX_RSA_MODULUS_LEN);
|
||||
print_buf("PublicExponent", blob->PublicExponent, MAX_RSA_EXPONENT_LEN);
|
||||
print_buf("PrivateExponent", blob->PrivateExponent, MAX_RSA_MODULUS_LEN);
|
||||
print_buf("Prime1", blob->Prime1, MAX_RSA_MODULUS_LEN/2);
|
||||
print_buf("Prime2", blob->Prime2, MAX_RSA_MODULUS_LEN/2);
|
||||
print_buf("Prime1Exponent", blob->Prime1Exponent, MAX_RSA_MODULUS_LEN/2);
|
||||
print_buf("Prime2Exponent", blob->Prime2Exponent, MAX_RSA_MODULUS_LEN/2);
|
||||
print_buf("Coefficient", blob->Coefficient, MAX_RSA_MODULUS_LEN/2);
|
||||
return SAR_OK;
|
||||
}
|
||||
|
||||
ULONG SKF_PrintECCPublicKey(ECCPUBLICKEYBLOB *blob)
|
||||
{
|
||||
print_int("BitLen", blob->BitLen);
|
||||
print_buf("XCoordinate", blob->XCoordinate, ECC_MAX_XCOORDINATE_BITS_LEN/8);
|
||||
print_buf("YCoordinate", blob->YCoordinate, ECC_MAX_XCOORDINATE_BITS_LEN/8);
|
||||
return SAR_OK;
|
||||
}
|
||||
|
||||
ULONG SKF_PrintECCPrivateKey(ECCPRIVATEKEYBLOB *blob)
|
||||
{
|
||||
print_int("BitLen", blob->BitLen);
|
||||
print_buf("PrivateKey", blob->PrivateKey, ECC_MAX_MODULUS_BITS_LEN/8);
|
||||
return SAR_OK;
|
||||
}
|
||||
|
||||
ULONG SKF_PrintECCCipher(ECCCIPHERBLOB *blob)
|
||||
{
|
||||
print_buf("XCoordinate", blob->XCoordinate, ECC_MAX_XCOORDINATE_BITS_LEN/8);
|
||||
print_buf("YCoordinate", blob->YCoordinate, ECC_MAX_XCOORDINATE_BITS_LEN/8);
|
||||
print_buf("HASH", blob->HASH, 32);
|
||||
print_int("CipherLen", blob->CipherLen);
|
||||
print_buf("Cipher", blob->Cipher, blob->CipherLen);
|
||||
return SAR_OK;
|
||||
}
|
||||
|
||||
ULONG SKF_PrintECCSignature(ECCSIGNATUREBLOB *blob)
|
||||
{
|
||||
print_buf("r", blob->r, ECC_MAX_XCOORDINATE_BITS_LEN/8);
|
||||
print_buf("s", blob->s, ECC_MAX_XCOORDINATE_BITS_LEN/8);
|
||||
return SAR_OK;
|
||||
}
|
||||
|
||||
ULONG DEVAPI SKF_NewECCCipher(ULONG ulCipherLen, ECCCIPHERBLOB **cipherBlob)
|
||||
{
|
||||
ECCCIPHERBLOB *ret = NULL;
|
||||
|
||||
if (!(ret = OPENSSL_malloc(sizeof(ECCCIPHERBLOB) - 1 + ulCipherLen))) {
|
||||
SKFerr(SKF_F_SKF_NEWECCCIPHER, ERR_R_MALLOC_FAILURE);
|
||||
return SAR_MEMORYERR;
|
||||
}
|
||||
|
||||
ret->CipherLen = ulCipherLen;
|
||||
*cipherBlob = ret;
|
||||
return SAR_OK;
|
||||
}
|
||||
|
||||
ULONG DEVAPI SKF_NewEnvelopedKey(ULONG ulCipherLen, ENVELOPEDKEYBLOB **envelopedKeyBlob)
|
||||
{
|
||||
ENVELOPEDKEYBLOB *ret = NULL;
|
||||
|
||||
if (!(ret = OPENSSL_zalloc(sizeof(ENVELOPEDKEYBLOB) - 1 + ulCipherLen))) {
|
||||
SKFerr(SKF_F_SKF_NEWENVELOPEDKEY, ERR_R_MALLOC_FAILURE);
|
||||
return SAR_MEMORYERR;
|
||||
}
|
||||
|
||||
ret->ECCCipherBlob.CipherLen = ulCipherLen;
|
||||
*envelopedKeyBlob = ret;
|
||||
return SAR_OK;
|
||||
}
|
||||
|
||||
ULONG DEVAPI SKF_PrintErrorString(ULONG ulError)
|
||||
{
|
||||
LPSTR str = NULL;
|
||||
SKF_GetErrorString(ulError, &str);
|
||||
printf("SKF Error: %s\n", (char *)str);
|
||||
return SAR_OK;
|
||||
}
|
||||
|
||||
ULONG DEVAPI SKF_GetAlgorName(ULONG ulAlgID, LPSTR *szName)
|
||||
{
|
||||
return SAR_OK;
|
||||
}
|
||||
4199
crypto/skf/skf_lib.c
4199
crypto/skf/skf_lib.c
File diff suppressed because it is too large
Load Diff
@@ -48,107 +48,123 @@
|
||||
*/
|
||||
|
||||
#include <openssl/err.h>
|
||||
#include <openssl/gmskf.h>
|
||||
#include "internal/dso.h"
|
||||
#include "internal/skf_meth.h"
|
||||
#include "internal/skf_int.h"
|
||||
|
||||
|
||||
#define SKF_METHOD_BIND_FUNCTION_EX(func,name) \
|
||||
skf->func = (SKF_##func##_FuncPtr)DSO_bind_func(skf->dso, "SKF_"#name)
|
||||
|
||||
#define SKF_METHOD_BIND_FUNCTION(func) \
|
||||
SKF_METHOD_BIND_FUNCTION_EX(func,func)
|
||||
|
||||
|
||||
SKF_METHOD *SKF_METHOD_load_library(const char *so_path)
|
||||
{
|
||||
SKF_METHOD *ret = NULL;
|
||||
SKF_METHOD *skf = NULL;
|
||||
DSO *dso = NULL;
|
||||
|
||||
if (!(dso = DSO_load(NULL, so_path, NULL, 0))) {
|
||||
goto end;
|
||||
}
|
||||
if (!(skf = OPENSSL_zalloc(sizeof(*skf)))) {
|
||||
SKFerr(SKF_F_SKF_METHOD_LOAD_LIBRARY, ERR_R_MALLOC_FAILURE);
|
||||
goto end;
|
||||
}
|
||||
if (!(skf->dso = DSO_load(NULL, so_path, NULL, 0))) {
|
||||
SKFerr(SKF_F_SKF_METHOD_LOAD_LIBRARY, SKF_R_DSO_LOAD_FAILURE);
|
||||
goto end;
|
||||
}
|
||||
|
||||
skf->WaitForDevEvent = (SKF_WaitForDevEvent_FuncPtr)DSO_bind_func(dso, "SKF_WaitForDevEvent");
|
||||
skf->CancelWaitForDevEvent = (SKF_CancelWaitForDevEvent_FuncPtr)DSO_bind_func(dso, "SKF_CancelWaitForDevEvent");
|
||||
skf->EnumDev = (SKF_EnumDev_FuncPtr)DSO_bind_func(dso, "SKF_EnumDev");
|
||||
skf->ConnectDev = (SKF_ConnectDev_FuncPtr)DSO_bind_func(dso, "SKF_ConnectDev");
|
||||
skf->DisConnectDev = (SKF_DisConnectDev_FuncPtr)DSO_bind_func(dso, "SKF_DisConnectDev");
|
||||
skf->GetDevState = (SKF_GetDevState_FuncPtr)DSO_bind_func(dso, "SKF_GetDevState");
|
||||
skf->SetLabel = (SKF_SetLabel_FuncPtr)DSO_bind_func(dso, "SKF_SetLabel");
|
||||
skf->GetDevInfo = (SKF_GetDevInfo_FuncPtr)DSO_bind_func(dso, "SKF_GetDevInfo");
|
||||
skf->LockDev = (SKF_LockDev_FuncPtr)DSO_bind_func(dso, "SKF_LockDev");
|
||||
skf->UnlockDev = (SKF_UnlockDev_FuncPtr)DSO_bind_func(dso, "SKF_UnlockDev");
|
||||
skf->Transmit = (SKF_Transmit_FuncPtr)DSO_bind_func(dso, "SKF_Transmit");
|
||||
skf->ChangeDevAuthKey = (SKF_ChangeDevAuthKey_FuncPtr)DSO_bind_func(dso, "SKF_ChangeDevAuthKey");
|
||||
skf->DevAuth = (SKF_DevAuth_FuncPtr)DSO_bind_func(dso, "SKF_DevAuth");
|
||||
skf->ChangePIN = (SKF_ChangePIN_FuncPtr)DSO_bind_func(dso, "SKF_ChangePIN");
|
||||
skf->GetPINInfo = (SKF_GetPINInfo_FuncPtr)DSO_bind_func(dso, "SKF_GetPINInfo");
|
||||
skf->VerifyPIN = (SKF_VerifyPIN_FuncPtr)DSO_bind_func(dso, "SKF_VerifyPIN");
|
||||
skf->UnblockPIN = (SKF_UnblockPIN_FuncPtr)DSO_bind_func(dso, "SKF_UnblockPIN");
|
||||
skf->ClearSecureState = (SKF_ClearSecureState_FuncPtr)DSO_bind_func(dso, "SKF_ClearSecureState");
|
||||
skf->CreateApplication = (SKF_CreateApplication_FuncPtr)DSO_bind_func(dso, "SKF_CreateApplication");
|
||||
skf->EnumApplication = (SKF_EnumApplication_FuncPtr)DSO_bind_func(dso, "SKF_EnumApplication");
|
||||
skf->DeleteApplication = (SKF_DeleteApplication_FuncPtr)DSO_bind_func(dso, "SKF_DeleteApplication");
|
||||
skf->OpenApplication = (SKF_OpenApplication_FuncPtr)DSO_bind_func(dso, "SKF_OpenApplication");
|
||||
skf->CloseApplication = (SKF_CloseApplication_FuncPtr)DSO_bind_func(dso, "SKF_CloseApplication");
|
||||
skf->CreateFileObject = (SKF_CreateFile_FuncPtr)DSO_bind_func(dso, "SKF_CreateFile");
|
||||
skf->DeleteFileObject = (SKF_DeleteFile_FuncPtr)DSO_bind_func(dso, "SKF_DeleteFile");
|
||||
skf->EnumFiles = (SKF_EnumFiles_FuncPtr)DSO_bind_func(dso, "SKF_EnumFiles");
|
||||
skf->GetFileInfo = (SKF_GetFileInfo_FuncPtr)DSO_bind_func(dso, "SKF_GetFileInfo");
|
||||
skf->ReadFileObject = (SKF_ReadFile_FuncPtr)DSO_bind_func(dso, "SKF_ReadFile");
|
||||
skf->WriteFileObject = (SKF_WriteFile_FuncPtr)DSO_bind_func(dso, "SKF_WriteFile");
|
||||
skf->CreateContainer = (SKF_CreateContainer_FuncPtr)DSO_bind_func(dso, "SKF_CreateContainer");
|
||||
skf->DeleteContainer = (SKF_DeleteContainer_FuncPtr)DSO_bind_func(dso, "SKF_DeleteContainer");
|
||||
skf->EnumContainer = (SKF_EnumContainer_FuncPtr)DSO_bind_func(dso, "SKF_EnumContainer");
|
||||
skf->OpenContainer = (SKF_OpenContainer_FuncPtr)DSO_bind_func(dso, "SKF_OpenContainer");
|
||||
skf->CloseContainer = (SKF_CloseContainer_FuncPtr)DSO_bind_func(dso, "SKF_CloseContainer");
|
||||
skf->GetContainerType = (SKF_GetContainerType_FuncPtr)DSO_bind_func(dso, "SKF_GetContainerType");
|
||||
skf->ImportCertificate = (SKF_ImportCertificate_FuncPtr)DSO_bind_func(dso, "SKF_ImportCertificate");
|
||||
skf->ExportCertificate = (SKF_ExportCertificate_FuncPtr)DSO_bind_func(dso, "SKF_ExportCertificate");
|
||||
skf->ExportPublicKey = (SKF_ExportPublicKey_FuncPtr)DSO_bind_func(dso, "SKF_ExportPublicKey");
|
||||
skf->GenRandom = (SKF_GenRandom_FuncPtr)DSO_bind_func(dso, "SKF_GenRandom");
|
||||
skf->GenExtRSAKey = (SKF_GenExtRSAKey_FuncPtr)DSO_bind_func(dso, "SKF_GenExtRSAKey");
|
||||
skf->GenRSAKeyPair = (SKF_GenRSAKeyPair_FuncPtr)DSO_bind_func(dso, "SKF_GenRSAKeyPair");
|
||||
skf->ImportRSAKeyPair = (SKF_ImportRSAKeyPair_FuncPtr)DSO_bind_func(dso, "SKF_ImportRSAKeyPair");
|
||||
skf->RSASignData = (SKF_RSASignData_FuncPtr)DSO_bind_func(dso, "SKF_RSASignData");
|
||||
skf->RSAVerify = (SKF_RSAVerify_FuncPtr)DSO_bind_func(dso, "SKF_RSAVerify");
|
||||
skf->RSAExportSessionKey = (SKF_RSAExportSessionKey_FuncPtr)DSO_bind_func(dso, "SKF_RSAExportSessionKey");
|
||||
skf->ExtRSAPubKeyOperation = (SKF_ExtRSAPubKeyOperation_FuncPtr)DSO_bind_func(dso, "SKF_ExtRSAPubKeyOperation");
|
||||
skf->ExtRSAPriKeyOperation = (SKF_ExtRSAPriKeyOperation_FuncPtr)DSO_bind_func(dso, "SKF_ExtRSAPriKeyOperation");
|
||||
skf->GenECCKeyPair = (SKF_GenECCKeyPair_FuncPtr)DSO_bind_func(dso, "SKF_GenECCKeyPair");
|
||||
skf->ImportECCKeyPair = (SKF_ImportECCKeyPair_FuncPtr)DSO_bind_func(dso, "SKF_ImportECCKeyPair");
|
||||
skf->ECCSignData = (SKF_ECCSignData_FuncPtr)DSO_bind_func(dso, "SKF_ECCSignData");
|
||||
skf->ECCVerify = (SKF_ECCVerify_FuncPtr)DSO_bind_func(dso, "SKF_ECCVerify");
|
||||
skf->ECCExportSessionKey = (SKF_ECCExportSessionKey_FuncPtr)DSO_bind_func(dso, "SKF_ECCExportSessionKey");
|
||||
skf->ExtECCEncrypt = (SKF_ExtECCEncrypt_FuncPtr)DSO_bind_func(dso, "SKF_ExtECCEncrypt");
|
||||
skf->ExtECCDecrypt = (SKF_ExtECCDecrypt_FuncPtr)DSO_bind_func(dso, "SKF_ExtECCDecrypt");
|
||||
skf->ExtECCSign = (SKF_ExtECCSign_FuncPtr)DSO_bind_func(dso, "SKF_ExtECCSign");
|
||||
skf->ExtECCVerify = (SKF_ExtECCVerify_FuncPtr)DSO_bind_func(dso, "SKF_ExtECCVerify");
|
||||
skf->GenerateAgreementDataWithECC = (SKF_GenerateAgreementDataWithECC_FuncPtr)DSO_bind_func(dso, "SKF_GenerateAgreementDataWithECC");
|
||||
skf->GenerateAgreementDataAndKeyWithECC = (SKF_GenerateAgreementDataAndKeyWithECC_FuncPtr)DSO_bind_func(dso, "SKF_GenerateAgreementDataAndKeyWithECC");
|
||||
skf->GenerateKeyWithECC = (SKF_GenerateKeyWithECC_FuncPtr)DSO_bind_func(dso, "SKF_GenerateKeyWithECC");
|
||||
skf->ImportSessionKey = (SKF_ImportSessionKey_FuncPtr)DSO_bind_func(dso, "SKF_ImportSessionKey");
|
||||
skf->SetSymmKey = (SKF_SetSymmKey_FuncPtr)DSO_bind_func(dso, "SKF_SetSymmKey");
|
||||
skf->EncryptInit = (SKF_EncryptInit_FuncPtr)DSO_bind_func(dso, "SKF_EncryptInit");
|
||||
skf->Encrypt = (SKF_Encrypt_FuncPtr)DSO_bind_func(dso, "SKF_Encrypt");
|
||||
skf->EncryptUpdate = (SKF_EncryptUpdate_FuncPtr)DSO_bind_func(dso, "SKF_EncryptUpdate");
|
||||
skf->EncryptFinal = (SKF_EncryptFinal_FuncPtr)DSO_bind_func(dso, "SKF_EncryptFinal");
|
||||
skf->DecryptInit = (SKF_DecryptInit_FuncPtr)DSO_bind_func(dso, "SKF_DecryptInit");
|
||||
skf->Decrypt = (SKF_Decrypt_FuncPtr)DSO_bind_func(dso, "SKF_Decrypt");
|
||||
skf->DecryptUpdate = (SKF_DecryptUpdate_FuncPtr)DSO_bind_func(dso, "SKF_DecryptUpdate");
|
||||
skf->DecryptFinal = (SKF_DecryptFinal_FuncPtr)DSO_bind_func(dso, "SKF_DecryptFinal");
|
||||
skf->DigestInit = (SKF_DigestInit_FuncPtr)DSO_bind_func(dso, "SKF_DigestInit");
|
||||
skf->Digest = (SKF_Digest_FuncPtr)DSO_bind_func(dso, "SKF_Digest");
|
||||
skf->DigestUpdate = (SKF_DigestUpdate_FuncPtr)DSO_bind_func(dso, "SKF_DigestUpdate");
|
||||
skf->DigestFinal = (SKF_DigestFinal_FuncPtr)DSO_bind_func(dso, "SKF_DigestFinal");
|
||||
skf->MacInit = (SKF_MacInit_FuncPtr)DSO_bind_func(dso, "SKF_MacInit");
|
||||
skf->Mac = (SKF_Mac_FuncPtr)DSO_bind_func(dso, "SKF_Mac");
|
||||
skf->MacUpdate = (SKF_MacUpdate_FuncPtr)DSO_bind_func(dso, "SKF_MacUpdate");
|
||||
skf->MacFinal = (SKF_MacFinal_FuncPtr)DSO_bind_func(dso, "SKF_MacFinal");
|
||||
skf->CloseHandle = (SKF_CloseHandle_FuncPtr)DSO_bind_func(dso, "SKF_CloseHandle");
|
||||
SKF_METHOD_BIND_FUNCTION(WaitForDevEvent);
|
||||
SKF_METHOD_BIND_FUNCTION(CancelWaitForDevEvent);
|
||||
SKF_METHOD_BIND_FUNCTION(EnumDev);
|
||||
SKF_METHOD_BIND_FUNCTION(ConnectDev);
|
||||
SKF_METHOD_BIND_FUNCTION(DisConnectDev);
|
||||
SKF_METHOD_BIND_FUNCTION(GetDevState);
|
||||
SKF_METHOD_BIND_FUNCTION(SetLabel);
|
||||
SKF_METHOD_BIND_FUNCTION(GetDevInfo);
|
||||
SKF_METHOD_BIND_FUNCTION(LockDev);
|
||||
SKF_METHOD_BIND_FUNCTION(UnlockDev);
|
||||
SKF_METHOD_BIND_FUNCTION(Transmit);
|
||||
SKF_METHOD_BIND_FUNCTION(ChangeDevAuthKey);
|
||||
SKF_METHOD_BIND_FUNCTION(DevAuth);
|
||||
SKF_METHOD_BIND_FUNCTION(ChangePIN);
|
||||
SKF_METHOD_BIND_FUNCTION(GetPINInfo);
|
||||
SKF_METHOD_BIND_FUNCTION(VerifyPIN);
|
||||
SKF_METHOD_BIND_FUNCTION(UnblockPIN);
|
||||
SKF_METHOD_BIND_FUNCTION(ClearSecureState);
|
||||
SKF_METHOD_BIND_FUNCTION(CreateApplication);
|
||||
SKF_METHOD_BIND_FUNCTION(EnumApplication);
|
||||
SKF_METHOD_BIND_FUNCTION(DeleteApplication);
|
||||
SKF_METHOD_BIND_FUNCTION(OpenApplication);
|
||||
SKF_METHOD_BIND_FUNCTION(CloseApplication);
|
||||
SKF_METHOD_BIND_FUNCTION_EX(CreateObject,CreateFile);
|
||||
SKF_METHOD_BIND_FUNCTION_EX(DeleteObject,DeleteFile);
|
||||
SKF_METHOD_BIND_FUNCTION_EX(EnumObjects,EnumFiles);
|
||||
SKF_METHOD_BIND_FUNCTION_EX(GetObjectInfo,GetFileInfo);
|
||||
SKF_METHOD_BIND_FUNCTION_EX(ReadObject,ReadFile);
|
||||
SKF_METHOD_BIND_FUNCTION_EX(WriteObject,WriteFile);
|
||||
SKF_METHOD_BIND_FUNCTION(CreateContainer);
|
||||
SKF_METHOD_BIND_FUNCTION(DeleteContainer);
|
||||
SKF_METHOD_BIND_FUNCTION(EnumContainer);
|
||||
SKF_METHOD_BIND_FUNCTION(OpenContainer);
|
||||
SKF_METHOD_BIND_FUNCTION(CloseContainer);
|
||||
SKF_METHOD_BIND_FUNCTION(GetContainerType);
|
||||
SKF_METHOD_BIND_FUNCTION(ImportCertificate);
|
||||
SKF_METHOD_BIND_FUNCTION(ExportCertificate);
|
||||
SKF_METHOD_BIND_FUNCTION(ExportPublicKey);
|
||||
SKF_METHOD_BIND_FUNCTION(GenRandom);
|
||||
SKF_METHOD_BIND_FUNCTION(GenExtRSAKey);
|
||||
SKF_METHOD_BIND_FUNCTION(GenRSAKeyPair);
|
||||
SKF_METHOD_BIND_FUNCTION(ImportRSAKeyPair);
|
||||
SKF_METHOD_BIND_FUNCTION(RSASignData);
|
||||
SKF_METHOD_BIND_FUNCTION(RSAVerify);
|
||||
SKF_METHOD_BIND_FUNCTION(RSAExportSessionKey);
|
||||
SKF_METHOD_BIND_FUNCTION(ExtRSAPubKeyOperation);
|
||||
SKF_METHOD_BIND_FUNCTION(ExtRSAPriKeyOperation);
|
||||
SKF_METHOD_BIND_FUNCTION(GenECCKeyPair);
|
||||
SKF_METHOD_BIND_FUNCTION(ImportECCKeyPair);
|
||||
SKF_METHOD_BIND_FUNCTION(ECCSignData);
|
||||
SKF_METHOD_BIND_FUNCTION(ECCVerify);
|
||||
SKF_METHOD_BIND_FUNCTION(ECCExportSessionKey);
|
||||
SKF_METHOD_BIND_FUNCTION(ExtECCEncrypt);
|
||||
SKF_METHOD_BIND_FUNCTION(ExtECCDecrypt);
|
||||
SKF_METHOD_BIND_FUNCTION(ECCDecrypt);
|
||||
SKF_METHOD_BIND_FUNCTION(ExtECCSign);
|
||||
SKF_METHOD_BIND_FUNCTION(ExtECCVerify);
|
||||
SKF_METHOD_BIND_FUNCTION(GenerateAgreementDataWithECC);
|
||||
SKF_METHOD_BIND_FUNCTION(GenerateAgreementDataAndKeyWithECC);
|
||||
SKF_METHOD_BIND_FUNCTION(GenerateKeyWithECC);
|
||||
SKF_METHOD_BIND_FUNCTION(ImportSessionKey);
|
||||
SKF_METHOD_BIND_FUNCTION(SetSymmKey);
|
||||
SKF_METHOD_BIND_FUNCTION(EncryptInit);
|
||||
SKF_METHOD_BIND_FUNCTION(Encrypt);
|
||||
SKF_METHOD_BIND_FUNCTION(EncryptUpdate);
|
||||
SKF_METHOD_BIND_FUNCTION(EncryptFinal);
|
||||
SKF_METHOD_BIND_FUNCTION(DecryptInit);
|
||||
SKF_METHOD_BIND_FUNCTION(Decrypt);
|
||||
SKF_METHOD_BIND_FUNCTION(DecryptUpdate);
|
||||
SKF_METHOD_BIND_FUNCTION(DecryptFinal);
|
||||
SKF_METHOD_BIND_FUNCTION(DigestInit);
|
||||
SKF_METHOD_BIND_FUNCTION(Digest);
|
||||
SKF_METHOD_BIND_FUNCTION(DigestUpdate);
|
||||
SKF_METHOD_BIND_FUNCTION(DigestFinal);
|
||||
SKF_METHOD_BIND_FUNCTION(MacInit);
|
||||
SKF_METHOD_BIND_FUNCTION(Mac);
|
||||
SKF_METHOD_BIND_FUNCTION(MacUpdate);
|
||||
SKF_METHOD_BIND_FUNCTION(MacFinal);
|
||||
SKF_METHOD_BIND_FUNCTION(CloseHandle);
|
||||
|
||||
ret = skf;
|
||||
skf = NULL;
|
||||
|
||||
end:
|
||||
OPENSSL_free(skf);
|
||||
DSO_free(dso);
|
||||
SKF_METHOD_free(skf);
|
||||
return ret;
|
||||
}
|
||||
|
||||
void SKF_METHOD_free(SKF_METHOD *meth)
|
||||
{
|
||||
if (meth)
|
||||
DSO_free(meth->dso);
|
||||
OPENSSL_free(meth);
|
||||
}
|
||||
|
||||
200
crypto/skf/skf_wisec.c
Normal file
200
crypto/skf/skf_wisec.c
Normal file
@@ -0,0 +1,200 @@
|
||||
/* ====================================================================
|
||||
* Copyright (c) 2016 - 2017 The GmSSL Project. All rights reserved.
|
||||
*
|
||||
* Redistribution and use in source and binary forms, with or without
|
||||
* modification, are permitted provided that the following conditions
|
||||
* are met:
|
||||
*
|
||||
* 1. Redistributions of source code must retain the above copyright
|
||||
* notice, this list of conditions and the following disclaimer.
|
||||
*
|
||||
* 2. Redistributions in binary form must reproduce the above copyright
|
||||
* notice, this list of conditions and the following disclaimer in
|
||||
* the documentation and/or other materials provided with the
|
||||
* distribution.
|
||||
*
|
||||
* 3. All advertising materials mentioning features or use of this
|
||||
* software must display the following acknowledgment:
|
||||
* "This product includes software developed by the GmSSL Project.
|
||||
* (http://gmssl.org/)"
|
||||
*
|
||||
* 4. The name "GmSSL Project" must not be used to endorse or promote
|
||||
* products derived from this software without prior written
|
||||
* permission. For written permission, please contact
|
||||
* guanzhi1980@gmail.com.
|
||||
*
|
||||
* 5. Products derived from this software may not be called "GmSSL"
|
||||
* nor may "GmSSL" appear in their names without prior written
|
||||
* permission of the GmSSL Project.
|
||||
*
|
||||
* 6. Redistributions of any form whatsoever must retain the following
|
||||
* acknowledgment:
|
||||
* "This product includes software developed by the GmSSL Project
|
||||
* (http://gmssl.org/)"
|
||||
*
|
||||
* THIS SOFTWARE IS PROVIDED BY THE GmSSL PROJECT ``AS IS'' AND ANY
|
||||
* EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
|
||||
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
|
||||
* PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE GmSSL PROJECT OR
|
||||
* ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
|
||||
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
|
||||
* NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
|
||||
* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
|
||||
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
|
||||
* STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
|
||||
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
|
||||
* OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
* ====================================================================
|
||||
*/
|
||||
|
||||
#include <openssl/err.h>
|
||||
#include <openssl/gmskf.h>
|
||||
#include "internal/skf_int.h"
|
||||
#include "../../e_os.h"
|
||||
#include "skf_wisec.h"
|
||||
|
||||
typedef struct {
|
||||
ULONG std_id;
|
||||
ULONG vendor_id;
|
||||
} SKF_ALGOR_PAIR;
|
||||
|
||||
static SKF_ALGOR_PAIR wisec_ciphers[] = {
|
||||
{ SGD_SM1, WISEC_SM1 },
|
||||
{ SGD_SM1_ECB, WISEC_SM1_ECB },
|
||||
{ SGD_SM1_CBC, WISEC_SM1_CBC },
|
||||
{ SGD_SM1_CFB, WISEC_SM1_CFB },
|
||||
{ SGD_SM1_OFB, WISEC_SM1_OFB },
|
||||
{ SGD_SM1_MAC, WISEC_SM1_MAC },
|
||||
{ SGD_SM4, WISEC_SM4 },
|
||||
{ SGD_SM4_ECB, WISEC_SM4_ECB },
|
||||
{ SGD_SM4_CBC, WISEC_SM4_CBC },
|
||||
{ SGD_SM4_CFB, WISEC_SM4_CFB },
|
||||
{ SGD_SM4_OFB, WISEC_SM4_OFB },
|
||||
{ SGD_SM4_MAC, WISEC_SM4_MAC },
|
||||
{ SGD_SSF33, WISEC_SSF33 },
|
||||
{ SGD_SSF33_ECB, WISEC_SSF33_ECB },
|
||||
{ SGD_SSF33_CBC, WISEC_SSF33_CBC },
|
||||
{ SGD_SSF33_CFB, WISEC_SSF33_CFB },
|
||||
{ SGD_SSF33_OFB, WISEC_SSF33_OFB },
|
||||
{ SGD_SSF33_MAC, WISEC_SSF33_MAC },
|
||||
};
|
||||
|
||||
static ULONG wisec_get_cipher_algor(ULONG vendor_id)
|
||||
{
|
||||
int i;
|
||||
for (i = 0; i < OSSL_NELEM(wisec_ciphers); i++) {
|
||||
if (vendor_id == wisec_ciphers[i].vendor_id) {
|
||||
return wisec_ciphers[i].std_id;
|
||||
}
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
static ULONG wisec_get_cipher_cap(ULONG vendor_cap)
|
||||
{
|
||||
ULONG std_cap = 0;
|
||||
int i;
|
||||
for (i = 0; i < OSSL_NELEM(wisec_ciphers); i++) {
|
||||
if (vendor_cap & wisec_ciphers[i].vendor_id) {
|
||||
std_cap |= wisec_ciphers[i].std_id;
|
||||
}
|
||||
}
|
||||
return std_cap;
|
||||
}
|
||||
|
||||
static SKF_ALGOR_PAIR wisec_digests[] = {
|
||||
{ SGD_SM3, WISEC_SM3 },
|
||||
{ SGD_SHA1, WISEC_SHA1 },
|
||||
{ SGD_SHA256, WISEC_SHA256 },
|
||||
};
|
||||
|
||||
static ULONG wisec_get_digest_algor(ULONG vendor_id)
|
||||
{
|
||||
int i;
|
||||
for (i = 0; i < OSSL_NELEM(wisec_digests); i++) {
|
||||
if (vendor_id == wisec_digests[i].vendor_id) {
|
||||
return wisec_digests[i].std_id;
|
||||
}
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
static ULONG wisec_get_digest_cap(ULONG vendor_cap)
|
||||
{
|
||||
ULONG std_cap = 0;
|
||||
int i;
|
||||
for (i = 0; i < OSSL_NELEM(wisec_digests); i++) {
|
||||
if (vendor_cap & wisec_digests[i].vendor_id) {
|
||||
std_cap |= wisec_digests[i].std_id;
|
||||
}
|
||||
}
|
||||
return std_cap;
|
||||
}
|
||||
|
||||
static SKF_ALGOR_PAIR wisec_pkeys[] = {
|
||||
{ SGD_RSA, WISEC_RSA },
|
||||
{ SGD_RSA_SIGN, WISEC_RSA_SIGN },
|
||||
{ SGD_RSA_ENC, WISEC_RSA_ENC },
|
||||
{ SGD_SM2, WISEC_SM2 },
|
||||
{ SGD_SM2_1, WISEC_SM2_1 },
|
||||
{ SGD_SM2_2, WISEC_SM2_2 },
|
||||
{ SGD_SM2_3, WISEC_SM2_3 },
|
||||
};
|
||||
|
||||
static ULONG wisec_get_pkey_algor(ULONG vendor_id)
|
||||
{
|
||||
int i;
|
||||
for (i = 0; i < OSSL_NELEM(wisec_pkeys); i++) {
|
||||
if (vendor_id == wisec_pkeys[i].vendor_id) {
|
||||
return wisec_pkeys[i].std_id;
|
||||
}
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
static ULONG wisec_get_pkey_cap(ULONG vendor_cap)
|
||||
{
|
||||
ULONG std_cap = 0;
|
||||
int i;
|
||||
for (i = 0; i < OSSL_NELEM(wisec_pkeys); i++) {
|
||||
if (vendor_cap & wisec_pkeys[i].vendor_id) {
|
||||
std_cap |= wisec_pkeys[i].std_id;
|
||||
}
|
||||
}
|
||||
return std_cap;
|
||||
}
|
||||
|
||||
static SKF_ERR_REASON wisec_errors[] = {
|
||||
{ WISEC_AUTH_BLOCKED, SKF_R_WISEC_AUTH_BLOCKED },
|
||||
{ WISEC_CERTNOUSAGEERR, SKF_R_WISEC_CERTNOUSAGEERR },
|
||||
{ WISEC_INVALIDCONTAINERERR, SKF_R_WISEC_INVALIDCONTAINERERR },
|
||||
{ WISEC_CONTAINER_NOT_EXISTS, SKF_R_WISEC_CONTAINER_NOT_EXISTS },
|
||||
{ WISEC_CONTAINER_EXISTS, SKF_R_WISEC_CONTAINER_EXISTS },
|
||||
{ WISEC_CERTUSAGEERR, SKF_R_WISEC_CERTUSAGEERR },
|
||||
{ WISEC_KEYNOUSAGEERR, SKF_R_WISEC_KEYNOUSAGEERR },
|
||||
{ WISEC_FILEATTRIBUTEERR, SKF_R_WISEC_FILEATTRIBUTEERR },
|
||||
{ WISEC_DEVNOAUTH, SKF_R_WISEC_DEVNOAUTH },
|
||||
};
|
||||
|
||||
static unsigned long wisec_get_error_reason(ULONG err)
|
||||
{
|
||||
int i = 0;
|
||||
for (i = 0; i < OSSL_NELEM(wisec_errors); i++) {
|
||||
if (err == wisec_errors[i].err) {
|
||||
return wisec_errors[i].reason;
|
||||
}
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
SKF_VENDOR skf_wisec = {
|
||||
"wisec",
|
||||
16,
|
||||
wisec_get_cipher_algor,
|
||||
wisec_get_cipher_cap,
|
||||
wisec_get_digest_algor,
|
||||
wisec_get_digest_cap,
|
||||
wisec_get_pkey_algor,
|
||||
wisec_get_pkey_cap,
|
||||
wisec_get_error_reason,
|
||||
};
|
||||
157
crypto/skf/skf_wisec.h
Normal file
157
crypto/skf/skf_wisec.h
Normal file
@@ -0,0 +1,157 @@
|
||||
/* ====================================================================
|
||||
* Copyright (c) 2016 - 2017 The GmSSL Project. All rights reserved.
|
||||
*
|
||||
* Redistribution and use in source and binary forms, with or without
|
||||
* modification, are permitted provided that the following conditions
|
||||
* are met:
|
||||
*
|
||||
* 1. Redistributions of source code must retain the above copyright
|
||||
* notice, this list of conditions and the following disclaimer.
|
||||
*
|
||||
* 2. Redistributions in binary form must reproduce the above copyright
|
||||
* notice, this list of conditions and the following disclaimer in
|
||||
* the documentation and/or other materials provided with the
|
||||
* distribution.
|
||||
*
|
||||
* 3. All advertising materials mentioning features or use of this
|
||||
* software must display the following acknowledgment:
|
||||
* "This product includes software developed by the GmSSL Project.
|
||||
* (http://gmssl.org/)"
|
||||
*
|
||||
* 4. The name "GmSSL Project" must not be used to endorse or promote
|
||||
* products derived from this software without prior written
|
||||
* permission. For written permission, please contact
|
||||
* guanzhi1980@gmail.com.
|
||||
*
|
||||
* 5. Products derived from this software may not be called "GmSSL"
|
||||
* nor may "GmSSL" appear in their names without prior written
|
||||
* permission of the GmSSL Project.
|
||||
*
|
||||
* 6. Redistributions of any form whatsoever must retain the following
|
||||
* acknowledgment:
|
||||
* "This product includes software developed by the GmSSL Project
|
||||
* (http://gmssl.org/)"
|
||||
*
|
||||
* THIS SOFTWARE IS PROVIDED BY THE GmSSL PROJECT ``AS IS'' AND ANY
|
||||
* EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
|
||||
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
|
||||
* PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE GmSSL PROJECT OR
|
||||
* ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
|
||||
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
|
||||
* NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
|
||||
* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
|
||||
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
|
||||
* STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
|
||||
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
|
||||
* OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
* ====================================================================
|
||||
*/
|
||||
|
||||
#ifndef HEADER_SKF_WISEC_H
|
||||
#define HEADER_SKF_WISEC_H
|
||||
|
||||
#include <openssl/err.h>
|
||||
#include <openssl/gmskf.h>
|
||||
|
||||
|
||||
#define WISEC_SM1 (SGD_SM1)
|
||||
#define WISEC_SM1_ECB (SGD_SM1_ECB)
|
||||
#define WISEC_SM1_CBC (SGD_SM1_CBC)
|
||||
#define WISEC_SM1_CFB (SGD_SM1_CFB)
|
||||
#define WISEC_SM1_OFB (SGD_SM1_OFB)
|
||||
#define WISEC_SM1_MAC (SGD_SM1_MAC)
|
||||
|
||||
#define WISEC_SSF33 (SGD_SSF33)
|
||||
#define WISEC_SSF33_ECB (SGD_SSF33_ECB)
|
||||
#define WISEC_SSF33_CBC (SGD_SSF33_CBC)
|
||||
#define WISEC_SSF33_CFB (SGD_SSF33_CFB)
|
||||
#define WISEC_SSF33_OFB (SGD_SSF33_OFB)
|
||||
#define WISEC_SSF33_MAC (SGD_SSF33_MAC)
|
||||
|
||||
#define WISEC_SM4 (SGD_SM4)
|
||||
#define WISEC_SM4_ECB (WISEC_SM4|SGD_ECB)
|
||||
#define WISEC_SM4_CBC (WISEC_SM4|SGD_CBC)
|
||||
#define WISEC_SM4_CFB (WISEC_SM4|SGD_CFB)
|
||||
#define WISEC_SM4_OFB (WISEC_SM4|SGD_OFB)
|
||||
#define WISEC_SM4_MAC (WISEC_SM4|SGD_MAC)
|
||||
|
||||
#define WISEC_AES 0x00000800
|
||||
#define WISEC_128 0x00000000
|
||||
#define WISEC_192 0x00000010
|
||||
#define WISEC_256 0x00000020
|
||||
#define WISEC_AES128 (WISEC_AES|WISEC_128)
|
||||
#define WISEC_AES192 (WISEC_AES|WISEC_192)
|
||||
#define WISEC_AES256 (WISEC_AES|WISEC_256)
|
||||
#define WISEC_AES128_ECB (WISEC_AES128|SGD_ECB)
|
||||
#define WISEC_AES128_CBC (WISEC_AES128|SGD_CBC)
|
||||
#define WISEC_AES128_CFB (WISEC_AES128|SGD_CFB)
|
||||
#define WISEC_AES128_OFB (WISEC_AES128|SGD_OFB)
|
||||
#define WISEC_AES128_MAC (WISEC_AES128|SGD_MAC)
|
||||
#define WISEC_AES192_ECB (WISEC_AES192|SGD_ECB)
|
||||
#define WISEC_AES192_CBC (WISEC_AES192|SGD_CBC)
|
||||
#define WISEC_AES192_CFB (WISEC_AES192|SGD_CFB)
|
||||
#define WISEC_AES192_OFB (WISEC_AES192|SGD_OFB)
|
||||
#define WISEC_AES192_MAC (WISEC_AES192|SGD_MAC)
|
||||
#define WISEC_AES256_ECB (WISEC_AES256|SGD_ECB)
|
||||
#define WISEC_AES256_CBC (WISEC_AES256|SGD_CBC)
|
||||
#define WISEC_AES256_CFB (WISEC_AES256|SGD_CFB)
|
||||
#define WISEC_AES256_OFB (WISEC_AES256|SGD_OFB)
|
||||
#define WISEC_AES256_MAC (WISEC_AES256|SGD_MAC)
|
||||
|
||||
#define WISEC_DES 0x00001000
|
||||
#define WISEC_DES_ECB (WISEC_DES|SGD_ECB)
|
||||
#define WISEC_DES_CBC (WISEC_DES|SGD_CBC)
|
||||
#define WISEC_DES_CFB (WISEC_DES|SGD_CFB)
|
||||
#define WISEC_DES_OFB (WISEC_DES|SGD_OFB)
|
||||
#define WISEC_DES_MAC (WISEC_DES|SGD_MAC)
|
||||
|
||||
#define WISEC_D3DES 0x00001010
|
||||
#define WISEC_D3DES_ECB (WISEC_D3DES|SGD_ECB)
|
||||
#define WISEC_D3DES_CBC (WISEC_D3DES|SGD_CBC)
|
||||
#define WISEC_D3DES_CFB (WISEC_D3DES|SGD_CFB)
|
||||
#define WISEC_D3DES_OFB (WISEC_D3DES|SGD_OFB)
|
||||
#define WISEC_D3DES_MAC (WISEC_D3DES|SGD_MAC)
|
||||
|
||||
#define WISEC_T3DES 0x00001020
|
||||
#define WISEC_T3DES_ECB (WISEC_T3DES|SGD_ECB)
|
||||
#define WISEC_T3DES_CBC (WISEC_T3DES|SGD_CBC)
|
||||
#define WISEC_T3DES_CFB (WISEC_T3DES|SGD_CFB)
|
||||
#define WISEC_T3DES_OFB (WISEC_T3DES|SGD_OFB)
|
||||
#define WISEC_T3DES_MAC (WISEC_T3DES|SGD_MAC)
|
||||
|
||||
#define WISEC_SM3 (SGD_SM3)
|
||||
#define WISEC_SHA1 (SGD_SHA1)
|
||||
#define WISEC_SHA256 (SGD_SHA256)
|
||||
|
||||
#define WISEC_RSA (SGD_RSA)
|
||||
#define WISEC_RSA_SIGN (SGD_RSA_SIGN)
|
||||
#define WISEC_RSA_ENC (SGD_RSA_ENC)
|
||||
#define WISEC_SM2 (SGD_SM2)
|
||||
#define WISEC_SM2_1 (SGD_SM2_1)
|
||||
#define WISEC_SM2_2 (SGD_SM2_2)
|
||||
#define WISEC_SM2_3 (SGD_SM2_3)
|
||||
|
||||
|
||||
#define WISEC_AUTH_BLOCKED 0x0A000033
|
||||
#define WISEC_CERTNOUSAGEERR 0x0A000034
|
||||
#define WISEC_INVALIDCONTAINERERR 0x0A000035
|
||||
#define WISEC_CONTAINER_NOT_EXISTS 0x0A000036
|
||||
#define WISEC_CONTAINER_EXISTS 0x0A000037
|
||||
#define WISEC_CERTUSAGEERR 0x0A000038
|
||||
#define WISEC_KEYNOUSAGEERR 0x0A000039
|
||||
#define WISEC_FILEATTRIBUTEERR 0x0A00003A
|
||||
#define WISEC_DEVNOAUTH 0x0A00003B
|
||||
|
||||
/*
|
||||
ULONG DEVAPI SKFE_SetSN(DEVHANDLE hDev, CHAR *SN, UINT SNLen);
|
||||
ULONG DEVAPI SKFE_GenExtECCKey(DEVHANDLE hDev, PECCPRIVATEKEYBLOB pPriBlob, PECCPUBLICKEYBLOB pPubBlob);
|
||||
ULONG DEVAPI SKF_ECCDecrypt(HCONTAINER hContainer, PECCCIPHERBLOB pCipherText, BYTE *pbPlainText,ULONG *pulPlainTextLen);
|
||||
ULONG DEVAPI SKF_GenerateKey(HCONTAINER hContainer, ULONG ulAlgId, HANDLE *phSessionKey) ;
|
||||
ULONG DEVAPI SKF_ECCExportSessionKeyByHandle(HANDLE phSessionKey, ECCPUBLICKEYBLOB *pPubKey,PECCCIPHERBLOB pData);
|
||||
ULONG DEVAPI SKF_RSAExportSessionKeyByHandle(HANDLE phSessionKey, RSAPUBLICKEYBLOB*pPubKey,BYTE *pbData, ULONG *pulDataLen);
|
||||
ULONG DEVAPI SKF_PrvKeyDecrypt(HCONTAINER hContainer, PECCCIPHERBLOB pCipherText, BYTE *pbData, ULONG *pbDataLen);
|
||||
ULONG DEVAPI SKF_PrvKeyDecrypt(HCONTAINER hContainer, ULONG ulType, PECCCIPHERBLOB pCipherText, BYTE *pbData, ULONG *pbDataLen);
|
||||
ULONG DEVAPI SKF_RSAPrvKeyDecrypt(HCONTAINER hContainer, BYTE *pCipherData, ULONG pCipherDataLen, BYTE *pbData, ULONG *pbDataLen);
|
||||
*/
|
||||
|
||||
#endif
|
||||
Reference in New Issue
Block a user