abc/GmSSL
1
0
Fork 0
mirror of https://github.com/guanzhi/GmSSL.git synced 2026-08-09 15:33:58 +08:00
Code Issues Packages Projects Releases Wiki Activity

start SKF engine

Browse Source
This commit is contained in:
Zhi Guan
2016-04-10 00:01:46 +02:00
parent 5cc6cfdf22
commit 70118dbcae
19 changed files with 778 additions and 234 deletions
Download Patch File Download Diff File Expand all files Collapse all files

406
engines/skf/e_skf.c
View File

@@ -1,406 +0,0 @@
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <openssl/evp.h>
#include <openssl/engine.h>
#include <openssl/obj_mac.h>
#include <openssl/objects.h>
#include <openssl/sm1.h>
#include <openssl/sm2.h>
#include <openssl/sm3.h>
#include <openssl/sms4.h>
#include <openssl/ssf33.h>
#include "skf.h"
#include "e_skf_err.h"
static DEVHANDLE skf_dev_handle = NULL;
static HAPPLICATION skf_app_handle = NULL;
static HCONTAINER skf_container_handle = NULL;
static int skf_init(ENGINE *e)
{
ULONG rv;
ULONG len;
/*
BOOL bPresent = TRUE;
CHAR *devNameList = NULL;
LPSTR devName;
ULONG devState;
DEVINFO devInfo;
BYTE authData[16];
CHAR appNameList[256];
LPSTR appName;
HAPPLICATION hApp;
CHAR containerNameList[256];
LPSTR containerName;
HCONTAINER hContainer;
ULONG containerType;
if ((rv = SKF_EnumDev(bPresent, NULL, &len)) != SAR_OK) {
return -1;
}
if (!(devNameList = OPENSSL_malloc(len))) {
return -1;
}
if ((rv = SKF_EnumDev(bPresent, devNameList, &len)) != SAR_OK) {
return -1;
}
if (devNameList[0] = 0) {
return -1;
}
devName = devNameList;
if ((rv = SKF_ConnectDev(devName, &hDev)) != SAR_OK) {
return -1;
}
if ((rv = SKF_GetDevInfo(hDev, &devInfo)) != SAR_OK) {
return -1;
}
if ((rv = SKF_DevAuth(hDev, authData, sizeof(authData))) != SAR_OK) {
return -1;
}
if ((rv = SKF_EnumApplication(hDev, NULL, &len)) != SAR_OK) {
return -1;
}
if (!(appNameList = OPENSSL_malloc(len))) {
return -1;
}
if ((rv = SKF_EnumApplication(hDev, appNameList, &len)) != SAR_OK) {
return -1;
}
if (appNameList[0] = 0) {
return -1;
}
appName = appNameList;
if ((rv = SKF_OpenApplication(hDev, appName, &hApp)) != SAR_OK) {
return -1;
}
for (p = containerNameList; p; p += strlen(p)) {
// check container type
}
*/
return 0;
}
static int skf_finish(ENGINE *e)
{
return 0;
}
#if 0
void ENGINE_load_skf(void)
{
}
static int skf_bind_helper(ENGINE *e)
{
if (!ENGINE_set_id(e, SKF_ENGINE_ID) ||
!ENGINE_set_name(e, SKF_ENGINE_NAME) ||
!ENGINE_set_init_function(e, skf_init) ||
!ENGINE_set_ciphers(e, skf_ciphers) ||
!ENGINE_set_RSA(e, SKF_get_rsa_method()) ||
!ENGINE_set_SM2(e, SKF_get_sm2_method()) ||
!ENGINE_set_RAND(e, skf_rand)) {
return 0;
}
return 1;
}
static ENGINE *ENGINE_skf(void)
{
ENGINE *eng = ENGINE_new();
if (!eng) {
return NULL;
}
if (!skf_bind_helper(eng)) {
ENGINE_free(eng);
return NULL;
}
return eng;
}
static int skf_ciphers(ENGINE *e, const EVP_CIPHER **cipher,
const int **nids, int nid)
{
if (!cipher) {
*nid = skf_cipher_nids;
return skf_num_cipher_nids;
}
switch (nid) {
case NID_ssf33_ecb:
*cipher = &skf_ssf33_ecb;
break;
default:
*cipher = NULL;
return 0;
}
return 1;
}
#endif
#define SSF33_IV_LENGTH SSF33_BLOCK_SIZE
#define SM1_IV_LENGTH SM1_BLOCK_SIZE
#define SMS4_IV_LENGTH SMS4_BLOCK_SIZE
static int skf_ssf33_init_key(EVP_CIPHER_CTX *ctx, const unsigned char *key,
const unsigned char *iv, int enc)
{
DEVHANDLE hDev = skf_dev_handle;
BYTE *pbKey = key;
ULONG ulAlgID = SGD_SSF33_ECB;
HANDLE *phKey;
if ((rv = SKF_SetSymmKey(hDev, pbKey, ulAlgID, (HANDLE *)ctx->cipher_data)) != SAR_OK) {
SKFerr(SKF_F_SKF_SSF33_INIT_KEY, 0);
return 0;
}
return 1;
}
static const EVP_CIPHER skf_ssf33_ecb = {
NID_ssf33_ecb,
SSF33_BLOCK_SIZE,
SSF33_KEY_LENGTH,
SSF33_IV_LENGTH,
0,
skf_ssf33_init_key,
skf_ssf33_ecb_cipher,
NULL,
sizeof(EVP_SMS4_CTX),
NULL,
NULL,
NULL,
NULL,
};
static int skf_cipher_nids[] = {
NID_ssf33_ecb,
NID_ssf33_cbc,
NID_ssf33_cfb128,
NID_ssf33_ofb128,
NID_sm1_ecb,
NID_sm1_cbc,
NID_sm1_cfb128,
NID_sm1_ofb128,
NID_sms4_ecb,
NID_sms4_cbc,
NID_sms4_cfb128,
NID_sms4_ofb128,
};
static int skf_num_ciphers = sizeof(skf_cipher_nids)/sizeof(skf_cipher_nids[0]);
static int skf_ciphers(ENGINE *e, const EVP_CIPHER **cipher, const int **nids, int nid)
{
if (!cipher) {
*nids = skf_cipher_nids;
return skf_num_ciphers;
}
switch (nid) {
case NID_ssf33_ecb:
*cipher = &skf_ssf33_ecb;
break;
case NID_ssf33_cbc:
*cipher = &skf_ssf33_cbc;
break;
case NID_ssf33_cfb128:
*cipher = &skf_ssf33_cfb128;
break;
case NID_ssf33_ofb128:
*cipher = &skf_ssf33_ofb128;
break;
case NID_sm1_ecb:
*cipher = &skf_sm1_ecb;
break;
case NID_sm1_cbc:
*cipher = &skf_sm1_cbc;
break;
case NID_sm1_cfb128:
*cipher = &skf_sm1_cfb128;
break;
case NID_sm1_ofb128:
*cipher = &skf_sm1_ofb128;
break;
case NID_sms4_ecb:
*cipher = &skf_sms4_ecb;
break;
case NID_sms4_cbc:
*cipher = &skf_sms4_cbc;
break;
case NID_sms4_cfb128:
*cipher = &skf_sms4_cfb128;
break;
case NID_sms4_ofb128:
*cipher = &skf_sms4_ofb128;
break;
default:
*cipher = NULL;
return 0;
}
return 1;
}
int skf_err2openssl(ULONG rv)
{
return 0;
}
/* RAND_METHOD */
int skf_rand_bytes(unsigned char *buf, int num)
{
ULONG rv;
if ((rv = SKF_GenRandom(skf_dev_handle, buf, num)) != SAR_OK) {
SKFerr(SKF_F_SKF_RAND_BYTES, skf_err2openssl(rv));
return 0;
}
return 1;
}
static RAND_METHOD skf_rand = {
NULL,
skf_rand_bytes,
NULL,
NULL,
skf_rand_bytes,
NULL,
};
/* EVP_MD */
static int skf_sm3_init(EVP_MD_CTX *ctx)
{
ULONG rv;
DEVHANDLE hDev = skf_dev_handle;
HANDLE hHash;
if ((rv = SKF_DigestInit(hDev, SGD_SM3, NULL, NULL, 0,
(HANDLE *)&ctx->md_data)) != SAR_OK) {
SKFerr(SKF_F_SM3_INIT, skf_err2openssl(rv));
return 0;
}
return 1;
}
static int skf_sm3_update(EVP_MD_CTX *ctx, const void *data, size_t count)
{
ULONG rv;
BYTE *pbData = (BYTE *)data;
ULONG ulDataLen = (ULONG)count;
if ((rv = SKF_DigestUpdate((HANDLE)ctx->md_data, pbData, ulDataLen)) != SAR_OK) {
SKFerr(SKF_F_SKF_SM3_UPDATE, skf_err2openssl(rv));
return 0;
}
return 1;
}
static int skf_sm3_final(EVP_MD_CTX *ctx, unsigned char *md)
{
ULONG rv;
BYTE *pHashData = (BYTE *)md;
ULONG ulHashLen = SM3_DIGEST_LENGTH;
if ((rv = SKF_DigestFinal(hHash, pHashData, &ulHashLen)) != SAR_OK) {
SKFerr(SKF_F_SKF_SM3_FINAL, skf_err2openssl(rv));
return 0;
}
if ((rv = SKF_CloseHandle(hHash)) != SAR_OK) {
SKFerr(SKF_F_SKF_SM3_FINAL, skf_err2openssl(rv));
return 0;
}
return 1;
}
static const EVP_MD skf_sm3 = {
NID_sm3,
0,
SM3_DIGEST_LENGTH,
0,
skf_sm3_init,
skf_sm3_update,
skf_sm3_final,
NULL,
NULL,
EVP_PKEY_NULL_method,
SM3_BLOCK_SIZE,
sizeof(EVP_MD *) + sizeof(HANDLE),
NULL,
};
static int skf_digest_nids[] = { NID_sm3, };
static int skf_num_digests = sizeof(skf_digest_nids)/sizeof(skf_digest_nids[0]);
static int skf_digests(ENGINE *e, const EVP_MD **digest, const int **nids, int nid)
{
if (!digest) {
*nids = skf_digest_nids;
return skf_num_digests;
}
switch (nid) {
case NID_sm3:
*digest = &skf_sm3;
break;
default:
*digest = NULL;
return 0;
}
return 1;
}
/* Dynamic ENGINE */
static const char *engine_skf_id = "SKF";
static const char *engine_skf_name = "SKF API Hardware Engine";
static int bind(ENGINE *e, const char *id)
{
if (id && strcmp(id, engine_skf_id)) {
return 0;
}
if (!ENGINE_set_id(e, engine_skf_id) ||
!ENGINE_set_name(e, engine_skf_name) ||
!ENGINE_set_digests(e, skf_digests) ||
//!ENGINE_set_ciphers(e, skf_ciphers) ||
!ENGINE_set_RAND(e, &skf_random)) {
return 0;
}
return 1;
}
IMPLEMENT_DYNAMIC_BIND_FN(bind);
IMPLEMENT_DYNAMIC_CHECK_FN();

