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

fast SMS4 with Intel AVX2/KNC-NI

Browse Source
This commit is contained in:
Zhi Guan
2016-05-09 09:20:02 +02:00
parent addcac4896
commit 8c0439e7d6
83 changed files with 3536 additions and 5882 deletions
Download Patch File Download Diff File Expand all files Collapse all files

200
engines/skf/skftest.c
View File

@@ -4,45 +4,81 @@
#include <assert.h>
#include "skf.h"
#define AUTH_RAND_LEN 16
#define AUTH_DATA_LEN 16
#define AUTH_KEY_LEN 16
int main(int argc, char **argv)
{
ULONG rv;
BYTE buf[2048];
ULONG len;
BOOL bPresent = TRUE;
CHAR devNameList[256];
LPSTR devName;
DEVHANDLE hDev;
DEVHANDLE hDev = NULL;
ULONG devState;
char *devStateStr;
DEVINFO devInfo;
BYTE authData[16];
BYTE authRand[AUTH_RAND_LEN];
BYTE authData[AUTH_DATA_LEN];
BYTE authKey[AUTH_KEY_LEN];
BLOCKCIPHERPARAM authParam;
HANDLE hAuthKey = NULL;
CHAR appNameList[256];
LPSTR appName;
HAPPLICATION hApp;
HAPPLICATION hApp = NULL;
CHAR containerNameList[256];
LPSTR containerName;
HCONTAINER hContainer;
HCONTAINER hContainer = NULL;
ULONG containerType;
char *containerTypeStr;
BYTE dgst[32];
ULONG dgstLen = sizeof(dgst);
ECCSIGNATUREBLOB sigblob;
len = sizeof(devNameList);
rv = SKF_EnumDev(bPresent, devNameList, &len);
assert(rv == SAR_OK);
if ((rv = SKF_EnumDev(bPresent, devNameList, &len)) != SAR_OK) {
goto end;
}
devName = devNameList;
printf(" Device Name : %s\n", devName);
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);
if ((rv = SKF_GetDevState(devName, &devState)) != SAR_OK) {
goto end;
}
rv = SKF_GetDevInfo(hDev, &devInfo);
assert(rv == SAR_OK);
switch (devState) {
case DEV_ABSENT_STATE:
devStateStr = "DEV_ABSENT_STATE";
break;
case DEV_PRESENT_STATE:
devStateStr = "DEV_PRESENT_STATE";
break;
case DEV_UNKNOW_STATE:
devStateStr = "DEV_UNKNOW_STATE";
break;
default:
devStateStr = "(undefined)";
}
printf("Device State: %s\n", devStateStr);
if ((rv = SKF_ConnectDev(devName, &hDev)) != SAR_OK) {
goto end;
}
if ((rv = SKF_GetDevInfo(hDev, &devInfo)) != SAR_OK) {
goto end;
}
printf("Device Info:\n");
printf(" Device Version : %d.%d\n", devInfo.Version.major, devInfo.Version.minor);
printf(" Manufacturer : %s\n", devInfo.Manufacturer);
printf(" Issuer : %s\n", devInfo.Issuer);
@@ -54,67 +90,119 @@ int main(int argc, char **argv)
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);
printf(" Total Space : %u\n", devInfo.TotalSpace);
printf(" Free Space : %u\n", devInfo.FreeSpace);
printf(" MaxECCBuffer : %u\n", devInfo.MaxECCBufferSize);
printf(" MaxBuffer : %u\n", devInfo.MaxBufferSize);
/* Device Authentication */
if ((rv = SKF_GenRandom(hDev, authRand, sizeof(authRand))) != SAR_OK) {
fprintf(stderr, "error: %s %d\n", __FILE__, __LINE__);
goto end;
}
ULONG ulAuthAlgId = devInfo.DevAuthAlgId;
unsigned char pbAuthKey[16] = {0};
if ((rv = SKF_SetSymmKey(hDev, authKey, devInfo.DevAuthAlgId, &hAuthKey)) != SAR_OK) {
fprintf(stderr, "error: %s %d\n", __FILE__, __LINE__);
goto end;
}
bzero(&authParam, sizeof(authParam));
if ((rv = SKF_EncryptInit(hAuthKey, authParam)) != SAR_OK) {
fprintf(stderr, "error: %s %d\n", __FILE__, __LINE__);
goto end;
}
if ((rv = SKF_Encrypt(hAuthKey, authRand, sizeof(authRand), authData, &len)) != SAR_OK) {
fprintf(stderr, "error: %s %d\n", __FILE__, __LINE__);
goto end;
}
if ((rv = SKF_DevAuth(hDev, authData, len)) != SAR_OK) {
fprintf(stderr, "error: %s %d\n", __FILE__, __LINE__);
goto end;
}
printf("Device Authentication Passed.\n");
/* get the DevAuth challenge from GenRandom API
* encrypt challenge with DevAuthKey
*/
rv = SKF_GenRandom(hDev, authRandom, sizeof(authRandom));
rv = SKF_EncryptInit(hKey, param);
rv = SKF_Encrypt(hKey, authRandom, 16, authResponse, &ulAuthLen);
rv = SKF_DevAuth(hDev, authData, authDataLen);
assert(rv == SAR_OK);
/*
*/
/* Open Application */
len = sizeof(appNameList);
rv = SKF_EnumApplication(hDev, appNameList, &len);
assert(rv == SAR_OK);
if ((rv = SKF_EnumApplication(hDev, appNameList, &len)) != SAR_OK) {
goto end;
}
appName = appNameList;
printf("Application Name : %s\n", appName);
rv = SKF_OpenApplication(hDev, appName, &hApp);
assert(rv == SAR_OK);
if ((rv = SKF_OpenApplication(hDev, appName, &hApp)) != SAR_OK) {
goto end;
}
/* Open Containter */
len = sizeof(containerNameList);
rv = SKF_EnumContainer(hApp, containerNameList, &len);
assert(rv == SAR_OK);
if ((rv = SKF_EnumContainer(hApp, containerNameList, &len)) != SAR_OK) {
goto end;
}
containerName = containerNameList;
printf("Container Name: %s\n", containerName);
rv = SKF_OpenContainer(hApp, containerName, &hContainer);
assert(rv == SAR_OK);
if ((rv = SKF_OpenContainer(hApp, containerName, &hContainer)) != SAR_OK) {
goto end;
}
rv = SKF_GetContainerType(hContainer, &containerType);
assert(rv == SAR_OK);
if ((rv = SKF_GetContainerType(hContainer, &containerType)) != SAR_OK) {
goto end;
}
printf("Container Type: %ld\n", containerType);
switch (containerType) {
case CONTAINER_TYPE_UNDEF:
containerTypeStr = "Undef";
break;
case CONTAINER_TYPE_RSA:
containerTypeStr = "RSA";
break;
case CONTAINER_TYPE_ECC:
containerTypeStr = "ECC";
break;
default:
containerTypeStr = "(error)";
}
printf("Container Type: %s\n", containerTypeStr);
rv = SKF_CloseContainer(hContainer);
assert(rv == SAR_OK);
/* Sign */
if ((rv = SKF_ECCSignData(hContainer, dgst, dgstLen, &sigblob)) != SAR_OK) {
goto end;
}
rv = SKF_CloseApplication(hApp);
assert(rv == SAR_OK);
/* Export Signing Public Key */
if ((rv = SKF_ExportPublicKey(hContainer, TRUE, buf, &len)) != SAR_OK) {
goto end;
}
printf("Success\n");
end:
//SKF_CloseContainer(hContainer);
//SKF_CloseApplication(hApp);
return 0;
}
int open_container(const char *dev, const char *app, const char *container,
const unsigned char *authkey, size_t authkeylen)
{
DEVHANDLE hDev = NULL;
DEVINFO devInfo;
HAPPLICATION hApp = NULL;
HCONTAINER hContainer = NULL;
return 0;
}