mirror of
https://github.com/guanzhi/GmSSL.git
synced 2026-05-26 02:06:28 +08:00
SM2 KAP (Key Agreement Protocol), not tested
This commit is contained in:
Zhi Guan
@@ -1,54 +1,103 @@
|
||||
#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"
|
||||
|
||||
|
||||
|
||||
#define SKF_ENGINE_ID "skf"
|
||||
#define SKF_ENGINE_NAME "skf engine"
|
||||
|
||||
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];
|
||||
|
||||
rv = SKF_EnumDev(TRUE, szNameList, &ulSize);
|
||||
rv = SKF_ConnectDev(szName, &hDev);
|
||||
rv = SKF_DevAuth(hDev, pbAuthData, ulLen);
|
||||
rv = SKF_EnumApplication(hDev, szAppName, &ulSize);
|
||||
rv = SKF_OpenApplication(hDev, szAppName, &hApp);
|
||||
CHAR appNameList[256];
|
||||
LPSTR appName;
|
||||
HAPPLICATION hApp;
|
||||
|
||||
rv = SKF_SetSymmKey(hDev, pbKey, ulAlgID, &hKey);
|
||||
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;
|
||||
}
|
||||
|
||||
rv = SKF_EncryptInit(hKey, encParam);
|
||||
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 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_bind_helper(ENGINE *e)
|
||||
{
|
||||
if (!ENGINE_set_id(e, SKF_ENGINE_ID) ||
|
||||
@@ -64,21 +113,21 @@ static int skf_bind_helper(ENGINE *e)
|
||||
return 1;
|
||||
}
|
||||
|
||||
static ENGINE *ENGINE_skf(void)
|
||||
{
|
||||
ENGINE *eng = ENGINE_new();
|
||||
|
||||
static int skf_cipher_nids[] = {
|
||||
NID_ssf33_ecb,
|
||||
NID_ssf33_cbc,
|
||||
NID_ssf33_cfb,
|
||||
NID_ssf33_ofb,
|
||||
NID_sm1_ecb,
|
||||
NID_sm1_cbc,
|
||||
NID_sm1_cfb,
|
||||
NID_sm1_ofb,
|
||||
NID_sm4_ecb,
|
||||
NID_sm4_cbc,
|
||||
NID_sm4_cfb,
|
||||
NID_sm4_ofb,
|
||||
};
|
||||
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)
|
||||
@@ -100,33 +149,258 @@ static int skf_ciphers(ENGINE *e, const EVP_CIPHER **cipher,
|
||||
return 1;
|
||||
}
|
||||
|
||||
|
||||
static RAND_METHOD skf_rand = {
|
||||
NULL, /* seed */
|
||||
skf_rand_bytes, /* bytes */
|
||||
NULL, /* cleanup */
|
||||
NULL, /* add */
|
||||
skf_rand_bytes, /* pseudorand */
|
||||
NULL, /* rand status */
|
||||
};
|
||||
#endif
|
||||
|
||||
|
||||
#define SSF33_IV_LENGTH SSF33_BLOCK_SIZE
|
||||
#define SM1_IV_LENGTH SM1_BLOCK_SIZE
|
||||
#define SMS4_IV_LENGTH SMS4_BLOCK_SIZE
|
||||
|
||||
static int bind_fn(ENGINE *e, const char *id)
|
||||
|
||||
static int skf_ssf33_init_key(EVP_CIPHER_CTX *ctx, const unsigned char *key,
|
||||
const unsigned char *iv, int enc)
|
||||
{
|
||||
if (id && (strcmp(id, SKF_ENGINE_ID) != 0)) {
|
||||
fprintf(stderr, "bad engine id\n");
|
||||
return 0;
|
||||
}
|
||||
if (!bind_helper(e)) {
|
||||
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();
|
||||
IMPLEMENT_DYNAMIC_BIND_FN(bind_fn);
|
||||
|
||||
|
||||
0
engines/skf/e_skf.h
Normal file
0
engines/skf/e_skf.h
Normal file
@@ -0,0 +1,79 @@
|
||||
#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
Normal file
77
engines/skf/e_skf_err.h
Normal file
@@ -0,0 +1,77 @@
|
||||
#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
|
||||
@@ -1,12 +1,6 @@
|
||||
#ifndef HEADER_SKF_H
|
||||
#define HEADER_SKF_H
|
||||
|
||||
#include "smapi_err.h"
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
|
||||
/* Algorithms */
|
||||
#define SGD_SM1_ECB 0x00000101
|
||||
@@ -32,7 +26,6 @@ extern "C" {
|
||||
#define SGD_SHA1 0x00000002
|
||||
#define SGD_SHA256 0x00000004
|
||||
|
||||
|
||||
#ifndef WIN32
|
||||
typedef signed char INT8;
|
||||
typedef signed short INT16;
|
||||
@@ -103,11 +96,17 @@ typedef HANDLE HCONTAINER;
|
||||
#define DEV_PRESENT_STATE 0x00000001
|
||||
#define DEV_UNKNOW_STATE 0x00000010
|
||||
|
||||
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
|
||||
typedef struct Struct_Version{
|
||||
BYTE major;
|
||||
BYTE minor;
|
||||
}VERSION;
|
||||
} VERSION;
|
||||
|
||||
typedef struct Struct_DEVINFO {
|
||||
VERSION Version;
|
||||
@@ -135,7 +134,7 @@ typedef struct Struct_RSAPUBLICKEYBLOB {
|
||||
BYTE PublicExponent[MAX_RSA_EXPONENT_LEN];
|
||||
} RSAPUBLICKEYBLOB, *PRSAPUBLICKEYBLOB;
|
||||
|
||||
typedef struct Struct_RSAPRIVATEKEYBLOB{
|
||||
typedef struct Struct_RSAPRIVATEKEYBLOB {
|
||||
ULONG AlgID;
|
||||
ULONG BitLen;
|
||||
BYTE Modulus[MAX_RSA_MODULUS_LEN];
|
||||
@@ -146,20 +145,20 @@ typedef struct Struct_RSAPRIVATEKEYBLOB{
|
||||
BYTE Prime1Exponent[MAX_RSA_MODULUS_LEN/2];
|
||||
BYTE Prime2Exponent[MAX_RSA_MODULUS_LEN/2];
|
||||
BYTE Coefficient[MAX_RSA_MODULUS_LEN/2];
|
||||
}RSAPRIVATEKEYBLOB, *PRSAPRIVATEKEYBLOB;
|
||||
} RSAPRIVATEKEYBLOB, *PRSAPRIVATEKEYBLOB;
|
||||
|
||||
typedef struct Struct_ECCPUBLICKEYBLOB{
|
||||
typedef struct Struct_ECCPUBLICKEYBLOB {
|
||||
ULONG BitLen;
|
||||
BYTE XCoordinate[ECC_MAX_XCOORDINATE_BITS_LEN/8];
|
||||
BYTE YCoordinate[ECC_MAX_YCOORDINATE_BITS_LEN/8];
|
||||
}ECCPUBLICKEYBLOB, *PECCPUBLICKEYBLOB;
|
||||
} ECCPUBLICKEYBLOB, *PECCPUBLICKEYBLOB;
|
||||
|
||||
typedef struct Struct_ECCPRIVATEKEYBLOB{
|
||||
typedef struct Struct_ECCPRIVATEKEYBLOB {
|
||||
ULONG BitLen;
|
||||
BYTE PrivateKey[ECC_MAX_MODULUS_BITS_LEN/8];
|
||||
}ECCPRIVATEKEYBLOB, *PECCPRIVATEKEYBLOB;
|
||||
} ECCPRIVATEKEYBLOB, *PECCPRIVATEKEYBLOB;
|
||||
|
||||
typedef struct Struct_ECCCIPHERBLOB{
|
||||
typedef struct Struct_ECCCIPHERBLOB {
|
||||
BYTE XCoordinate[ECC_MAX_XCOORDINATE_BITS_LEN/8];
|
||||
BYTE YCoordinate[ECC_MAX_XCOORDINATE_BITS_LEN/8];
|
||||
BYTE HASH[32];
|
||||
@@ -167,28 +166,28 @@ typedef struct Struct_ECCCIPHERBLOB{
|
||||
BYTE Cipher[1];
|
||||
} ECCCIPHERBLOB, *PECCCIPHERBLOB;
|
||||
|
||||
typedef struct Struct_ECCSIGNATUREBLOB{
|
||||
typedef struct Struct_ECCSIGNATUREBLOB {
|
||||
BYTE r[ECC_MAX_XCOORDINATE_BITS_LEN/8];
|
||||
BYTE s[ECC_MAX_XCOORDINATE_BITS_LEN/8];
|
||||
} ECCSIGNATUREBLOB, *PECCSIGNATUREBLOB;
|
||||
|
||||
typedef struct Struct_BLOCKCIPHERPARAM{
|
||||
typedef struct Struct_BLOCKCIPHERPARAM {
|
||||
BYTE IV[MAX_IV_LEN];
|
||||
ULONG IVLen;
|
||||
ULONG PaddingType;
|
||||
ULONG FeedBitLen;
|
||||
} BLOCKCIPHERPARAM, *PBLOCKCIPHERPARAM;
|
||||
|
||||
typedef struct SKF_ENVELOPEDKEYBLOB{
|
||||
typedef struct SKF_ENVELOPEDKEYBLOB {
|
||||
ULONG Version;
|
||||
ULONG ulSymmAlgID;
|
||||
ULONG ulBits;
|
||||
BYTE cbEncryptedPriKey[64];
|
||||
ECCPUBLICKEYBLOB PubKey;
|
||||
ECCCIPHERBLOB ECCCipherBlob;
|
||||
}ENVELOPEDKEYBLOB, *PENVELOPEDKEYBLOB;
|
||||
} ENVELOPEDKEYBLOB, *PENVELOPEDKEYBLOB;
|
||||
|
||||
typedef struct Struct_FILEATTRIBUTE{
|
||||
typedef struct Struct_FILEATTRIBUTE {
|
||||
CHAR FileName[MAX_FILE_NAME_SIZE];
|
||||
ULONG FileSize;
|
||||
ULONG ReadRights;
|
||||
@@ -226,11 +225,7 @@ ULONG DEVAPI SKF_ChangeDevAuthKey(DEVHANDLE hDev,
|
||||
ULONG DEVAPI SKF_DevAuth(DEVHANDLE hDev,
|
||||
BYTE *pbAuthData,
|
||||
ULONG ulLen);
|
||||
ULONG DEVAPI SKF_ChangePIN(HAPPLICATION hApplication,
|
||||
ULONG ulPINType,
|
||||
LPSTR szOldPin,
|
||||
LPSTR szNewPin,
|
||||
ULONG *pulRetryCount);
|
||||
ULONG DEVAPI SKF_ChangePIN(HAPPLICATION hApplication, ULONG ulPINType, LPSTR szOldPin, LPSTR szNewPin, ULONG *pulRetryCount);
|
||||
LONG DEVAPI SKF_GetPINInfo(HAPPLICATION hApplication,
|
||||
ULONG ulPINType,
|
||||
ULONG *pulMaxRetryCount,
|
||||
|
||||
766
engines/skf/skf_impl.c
Normal file
766
engines/skf/skf_impl.c
Normal file
@@ -0,0 +1,766 @@
|
||||
#include <string.h>
|
||||
#include "skf.h"
|
||||
|
||||
#define DEV_NAME "dev0"
|
||||
#define DEV_NAME_LIST DEV_NAME"\0"
|
||||
#define APP_NAME "app0"
|
||||
#define APP_NAME_LIST APP_NAME"\0"
|
||||
#define CONTAINER_NAME "container0"
|
||||
#define CONTAINER_NAME_LIST CONTAINER_NAME"\0"
|
||||
#define CONTAINER_TYPE_UNDEF 0
|
||||
#define CONTAINER_TYPE_RSA 1
|
||||
#define CONTAINER_TYPE_ECC 2
|
||||
|
||||
|
||||
int default_dev = 1;
|
||||
int default_app = 1;
|
||||
int default_container = 1;
|
||||
DEVHANDLE DEV_HANDLE = &default_dev;
|
||||
HAPPLICATION APP_HANDLE = &default_app;
|
||||
HCONTAINER CONTAINER_HANDLE = &default_container;
|
||||
|
||||
|
||||
ULONG DEVAPI SKF_WaitForDevEvent(LPSTR szDevName,
|
||||
ULONG *pulDevNameLen, ULONG *pulEvent)
|
||||
{
|
||||
return SAR_NOTSUPPORTYETERR;
|
||||
}
|
||||
|
||||
ULONG DEVAPI SKF_CancelWaitForDevEvent()
|
||||
{
|
||||
return SAR_NOTSUPPORTYETERR;
|
||||
}
|
||||
|
||||
ULONG DEVAPI SKF_EnumDev(BOOL bPresent,
|
||||
LPSTR szNameList,
|
||||
ULONG *pulSize)
|
||||
{
|
||||
if (!szNameList) {
|
||||
*pulSize = sizeof(DEV_NAME_LIST);
|
||||
return SAR_OK;
|
||||
}
|
||||
|
||||
if (*pulSize < sizeof(DEV_NAME_LIST)) {
|
||||
return SAR_BUFFER_TOO_SMALL;
|
||||
}
|
||||
|
||||
memcpy(szNameList, DEV_NAME_LIST, sizeof(DEV_NAME_LIST));
|
||||
*pulSize = sizeof(DEV_NAME_LIST);
|
||||
|
||||
return SAR_OK;
|
||||
}
|
||||
|
||||
ULONG DEVAPI SKF_ConnectDev(LPSTR szName,
|
||||
DEVHANDLE *phDev)
|
||||
{
|
||||
printf("%s\n", (char *)szName);
|
||||
|
||||
|
||||
if (!phDev) {
|
||||
printf("shit\n");
|
||||
return SAR_INVALIDPARAMERR;
|
||||
}
|
||||
|
||||
if (memcmp(szName, DEV_NAME, sizeof(DEV_NAME))) {
|
||||
printf("%s %s\n", szName, DEV_NAME);
|
||||
return SAR_FAIL;
|
||||
}
|
||||
|
||||
*phDev = DEV_HANDLE;
|
||||
|
||||
return SAR_OK;
|
||||
}
|
||||
|
||||
ULONG DEVAPI SKF_DisConnectDev(DEVHANDLE hDev)
|
||||
{
|
||||
return SAR_OK;
|
||||
}
|
||||
|
||||
ULONG DEVAPI SKF_GetDevState(LPSTR szDevName,
|
||||
ULONG *pulDevState)
|
||||
{
|
||||
if (!szDevName || !pulDevState) {
|
||||
return SAR_INVALIDPARAMERR;
|
||||
}
|
||||
|
||||
if (memcmp(szDevName, DEV_NAME, sizeof(DEV_NAME))) {
|
||||
return SAR_FAIL;
|
||||
}
|
||||
|
||||
*pulDevState = DEV_PRESENT_STATE;
|
||||
|
||||
return SAR_OK;
|
||||
}
|
||||
|
||||
ULONG DEVAPI SKF_SetLabel(DEVHANDLE hDev,
|
||||
LPSTR szLabel)
|
||||
{
|
||||
return SAR_NOTSUPPORTYETERR;
|
||||
}
|
||||
|
||||
ULONG DEVAPI SKF_GetDevInfo(DEVHANDLE hDev,
|
||||
DEVINFO *pDevInfo)
|
||||
{
|
||||
DEVINFO devInfo;
|
||||
|
||||
bzero(&devInfo, 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, "000001");
|
||||
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_NOTSUPPORTYETERR;
|
||||
}
|
||||
|
||||
ULONG DEVAPI SKF_UnlockDev(DEVHANDLE hDev)
|
||||
{
|
||||
return SAR_NOTSUPPORTYETERR;
|
||||
}
|
||||
|
||||
ULONG DEVAPI SKF_Transmit(DEVHANDLE hDev,
|
||||
BYTE *pbCommand,
|
||||
ULONG ulCommandLen,
|
||||
BYTE *pbData,
|
||||
ULONG *pulDataLen)
|
||||
{
|
||||
return SAR_NOTSUPPORTYETERR;
|
||||
}
|
||||
|
||||
ULONG DEVAPI SKF_ChangeDevAuthKey(DEVHANDLE hDev,
|
||||
BYTE *pbKeyValue,
|
||||
ULONG ulKeyLen)
|
||||
{
|
||||
return SAR_NOTSUPPORTYETERR;
|
||||
}
|
||||
|
||||
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)
|
||||
{
|
||||
return SAR_NOTSUPPORTYETERR;
|
||||
}
|
||||
|
||||
LONG DEVAPI SKF_GetPINInfo(HAPPLICATION hApplication,
|
||||
ULONG ulPINType,
|
||||
ULONG *pulMaxRetryCount,
|
||||
ULONG *pulRemainRetryCount,
|
||||
BOOL *pbDefaultPin)
|
||||
{
|
||||
return SAR_NOTSUPPORTYETERR;
|
||||
}
|
||||
|
||||
ULONG DEVAPI SKF_VerifyPIN(HAPPLICATION hApplication,
|
||||
ULONG ulPINType,
|
||||
LPSTR szPIN,
|
||||
ULONG *pulRetryCount)
|
||||
{
|
||||
return SAR_OK;
|
||||
}
|
||||
|
||||
ULONG DEVAPI SKF_UnblockPIN(HAPPLICATION hApplication,
|
||||
LPSTR szAdminPIN,
|
||||
LPSTR szNewUserPIN,
|
||||
ULONG *pulRetryCount)
|
||||
{
|
||||
return SAR_NOTSUPPORTYETERR;
|
||||
}
|
||||
|
||||
ULONG DEVAPI SKF_ClearSecureState(HAPPLICATION hApplication)
|
||||
{
|
||||
return SAR_NOTSUPPORTYETERR;
|
||||
}
|
||||
|
||||
ULONG DEVAPI SKF_CreateApplication(DEVHANDLE hDev,
|
||||
LPSTR szAppName,
|
||||
LPSTR szAdminPin,
|
||||
DWORD dwAdminPinRetryCount,
|
||||
LPSTR szUserPin,
|
||||
DWORD dwUserPinRetryCount,
|
||||
DWORD dwCreateFileRights,
|
||||
HAPPLICATION *phApplication)
|
||||
{
|
||||
return SAR_NOTSUPPORTYETERR;
|
||||
}
|
||||
|
||||
ULONG DEVAPI SKF_EnumApplication(DEVHANDLE hDev,
|
||||
LPSTR szAppName,
|
||||
ULONG *pulSize)
|
||||
{
|
||||
if (!szAppName) {
|
||||
*pulSize = sizeof(APP_NAME_LIST);
|
||||
return SAR_OK;
|
||||
}
|
||||
|
||||
if (*pulSize < sizeof(APP_NAME_LIST)) {
|
||||
return SAR_BUFFER_TOO_SMALL;
|
||||
}
|
||||
|
||||
memcpy(szAppName, APP_NAME_LIST, sizeof(APP_NAME_LIST));
|
||||
|
||||
return SAR_OK;
|
||||
}
|
||||
|
||||
ULONG DEVAPI SKF_DeleteApplication(DEVHANDLE hDev,
|
||||
LPSTR szAppName)
|
||||
{
|
||||
return SAR_NOTSUPPORTYETERR;
|
||||
}
|
||||
|
||||
ULONG DEVAPI SKF_OpenApplication(DEVHANDLE hDev,
|
||||
LPSTR szAppName,
|
||||
HAPPLICATION *phApplication)
|
||||
{
|
||||
if (!szAppName || !phApplication) {
|
||||
return SAR_INVALIDPARAMERR;
|
||||
}
|
||||
|
||||
if (hDev != DEV_HANDLE || memcmp(szAppName, APP_NAME, sizeof(APP_NAME))) {
|
||||
return SAR_FAIL;
|
||||
}
|
||||
|
||||
*phApplication = APP_HANDLE;
|
||||
|
||||
return SAR_OK;
|
||||
}
|
||||
|
||||
ULONG DEVAPI SKF_CloseApplication(HAPPLICATION hApplication)
|
||||
{
|
||||
if (hApplication != APP_HANDLE) {
|
||||
return SAR_FAIL;
|
||||
}
|
||||
|
||||
return SAR_OK;
|
||||
}
|
||||
|
||||
ULONG DEVAPI SKF_CreateFile(HAPPLICATION hApplication,
|
||||
LPSTR szFileName,
|
||||
ULONG ulFileSize,
|
||||
ULONG ulReadRights,
|
||||
ULONG ulWriteRights)
|
||||
{
|
||||
return SAR_NOTSUPPORTYETERR;
|
||||
}
|
||||
|
||||
ULONG DEVAPI SKF_DeleteFile(HAPPLICATION hApplication,
|
||||
LPSTR szFileName)
|
||||
{
|
||||
return SAR_NOTSUPPORTYETERR;
|
||||
}
|
||||
|
||||
ULONG DEVAPI SKF_EnumFiles(HAPPLICATION hApplication,
|
||||
LPSTR szFileList,
|
||||
ULONG *pulSize)
|
||||
{
|
||||
return SAR_NOTSUPPORTYETERR;
|
||||
}
|
||||
|
||||
ULONG DEVAPI SKF_GetFileInfo(HAPPLICATION hApplication,
|
||||
LPSTR szFileName,
|
||||
FILEATTRIBUTE *pFileInfo)
|
||||
{
|
||||
return SAR_NOTSUPPORTYETERR;
|
||||
}
|
||||
|
||||
ULONG DEVAPI SKF_ReadFile(HAPPLICATION hApplication,
|
||||
LPSTR szFileName,
|
||||
ULONG ulOffset,
|
||||
ULONG ulSize,
|
||||
BYTE * pbOutData,
|
||||
ULONG *pulOutLen)
|
||||
{
|
||||
return SAR_NOTSUPPORTYETERR;
|
||||
}
|
||||
|
||||
ULONG DEVAPI SKF_WriteFile(HAPPLICATION hApplication,
|
||||
LPSTR szFileName,
|
||||
ULONG ulOffset,
|
||||
BYTE *pbData,
|
||||
ULONG ulSize)
|
||||
{
|
||||
return SAR_NOTSUPPORTYETERR;
|
||||
}
|
||||
|
||||
ULONG DEVAPI SKF_CreateContainer(HAPPLICATION hApplication,
|
||||
LPSTR szContainerName,
|
||||
HCONTAINER *phContainer)
|
||||
{
|
||||
return SAR_NOTSUPPORTYETERR;
|
||||
}
|
||||
|
||||
ULONG DEVAPI SKF_DeleteContainer(HAPPLICATION hApplication,
|
||||
LPSTR szContainerName)
|
||||
{
|
||||
return SAR_NOTSUPPORTYETERR;
|
||||
}
|
||||
|
||||
ULONG DEVAPI SKF_EnumContainer(HAPPLICATION hApplication,
|
||||
LPSTR szContainerName,
|
||||
ULONG *pulSize)
|
||||
{
|
||||
if (!pulSize) {
|
||||
return SAR_INVALIDPARAMERR;
|
||||
}
|
||||
|
||||
if (hApplication != APP_HANDLE) {
|
||||
return SAR_FAIL;
|
||||
}
|
||||
|
||||
if (!szContainerName) {
|
||||
*pulSize = sizeof(CONTAINER_NAME_LIST);
|
||||
return SAR_OK;
|
||||
}
|
||||
|
||||
if (*pulSize < sizeof(CONTAINER_NAME_LIST)) {
|
||||
return SAR_BUFFER_TOO_SMALL;
|
||||
}
|
||||
|
||||
memcpy(szContainerName, CONTAINER_NAME_LIST, sizeof(CONTAINER_NAME_LIST));
|
||||
|
||||
return SAR_OK;
|
||||
}
|
||||
|
||||
ULONG DEVAPI SKF_OpenContainer(HAPPLICATION hApplication,
|
||||
LPSTR szContainerName,
|
||||
HCONTAINER *phContainer)
|
||||
{
|
||||
if (!szContainerName || !phContainer) {
|
||||
return SAR_INVALIDPARAMERR;
|
||||
}
|
||||
|
||||
if (hApplication != APP_HANDLE || memcmp(szContainerName, CONTAINER_NAME, sizeof(CONTAINER_NAME))) {
|
||||
return SAR_FAIL;
|
||||
}
|
||||
|
||||
*phContainer = CONTAINER_HANDLE;
|
||||
|
||||
return SAR_OK;
|
||||
}
|
||||
|
||||
ULONG DEVAPI SKF_CloseContainer(HCONTAINER hContainer)
|
||||
{
|
||||
if (hContainer != CONTAINER_HANDLE) {
|
||||
return SAR_FAIL;
|
||||
}
|
||||
|
||||
return SAR_OK;
|
||||
}
|
||||
|
||||
ULONG DEVAPI SKF_GetContainerType(HCONTAINER hContainer,
|
||||
ULONG *pulContainerType)
|
||||
{
|
||||
if (!pulContainerType) {
|
||||
return SAR_INVALIDPARAMERR;
|
||||
}
|
||||
|
||||
if (hContainer != CONTAINER_HANDLE) {
|
||||
return SAR_FAIL;
|
||||
}
|
||||
|
||||
*pulContainerType = CONTAINER_TYPE_UNDEF;
|
||||
|
||||
return SAR_OK;
|
||||
}
|
||||
|
||||
ULONG DEVAPI SKF_ImportCertificate(HCONTAINER hContainer,
|
||||
BOOL bSignFlag,
|
||||
BYTE *pbCert,
|
||||
ULONG ulCertLen)
|
||||
{
|
||||
return SAR_NOTSUPPORTYETERR;
|
||||
}
|
||||
|
||||
ULONG DEVAPI SKF_ExportCertificate(HCONTAINER hContainer,
|
||||
BOOL bSignFlag,
|
||||
BYTE* pbCert,
|
||||
ULONG *pulCertLen)
|
||||
{
|
||||
return SAR_NOTSUPPORTYETERR;
|
||||
}
|
||||
|
||||
ULONG DEVAPI SKF_GenRandom(DEVHANDLE hDev,
|
||||
BYTE *pbRandom,
|
||||
ULONG ulRandomLen)
|
||||
{
|
||||
/*
|
||||
if (!pbRandom || ulRandomLen > 100 * 1024 * 1024) {
|
||||
return SAR_INVALIDPARAMERR;
|
||||
}
|
||||
|
||||
if (hDev != DEV_HANDLE) {
|
||||
return SAR_FAIL;
|
||||
}
|
||||
|
||||
if (!RAND_pseudo_bytes(pbRandom, ulRandomLen)) {
|
||||
return SAR_GENRANDERR;
|
||||
}
|
||||
*/
|
||||
return SAR_OK;
|
||||
}
|
||||
|
||||
ULONG DEVAPI SKF_GenExtRSAKey(DEVHANDLE hDev,
|
||||
ULONG ulBitsLen,
|
||||
RSAPRIVATEKEYBLOB *pBlob)
|
||||
{
|
||||
return SAR_NOTSUPPORTYETERR;
|
||||
}
|
||||
|
||||
ULONG DEVAPI SKF_GenRSAKeyPair(HCONTAINER hContainer,
|
||||
ULONG ulBitsLen,
|
||||
RSAPUBLICKEYBLOB *pBlob)
|
||||
{
|
||||
return SAR_NOTSUPPORTYETERR;
|
||||
}
|
||||
|
||||
ULONG DEVAPI SKF_ImportRSAKeyPair(HCONTAINER hContainer,
|
||||
ULONG ulSymAlgId,
|
||||
BYTE *pbWrappedKey,
|
||||
ULONG ulWrappedKeyLen,
|
||||
BYTE *pbEncryptedData,
|
||||
ULONG ulEncryptedDataLen)
|
||||
{
|
||||
return SAR_NOTSUPPORTYETERR;
|
||||
}
|
||||
|
||||
ULONG DEVAPI SKF_RSASignData(HCONTAINER hContainer,
|
||||
BYTE *pbData,
|
||||
ULONG ulDataLen,
|
||||
BYTE *pbSignature,
|
||||
ULONG *pulSignLen)
|
||||
{
|
||||
return SAR_NOTSUPPORTYETERR;
|
||||
}
|
||||
|
||||
ULONG DEVAPI SKF_RSAVerify(DEVHANDLE hDev,
|
||||
RSAPUBLICKEYBLOB *pRSAPubKeyBlob,
|
||||
BYTE *pbData,
|
||||
ULONG ulDataLen,
|
||||
BYTE *pbSignature,
|
||||
ULONG ulSignLen)
|
||||
{
|
||||
return SAR_NOTSUPPORTYETERR;
|
||||
}
|
||||
|
||||
ULONG DEVAPI SKF_RSAExportSessionKey(HCONTAINER hContainer,
|
||||
ULONG ulAlgId,
|
||||
RSAPUBLICKEYBLOB *pPubKey,
|
||||
BYTE *pbData,
|
||||
ULONG *pulDataLen,
|
||||
HANDLE *phSessionKey)
|
||||
{
|
||||
return SAR_NOTSUPPORTYETERR;
|
||||
}
|
||||
|
||||
ULONG DEVAPI SKF_ExtRSAPubKeyOperation(DEVHANDLE hDev,
|
||||
RSAPUBLICKEYBLOB *pRSAPubKeyBlob,
|
||||
BYTE *pbInput,
|
||||
ULONG ulInputLen,
|
||||
BYTE *pbOutput,
|
||||
ULONG *pulOutputLen)
|
||||
{
|
||||
return SAR_NOTSUPPORTYETERR;
|
||||
}
|
||||
|
||||
ULONG DEVAPI SKF_ExtRSAPriKeyOperation(DEVHANDLE hDev,
|
||||
RSAPRIVATEKEYBLOB *pRSAPriKeyBlob,
|
||||
BYTE *pbInput,
|
||||
ULONG ulInputLen,
|
||||
BYTE *pbOutput,
|
||||
ULONG *pulOutputLen)
|
||||
{
|
||||
return SAR_NOTSUPPORTYETERR;
|
||||
}
|
||||
|
||||
ULONG DEVAPI SKF_GenECCKeyPair(HCONTAINER hContainer,
|
||||
ULONG ulAlgId,
|
||||
ECCPUBLICKEYBLOB *pBlob)
|
||||
{
|
||||
return SAR_NOTSUPPORTYETERR;
|
||||
}
|
||||
|
||||
ULONG DEVAPI SKF_ImportECCKeyPair(HCONTAINER hContainer,
|
||||
PENVELOPEDKEYBLOB pEnvelopedKeyBlob)
|
||||
{
|
||||
return SAR_NOTSUPPORTYETERR;
|
||||
}
|
||||
|
||||
ULONG DEVAPI SKF_ECCSignData(HCONTAINER hContainer,
|
||||
BYTE *pbData,
|
||||
ULONG ulDataLen,
|
||||
PECCSIGNATUREBLOB pSignature)
|
||||
{
|
||||
return SAR_NOTSUPPORTYETERR;
|
||||
}
|
||||
|
||||
ULONG DEVAPI SKF_ECCVerify(DEVHANDLE hDev,
|
||||
ECCPUBLICKEYBLOB *pECCPubKeyBlob,
|
||||
BYTE *pbData,
|
||||
ULONG ulDataLen,
|
||||
PECCSIGNATUREBLOB pSignature)
|
||||
{
|
||||
return SAR_NOTSUPPORTYETERR;
|
||||
}
|
||||
|
||||
ULONG DEVAPI SKF_ECCExportSessionKey(HCONTAINER hContainer,
|
||||
ULONG ulAlgId,
|
||||
ECCPUBLICKEYBLOB *pPubKey,
|
||||
PECCCIPHERBLOB pData,
|
||||
HANDLE *phSessionKey)
|
||||
{
|
||||
return SAR_NOTSUPPORTYETERR;
|
||||
}
|
||||
|
||||
ULONG DEVAPI SKF_ExtECCEncrypt(DEVHANDLE hDev,
|
||||
ECCPUBLICKEYBLOB *pECCPubKeyBlob,
|
||||
BYTE *pbPlainText,
|
||||
ULONG ulPlainTextLen,
|
||||
PECCCIPHERBLOB pCipherText)
|
||||
{
|
||||
return SAR_NOTSUPPORTYETERR;
|
||||
}
|
||||
|
||||
ULONG DEVAPI SKF_ExtECCDecrypt(DEVHANDLE hDev,
|
||||
ECCPRIVATEKEYBLOB *pECCPriKeyBlob,
|
||||
PECCCIPHERBLOB pCipherText,
|
||||
BYTE *pbPlainText,
|
||||
ULONG *pulPlainTextLen)
|
||||
{
|
||||
return SAR_NOTSUPPORTYETERR;
|
||||
}
|
||||
|
||||
ULONG DEVAPI SKF_ExtECCSign(DEVHANDLE hDev,
|
||||
ECCPRIVATEKEYBLOB *pECCPriKeyBlob,
|
||||
BYTE *pbData,
|
||||
ULONG ulDataLen,
|
||||
PECCSIGNATUREBLOB pSignature)
|
||||
{
|
||||
return SAR_NOTSUPPORTYETERR;
|
||||
}
|
||||
|
||||
ULONG DEVAPI SKF_ExtECCVerify(DEVHANDLE hDev,
|
||||
ECCPUBLICKEYBLOB *pECCPubKeyBlob,
|
||||
BYTE *pbData,
|
||||
ULONG ulDataLen,
|
||||
PECCSIGNATUREBLOB pSignature)
|
||||
{
|
||||
return SAR_NOTSUPPORTYETERR;
|
||||
}
|
||||
|
||||
ULONG DEVAPI SKF_GenerateAgreementDataWithECC(HCONTAINER hContainer,
|
||||
ULONG ulAlgId,
|
||||
ECCPUBLICKEYBLOB *pTempECCPubKeyBlob,
|
||||
BYTE *pbID,
|
||||
ULONG ulIDLen,
|
||||
HANDLE *phAgreementHandle)
|
||||
{
|
||||
return SAR_NOTSUPPORTYETERR;
|
||||
}
|
||||
|
||||
ULONG DEVAPI SKF_GenerateAgreementDataAndKeyWithECC(HANDLE hContainer,
|
||||
ULONG ulAlgId,
|
||||
ECCPUBLICKEYBLOB *pSponsorECCPubKeyBlob,
|
||||
ECCPUBLICKEYBLOB *pSponsorTempECCPubKeyBlob,
|
||||
ECCPUBLICKEYBLOB *pTempECCPubKeyBlob,
|
||||
BYTE *pbID,
|
||||
ULONG ulIDLen,
|
||||
BYTE *pbSponsorID,
|
||||
ULONG ulSponsorIDLen,
|
||||
HANDLE *phKeyHandle)
|
||||
{
|
||||
return SAR_NOTSUPPORTYETERR;
|
||||
}
|
||||
|
||||
ULONG DEVAPI SKF_GenerateKeyWithECC(HANDLE hAgreementHandle,
|
||||
ECCPUBLICKEYBLOB *pECCPubKeyBlob,
|
||||
ECCPUBLICKEYBLOB *pTempECCPubKeyBlob,
|
||||
BYTE *pbID,
|
||||
ULONG ulIDLen,
|
||||
HANDLE *phKeyHandle)
|
||||
{
|
||||
return SAR_NOTSUPPORTYETERR;
|
||||
}
|
||||
|
||||
ULONG DEVAPI SKF_ExportPublicKey(HCONTAINER hContainer,
|
||||
BOOL bSignFlag,
|
||||
BYTE* pbBlob,
|
||||
ULONG* pulBlobLen)
|
||||
{
|
||||
return SAR_NOTSUPPORTYETERR;
|
||||
}
|
||||
|
||||
ULONG DEVAPI SKF_ImportSessionKey(HCONTAINER hContainer,
|
||||
ULONG ulAlgId,
|
||||
BYTE *pbWrapedData,
|
||||
ULONG ulWrapedLen,
|
||||
HANDLE *phKey)
|
||||
{
|
||||
return SAR_NOTSUPPORTYETERR;
|
||||
}
|
||||
|
||||
ULONG DEVAPI SKF_SetSymmKey(DEVHANDLE hDev,
|
||||
BYTE *pbKey,
|
||||
ULONG ulAlgID,
|
||||
HANDLE *phKey)
|
||||
{
|
||||
return SAR_NOTSUPPORTYETERR;
|
||||
}
|
||||
|
||||
ULONG DEVAPI SKF_EncryptInit(HANDLE hKey,
|
||||
BLOCKCIPHERPARAM EncryptParam)
|
||||
{
|
||||
return SAR_NOTSUPPORTYETERR;
|
||||
}
|
||||
|
||||
ULONG DEVAPI SKF_Encrypt(HANDLE hKey,
|
||||
BYTE *pbData,
|
||||
ULONG ulDataLen,
|
||||
BYTE *pbEncryptedData,
|
||||
ULONG *pulEncryptedLen)
|
||||
{
|
||||
return SAR_NOTSUPPORTYETERR;
|
||||
}
|
||||
|
||||
ULONG DEVAPI SKF_EncryptUpdate(HANDLE hKey,
|
||||
BYTE *pbData,
|
||||
ULONG ulDataLen,
|
||||
BYTE *pbEncryptedData,
|
||||
ULONG *pulEncryptedLen)
|
||||
{
|
||||
return SAR_NOTSUPPORTYETERR;
|
||||
}
|
||||
|
||||
ULONG DEVAPI SKF_EncryptFinal(HANDLE hKey,
|
||||
BYTE *pbEncryptedData,
|
||||
ULONG *pulEncryptedDataLen)
|
||||
{
|
||||
return SAR_NOTSUPPORTYETERR;
|
||||
}
|
||||
|
||||
ULONG DEVAPI SKF_DecryptInit(HANDLE hKey,
|
||||
BLOCKCIPHERPARAM DecryptParam)
|
||||
{
|
||||
return SAR_NOTSUPPORTYETERR;
|
||||
}
|
||||
|
||||
ULONG DEVAPI SKF_Decrypt(HANDLE hKey,
|
||||
BYTE *pbEncryptedData,
|
||||
ULONG ulEncryptedLen,
|
||||
BYTE *pbData,
|
||||
ULONG *pulDataLen)
|
||||
{
|
||||
return SAR_NOTSUPPORTYETERR;
|
||||
}
|
||||
|
||||
ULONG DEVAPI SKF_DecryptUpdate(HANDLE hKey,
|
||||
BYTE *pbEncryptedData,
|
||||
ULONG ulEncryptedLen,
|
||||
BYTE *pbData,
|
||||
ULONG *pulDataLen)
|
||||
{
|
||||
return SAR_NOTSUPPORTYETERR;
|
||||
}
|
||||
|
||||
ULONG DEVAPI SKF_DecryptFinal(HANDLE hKey,
|
||||
BYTE *pbDecryptedData,
|
||||
ULONG *pulDecryptedDataLen)
|
||||
{
|
||||
return SAR_NOTSUPPORTYETERR;
|
||||
}
|
||||
|
||||
ULONG DEVAPI SKF_DigestInit(DEVHANDLE hDev,
|
||||
ULONG ulAlgID,
|
||||
ECCPUBLICKEYBLOB *pPubKey,
|
||||
BYTE *pucID,
|
||||
ULONG ulIDLen,
|
||||
HANDLE *phHash)
|
||||
{
|
||||
return SAR_OK;
|
||||
}
|
||||
|
||||
ULONG DEVAPI SKF_Digest(HANDLE hHash,
|
||||
BYTE *pbData,
|
||||
ULONG ulDataLen,
|
||||
BYTE *pbHashData,
|
||||
ULONG *pulHashLen)
|
||||
{
|
||||
return SAR_OK;
|
||||
}
|
||||
|
||||
ULONG DEVAPI SKF_DigestUpdate(HANDLE hHash,
|
||||
BYTE *pbData,
|
||||
ULONG ulDataLen)
|
||||
{
|
||||
return SAR_OK;
|
||||
}
|
||||
|
||||
ULONG DEVAPI SKF_DigestFinal(HANDLE hHash,
|
||||
BYTE *pHashData,
|
||||
ULONG *pulHashLen)
|
||||
{
|
||||
return SAR_OK;
|
||||
}
|
||||
|
||||
ULONG DEVAPI SKF_MacInit(HANDLE hKey,
|
||||
BLOCKCIPHERPARAM *pMacParam,
|
||||
HANDLE *phMac)
|
||||
{
|
||||
return SAR_NOTSUPPORTYETERR;
|
||||
}
|
||||
|
||||
ULONG DEVAPI SKF_Mac(HANDLE hMac,
|
||||
BYTE *pbData,
|
||||
ULONG ulDataLen,
|
||||
BYTE *pbMacData,
|
||||
ULONG *pulMacLen)
|
||||
{
|
||||
return SAR_NOTSUPPORTYETERR;
|
||||
}
|
||||
|
||||
ULONG DEVAPI SKF_MacUpdate(HANDLE hMac,
|
||||
BYTE *pbData,
|
||||
ULONG ulDataLen)
|
||||
{
|
||||
return SAR_NOTSUPPORTYETERR;
|
||||
}
|
||||
|
||||
ULONG DEVAPI SKF_MacFinal(HANDLE hMac,
|
||||
BYTE *pbMacData,
|
||||
ULONG *pulMacDataLen)
|
||||
{
|
||||
return SAR_NOTSUPPORTYETERR;
|
||||
}
|
||||
|
||||
ULONG DEVAPI SKF_CloseHandle(HANDLE hHandle)
|
||||
{
|
||||
return SAR_NOTSUPPORTYETERR;
|
||||
}
|
||||
|
||||
100
engines/skf/skftest.c
Normal file
100
engines/skf/skftest.c
Normal file
@@ -0,0 +1,100 @@
|
||||
#include <stdio.h>
|
||||
#include <string.h>
|
||||
#include <stdlib.h>
|
||||
#include <assert.h>
|
||||
#include "skf.h"
|
||||
|
||||
int main(int argc, char **argv)
|
||||
{
|
||||
ULONG rv;
|
||||
ULONG len;
|
||||
|
||||
BOOL bPresent = TRUE;
|
||||
CHAR devNameList[256];
|
||||
LPSTR devName;
|
||||
DEVHANDLE hDev;
|
||||
ULONG devState;
|
||||
DEVINFO devInfo;
|
||||
BYTE authData[16];
|
||||
|
||||
CHAR appNameList[256];
|
||||
LPSTR appName;
|
||||
HAPPLICATION hApp;
|
||||
|
||||
CHAR containerNameList[256];
|
||||
LPSTR containerName;
|
||||
HCONTAINER hContainer;
|
||||
ULONG containerType;
|
||||
|
||||
len = sizeof(devNameList);
|
||||
rv = SKF_EnumDev(bPresent, devNameList, &len);
|
||||
assert(rv == SAR_OK);
|
||||
|
||||
devName = devNameList;
|
||||
printf(" Device Name : %s\n", devName);
|
||||
|
||||
rv = SKF_GetDevState(devName, &devState);
|
||||
assert(rv == SAR_OK);
|
||||
printf(" Device State: %ld\n", devState);
|
||||
|
||||
rv = SKF_ConnectDev(devName, &hDev);
|
||||
assert(rv == SAR_OK);
|
||||
|
||||
rv = SKF_GetDevInfo(hDev, &devInfo);
|
||||
assert(rv == SAR_OK);
|
||||
|
||||
printf(" Device 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);
|
||||
printf(" Serial Number : %s\n", 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(" AlgSymCap : 0x%08x\n", devInfo.AlgSymCap);
|
||||
printf(" AlgAsymCap : 0x%08x\n", devInfo.AlgAsymCap);
|
||||
printf(" AlgHashCap : 0x%08x\n", devInfo.AlgHashCap);
|
||||
printf(" AlgHashCap : 0x%08x\n", devInfo.DevAuthAlgId);
|
||||
printf(" Total Space : %ld\n", devInfo.TotalSpace);
|
||||
printf(" Free Space : %ld\n", devInfo.FreeSpace);
|
||||
printf(" MaxECCBuffer : %ld\n", devInfo.MaxECCBufferSize);
|
||||
printf(" MaxBuffer : %ld\n", devInfo.MaxBufferSize);
|
||||
|
||||
rv = SKF_DevAuth(hDev, authData, sizeof(authData));
|
||||
assert(rv == SAR_OK);
|
||||
|
||||
|
||||
len = sizeof(appNameList);
|
||||
rv = SKF_EnumApplication(hDev, appNameList, &len);
|
||||
assert(rv == SAR_OK);
|
||||
|
||||
appName = appNameList;
|
||||
printf("Application Name : %s\n", appName);
|
||||
|
||||
rv = SKF_OpenApplication(hDev, appName, &hApp);
|
||||
assert(rv == SAR_OK);
|
||||
|
||||
len = sizeof(containerNameList);
|
||||
rv = SKF_EnumContainer(hApp, containerNameList, &len);
|
||||
assert(rv == SAR_OK);
|
||||
|
||||
containerName = containerNameList;
|
||||
printf("Container Name: %s\n", containerName);
|
||||
|
||||
rv = SKF_OpenContainer(hApp, containerName, &hContainer);
|
||||
assert(rv == SAR_OK);
|
||||
|
||||
rv = SKF_GetContainerType(hContainer, &containerType);
|
||||
assert(rv == SAR_OK);
|
||||
|
||||
printf("Container Type: %ld\n", containerType);
|
||||
|
||||
|
||||
rv = SKF_CloseContainer(hContainer);
|
||||
assert(rv == SAR_OK);
|
||||
|
||||
rv = SKF_CloseApplication(hApp);
|
||||
assert(rv == SAR_OK);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
Reference in New Issue
Block a user