0
engines/skf/e_skf.ec
View File

0
engines/skf/e_skf.h
View File

79
engines/skf/e_skf_err.c
View File

@@ -1,79 +0,0 @@
#include "smapi_err.h"
typedef struct {
int err_no;
char *err_str;
} skf_errstr[] = {
{ SAR_OK, "Success" },
{ SAR_FAIL, "Failure" },
{ SAR_UNKNOWNERR, "Unknown error" },
{ SAR_NOTSUPPORTYETERR, "Not supported" },
{ SAR_FILEERR, "File error" },
{ SAR_INVALIDHANDLEERR, "Invalid handler" },
{ SAR_INVALIDPARAMERR, "Invalid parameter" },
{ SAR_READFILEERR, "Read file error" },
{ SAR_WRITEFILEERR "Write file error" },
{ SAR_NAMELENERR, "Name length error" },
{ SAR_KEYUSAGEERR, "Key usage error" },
{ SAR_MODULUSLENERR, "Modulus length error" },
{ SAR_NOTINITIALIZEERR, "Not initialized" },
{ SAR_OBJERR, "Object error" },
{ SAR_MEMORYERR, "Memory error" },
{ SAR_TIMEOUTERR, "Time out" },
{ SAR_INDATALENERR, "Input data length error" },
{ SAR_INDATAERR, "Input data error" },
{ SAR_GENRANDERR, "Generate randomness error" },
{ SAR_HASHOBJERR, "Hash object error" },
{ SAR_HASHERR, "Hash error" },
{ SAR_GENRSAKEYERR, "Genenerate RSA key error" },
{ SAR_RSAMODULUSLENERR, "RSA modulus length error" },
{ SAR_CSPIMPRTPUBKEYERR, "CSP import public key error" },
{ SAR_RSAENCERR, "RSA encryption error" },
{ SAR_RSADECERR, "RSA decryption error" },
{ SAR_HASHNOTEQUALERR, "Hash not equal" },
{ SAR_KEYNOTFOUNTERR, "Key not found" },
{ SAR_CERTNOTFOUNTERR, "Certificate not found" },
{ SAR_NOTEXPORTERR, "Not exported" },
{ SAR_DECRYPTPADERR, "Decrypt pad error" },
{ SAR_MACLENERR, "MAC length error" },
{ SAR_BUFFER_TOO_SMALL, "Buffer too small" },
{ SAR_KEYINFOTYPEERR, "Key info type error" },
{ SAR_NOT_EVENTERR, "No event error" },
{ SAR_DEVICE_REMOVED "Device removed" },
{ SAR_PIN_INCORRECT, "PIN incorrect" },
{ SAR_PIN_LOCKED, "PIN locked" },
{ SAR_PIN_INVALID, "PIN invalid" },
{ SAR_PIN_LEN_RANGE, "PIN length error" },
{ SAR_USER_ALREADY_LOGGED_IN, "User already logged in" },
{ SAR_USER_PIN_NOT_INITIALIZED, "User PIN not initialized" },
{ SAR_USER_TYPE_INVALID, "User type invalid" },
{ SAR_APPLICATION_NAME_INVALID, "Application name invalid" },
{ SAR_APPLICATION_EXISTS, "Application already exist" },
{ SAR_USER_NOT_LOGGED_IN, "User not logged in" },
{ SAR_APPLICATION_NOT_EXISTS, "Application not exist" },
{ SAR_FILE_ALREADY_EXIST, "File already exist" },
{ SAR_NO_ROOM, "No file space" },
{ SAR_FILE_NOT_EXIST, "File not exist" }
};
typedef struct {
uint32_t alg_id;
char *alg_name;
} smapi_algid[] = {
{ SGD_RSA, "RSA" },
{ SGD_RSA | SGD_SHA1, "RSA-with-SHA1" },
};
LPSTR DEVAPI SKF_GetErrorString(ULONG ulError)
{
/*
* TODO: check smapi_errstr[] and return the error string
* if error number not exist, return NULL;
*/
return NULL;
}
LPSTR DEVAPI SKF_GetAlgorString(ULONG ulAlgId)
{
return NULL;
}

77
engines/skf/e_skf_err.h
View File

@@ -1,77 +0,0 @@
#ifndef HEADER_SKF_ERR_H
#define HEADER_SKF_ERR_H
#ifdef __cplusplus
extern "C" {
#endif
static void ERR_load_SKF_strings(void);
static void ERR_unload_SKF_strings(void);
static void ERR_SKF_error(int function, int reason, char *file, int line);
# define SKFerr(f,r) ERR_SKF_error((f),(r),__FILE__,__LINE__)
/* Function codes. */
#define SKF_F_SKF_RAND 100
/* Reason codes. */
#define SKF_R_OK 110
#define SKF_R_FAIL 101
#define SKF_R_UNKNOWNERR 102
#define SKF_R_NOTSUPPORTYETERR 103
#define SKF_R_FILEERR 104
#define SKF_R_INVALIDHANDLEERR 105
#define SKF_R_INVALIDPARAMERR 106
#define SKF_R_READFILEERR 107
#define SKF_R_WRITEFILEERR 108
#define SKF_R_NAMELENERR 109
#define SKF_R_KEYUSAGEERR 110
#define SKF_R_MODULUSLENERR 111
#define SKF_R_NOTINITIALIZEERR 112
#define SKF_R_OBJERR 113
#define SKF_R_MEMORYERR 114
#define SKF_R_TIMEOUTERR 115
#define SKF_R_INDATALENERR 116
#define SKF_R_INDATAERR 117
#define SKF_R_GENRANDERR 118
#define SKF_R_HASHOBJERR 119
#define SKF_R_HASHERR 120
#define SKF_R_GENRSAKEYERR 121
#define SKF_R_RSAMODULUSLENERR 122
#define SKF_R_CSPIMPRTPUBKEYERR 123
#define SKF_R_RSAENCERR 124
#define SKF_R_RSADECERR 125
#define SKF_R_HASHNOTEQUALERR 126
#define SKF_R_KEYNOTFOUNTERR 127
#define SKF_R_CERTNOTFOUNTERR 128
#define SKF_R_NOTEXPORTERR 129
#define SKF_R_DECRYPTPADERR 130
#define SKF_R_MACLENERR 131
#define SKF_R_BUFFER_TOO_SMALL 132
#define SKF_R_KEYINFOTYPEERR 133
#define SKF_R_NOT_EVENTERR 134
#define SKF_R_DEVICE_REMOVED 135
#define SKF_R_PIN_INCORRECT 136
#define SKF_R_PIN_LOCKED 137
#define SKF_R_PIN_INVALID 138
#define SKF_R_PIN_LEN_RANGE 139
#define SKF_R_USER_ALREADY_LOGGED_IN 140
#define SKF_R_USER_PIN_NOT_INITIALIZED 141
#define SKF_R_USER_TYPE_INVALID 142
#define SKF_R_APPLICATION_NAME_INVALID 143
#define SKF_R_APPLICATION_EXISTS 144
#define SKF_R_USER_NOT_LOGGED_IN 145
#define SKF_R_APPLICATION_NOT_EXISTS 146
#define SKF_R_FILE_ALREADY_EXIST 147
#define SKF_R_NO_ROOM 148
#define SKF_R_FILE_NOT_EXIST 149
#ifdef __cplusplus
}
#endif
#endif

156
engines/skf/skf.h
View File

@@ -73,7 +73,7 @@ typedef HANDLE HCONTAINER;
#endif
#ifndef USER_TYPE
#define USER_TYPE 1
#define USER_TYPE 1
#endif
#define MAX_RSA_MODULUS_LEN 256
@@ -215,10 +215,10 @@ ULONG DEVAPI SKF_LockDev(DEVHANDLE hDev,
ULONG ulTimeOut);
ULONG DEVAPI SKF_UnlockDev(DEVHANDLE hDev);
ULONG DEVAPI SKF_Transmit(DEVHANDLE hDev,
BYTE* pbCommand,
BYTE *pbCommand,
ULONG ulCommandLen,
BYTE* pbData,
ULONG* pulDataLen);
BYTE *pbData,
ULONG *pulDataLen);
ULONG DEVAPI SKF_ChangeDevAuthKey(DEVHANDLE hDev,
BYTE *pbKeyValue,
ULONG ulKeyLen);
@@ -276,11 +276,11 @@ ULONG DEVAPI SKF_ReadFile(HAPPLICATION hApplication,
LPSTR szFileName,
ULONG ulOffset,
ULONG ulSize,
BYTE * pbOutData,
BYTE *pbOutData,
ULONG *pulOutLen);
ULONG DEVAPI SKF_WriteFile(HAPPLICATION hApplication,
LPSTR szFileName,
ULONG ulOffset,
ULONG ulOffset,
BYTE *pbData,
ULONG ulSize);
@@ -300,11 +300,11 @@ ULONG DEVAPI SKF_GetContainerType(HCONTAINER hContainer,
ULONG *pulContainerType);
ULONG DEVAPI SKF_ImportCertificate(HCONTAINER hContainer,
BOOL bSignFlag,
BYTE* pbCert,
BYTE *pbCert,
ULONG ulCertLen);
ULONG DEVAPI SKF_ExportCertificate(HCONTAINER hContainer,
BOOL bSignFlag,
BYTE* pbCert,
BYTE *pbCert,
ULONG *pulCertLen);
ULONG DEVAPI SKF_GenRandom(DEVHANDLE hDev,
@@ -324,33 +324,33 @@ ULONG DEVAPI SKF_ImportRSAKeyPair(HCONTAINER hContainer,
ULONG ulEncryptedDataLen);
ULONG DEVAPI SKF_RSASignData(HCONTAINER hContainer,
BYTE *pbData,
ULONG ulDataLen,
BYTE *pbSignature,
ULONG ulDataLen,
BYTE *pbSignature,
ULONG *pulSignLen);
ULONG DEVAPI SKF_RSAVerify(DEVHANDLE hDev,
RSAPUBLICKEYBLOB* pRSAPubKeyBlob,
BYTE *pbData,
ULONG ulDataLen,
RSAPUBLICKEYBLOB *pRSAPubKeyBlob,
BYTE *pbData,
ULONG ulDataLen,
BYTE *pbSignature,
ULONG ulSignLen);
ULONG DEVAPI SKF_RSAExportSessionKey(HCONTAINER hContainer,
ULONG ulAlgId,
RSAPUBLICKEYBLOB *pPubKey,
BYTE *pbData,
ULONG *pulDataLen,
ULONG *pulDataLen,
HANDLE *phSessionKey);
ULONG DEVAPI SKF_ExtRSAPubKeyOperation(DEVHANDLE hDev,
RSAPUBLICKEYBLOB* pRSAPubKeyBlob,
BYTE* pbInput,
RSAPUBLICKEYBLOB *pRSAPubKeyBlob,
BYTE *pbInput,
ULONG ulInputLen,
BYTE* pbOutput,
ULONG* pulOutputLen);
BYTE *pbOutput,
ULONG *pulOutputLen);
ULONG DEVAPI SKF_ExtRSAPriKeyOperation(DEVHANDLE hDev,
RSAPRIVATEKEYBLOB* pRSAPriKeyBlob,
BYTE* pbInput,
RSAPRIVATEKEYBLOB *pRSAPriKeyBlob,
BYTE *pbInput,
ULONG ulInputLen,
BYTE* pbOutput,
ULONG* pulOutputLen);
BYTE *pbOutput,
ULONG *pulOutputLen);
ULONG DEVAPI SKF_GenECCKeyPair(HCONTAINER hContainer,
ULONG ulAlgId,
ECCPUBLICKEYBLOB *pBlob);
@@ -358,13 +358,13 @@ ULONG DEVAPI SKF_ImportECCKeyPair(HCONTAINER hContainer,
PENVELOPEDKEYBLOB pEnvelopedKeyBlob);
ULONG DEVAPI SKF_ECCSignData(HCONTAINER hContainer,
BYTE *pbData,
ULONG ulDataLen,
ULONG ulDataLen,
PECCSIGNATUREBLOB pSignature);
ULONG DEVAPI SKF_ECCVerify(DEVHANDLE hDev,
ECCPUBLICKEYBLOB* pECCPubKeyBlob,
BYTE *pbData,
ULONG ulDataLen,
ULONG ulDataLen,
PECCSIGNATUREBLOB pSignature);
ULONG DEVAPI SKF_ECCExportSessionKey(HCONTAINER hContainer,
ULONG ulAlgId,
@@ -372,61 +372,61 @@ ULONG DEVAPI SKF_ECCExportSessionKey(HCONTAINER hContainer,
PECCCIPHERBLOB pData,
HANDLE *phSessionKey);
ULONG DEVAPI SKF_ExtECCEncrypt(DEVHANDLE hDev,
ECCPUBLICKEYBLOB* pECCPubKeyBlob,
BYTE* pbPlainText,
ULONG ulPlainTextLen,
ECCPUBLICKEYBLOB *pECCPubKeyBlob,
BYTE *pbPlainText,
ULONG ulPlainTextLen,
PECCCIPHERBLOB pCipherText);
ULONG DEVAPI SKF_ExtECCDecrypt(DEVHANDLE hDev,
ECCPRIVATEKEYBLOB* pECCPriKeyBlob,
PECCCIPHERBLOB pCipherText,
BYTE* pbPlainText,
ULONG* pulPlainTextLen);
ECCPRIVATEKEYBLOB *pECCPriKeyBlob,
PECCCIPHERBLOB pCipherText,
BYTE *pbPlainText,
ULONG *pulPlainTextLen);
ULONG DEVAPI SKF_ExtECCSign(DEVHANDLE hDev,
ECCPRIVATEKEYBLOB* pECCPriKeyBlob,
BYTE* pbData,
ULONG ulDataLen,
ECCPRIVATEKEYBLOB *pECCPriKeyBlob,
BYTE *pbData,
ULONG ulDataLen,
PECCSIGNATUREBLOB pSignature);
ULONG DEVAPI SKF_ExtECCVerify(DEVHANDLE hDev,
ECCPUBLICKEYBLOB* pECCPubKeyBlob,
BYTE* pbData,
ULONG ulDataLen,
ECCPUBLICKEYBLOB *pECCPubKeyBlob,
BYTE *pbData,
ULONG ulDataLen,
PECCSIGNATUREBLOB pSignature);
ULONG DEVAPI SKF_GenerateAgreementDataWithECC(HCONTAINER hContainer,
ULONG ulAlgId,
ECCPUBLICKEYBLOB* pTempECCPubKeyBlob,
BYTE* pbID,
ECCPUBLICKEYBLOB *pTempECCPubKeyBlob,
BYTE *pbID,
ULONG ulIDLen,
HANDLE *phAgreementHandle);
ULONG DEVAPI SKF_GenerateAgreementDataAndKeyWithECC(HANDLE hContainer,
ULONG ulAlgId,
ECCPUBLICKEYBLOB* pSponsorECCPubKeyBlob,
ECCPUBLICKEYBLOB* pSponsorTempECCPubKeyBlob,
ECCPUBLICKEYBLOB* pTempECCPubKeyBlob,
BYTE* pbID,
ULONG ulIDLen,
BYTE *pbSponsorID,
ECCPUBLICKEYBLOB *pSponsorECCPubKeyBlob,
ECCPUBLICKEYBLOB *pSponsorTempECCPubKeyBlob,
ECCPUBLICKEYBLOB *pTempECCPubKeyBlob,
BYTE *pbID,
ULONG ulIDLen,
BYTE *pbSponsorID,
ULONG ulSponsorIDLen,
HANDLE *phKeyHandle);
ULONG DEVAPI SKF_GenerateKeyWithECC(HANDLE hAgreementHandle,
ECCPUBLICKEYBLOB* pECCPubKeyBlob,
ECCPUBLICKEYBLOB* pTempECCPubKeyBlob,
BYTE* pbID,
ULONG ulIDLen,
ECCPUBLICKEYBLOB *pECCPubKeyBlob,
ECCPUBLICKEYBLOB *pTempECCPubKeyBlob,
BYTE *pbID,
ULONG ulIDLen,
HANDLE *phKeyHandle);
ULONG DEVAPI SKF_ExportPublicKey(HCONTAINER hContainer,
BOOL bSignFlag,
BYTE* pbBlob,
ULONG* pulBlobLen);
BYTE *pbBlob,
ULONG *pulBlobLen);
ULONG DEVAPI SKF_ImportSessionKey(HCONTAINER hContainer,
ULONG ulAlgId,
BYTE *pbWrapedData,
ULONG ulWrapedLen,
HANDLE *phKey);
ULONG DEVAPI SKF_SetSymmKey(DEVHANDLE hDev,
BYTE* pbKey,
ULONG ulAlgID,
HANDLE* phKey);
ULONG DEVAPI SKF_EncryptInit(HANDLE hKey,
BYTE *pbKey,
ULONG ulAlgID,
HANDLE *phKey);
ULONG DEVAPI SKF_EncryptInit(HANDLE hKey,
BLOCKCIPHERPARAM EncryptParam);
ULONG DEVAPI SKF_Encrypt(HANDLE hKey,
BYTE *pbData,
@@ -434,9 +434,9 @@ ULONG DEVAPI SKF_Encrypt(HANDLE hKey,
BYTE *pbEncryptedData,
ULONG *pulEncryptedLen);
ULONG DEVAPI SKF_EncryptUpdate(HANDLE hKey,
BYTE * pbData,
ULONG ulDataLen,
BYTE *pbEncryptedData,
BYTE *pbData,
ULONG ulDataLen,
BYTE *pbEncryptedData,
ULONG *pulEncryptedLen);
ULONG DEVAPI SKF_EncryptFinal(HANDLE hKey,
BYTE *pbEncryptedData,
@@ -444,45 +444,45 @@ ULONG DEVAPI SKF_EncryptFinal(HANDLE hKey,
ULONG DEVAPI SKF_DecryptInit(HANDLE hKey,
BLOCKCIPHERPARAM DecryptParam);
ULONG DEVAPI SKF_Decrypt(HANDLE hKey,
BYTE * pbEncryptedData,
ULONG ulEncryptedLen,
BYTE * pbData,
ULONG * pulDataLen);
BYTE *pbEncryptedData,
ULONG ulEncryptedLen,
BYTE *pbData,
ULONG *pulDataLen);
ULONG DEVAPI SKF_DecryptUpdate(HANDLE hKey,
BYTE * pbEncryptedData,
ULONG ulEncryptedLen,
BYTE * pbData,
ULONG * pulDataLen);
BYTE *pbEncryptedData,
ULONG ulEncryptedLen,
BYTE *pbData,
ULONG *pulDataLen);
ULONG DEVAPI SKF_DecryptFinal(HANDLE hKey,
BYTE *pbDecryptedData,
ULONG *pulDecryptedDataLen);
ULONG DEVAPI SKF_DigestInit(DEVHANDLE hDev,
ULONG ulAlgID,
ECCPUBLICKEYBLOB *pPubKey,
unsigned char *pucID,
ULONG ulIDLen,
ECCPUBLICKEYBLOB *pPubKey,
unsigned char *pucID,
ULONG ulIDLen,
HANDLE *phHash);
ULONG DEVAPI SKF_Digest(HANDLE hHash,
BYTE *pbData,
ULONG ulDataLen,
ULONG ulDataLen,
BYTE *pbHashData,
ULONG *pulHashLen);
ULONG DEVAPI SKF_DigestUpdate(HANDLE hHash,
BYTE *pbData,
ULONG ulDataLen);
ULONG ulDataLen);
ULONG DEVAPI SKF_DigestFinal(HANDLE hHash,
BYTE *pHashData,
ULONG *pulHashLen);
ULONG DEVAPI SKF_MacInit(HANDLE hKey,
BLOCKCIPHERPARAM* pMacParam,
ULONG *pulHashLen);
ULONG DEVAPI SKF_MacInit(HANDLE hKey,
BLOCKCIPHERPARAM *pMacParam,
HANDLE *phMac);
ULONG DEVAPI SKF_Mac(HANDLE hMac,
BYTE* pbData,
ULONG ulDataLen,
BYTE *pbMacData,
BYTE *pbData,
ULONG ulDataLen,
BYTE *pbMacData,
ULONG *pulMacLen);
ULONG DEVAPI SKF_MacUpdate(HANDLE hMac,
BYTE * pbData,
BYTE *pbData,
ULONG ulDataLen);
ULONG DEVAPI SKF_MacFinal(HANDLE hMac,
BYTE *pbMacData,

1
engines/skf/skf_impl.c
View File

@@ -1,3 +1,4 @@
#include <stdio.h>
#include <string.h>
#include "skf.h"

BIN
engines/skf/skf_impl.o Normal file
View File

Binary file not shown.