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

jni api

Browse Source
This commit is contained in:
Zhi Guan
2016-06-06 22:04:44 +02:00
parent 2bf25bd29f
commit 2cb43b7f80
142 changed files with 7768 additions and 1678 deletions
Download Patch File Download Diff File Expand all files Collapse all files

4
crypto/skf/Makefile
View File

@@ -65,6 +65,8 @@ tests:
lint:
lint -DLINT $(INCLUDES) $(SRC)>fluff
update: depend
depend:
@[ -n "$(MAKEDEPEND)" ] # should be set by upper Makefile...
$(MAKEDEPEND) -- $(CFLAG) $(INCLUDES) $(DEPFLAG) -- $(PROGS) $(LIBSRC)
@@ -74,7 +76,7 @@ dclean:
mv -f Makefile.new $(MAKEFILE)
clean:
rm -f *.o *.obj lib tags core .pure .nfs* *.old *.bak fluff
rm -f *.o *.obj lib tags core .pure .nfs* *.old *.bak fluff a.out
# DO NOT DELETE THIS LINE -- make depend depends on it.

2
crypto/skf/skf.h
View File

@@ -1,6 +1,6 @@
/* crypto/skf/skf.h */
/* ====================================================================
* Copyright (c) 2014 - 2015 The GmSSL Project. All rights reserved.
* Copyright (c) 2014 - 2016 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

33
crypto/skf/skf_dev.c
View File

@@ -58,6 +58,7 @@
#define DEV_NAME "pseudo_dev"
#define DEV_NAME_LIST DEV_NAME"\0"
SKF_HANDLE skf_dev_handle;
ULONG DEVAPI SKF_EnumDev(BOOL bPresent,
LPSTR szNameList,
@@ -79,11 +80,14 @@ ULONG DEVAPI SKF_EnumDev(BOOL bPresent,
ULONG DEVAPI SKF_ConnectDev(LPSTR szName,
DEVHANDLE *phDev)
{
*phDev = &skf_dev_handle;
return SAR_OK;
}
ULONG DEVAPI SKF_DisConnectDev(DEVHANDLE hDev)
{
//FIXME: close all handles
hDev = NULL;
return SAR_OK;
}
@@ -155,4 +159,33 @@ int SKF_print_dev_info(DEVINFO *devInfo)
return 1;
}
char *SKF_get_alg_name(ULONG ulAlgID)
{
//FIXME: make these name compatible with OBJ short name
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-OFB";
case SGD_SM1_MAC: return "SM1-MAC";
case SGD_SM4_ECB: return "SM4-ECB";
case SGD_SM4_CBC: return "SM4-CBC";
case SGD_SM4_CFB: return "SM4-CFB";
case SGD_SM4_OFB: return "SM4-OFB";
case SGD_SM4_MAC: return "SM4-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-OFB";
case SGD_SSF33_MAC: return "SSF33-MAC";
case SGD_RSA: return "RSA";
case SGD_SM2_1: return "SM2-1";
case SGD_SM2_2: return "SM2-2";
case SGD_SM2_3: return "SM2-3";
case SGD_SM3: return "SM3";
case SGD_SHA1: return "SHA-1";
case SGD_SHA256: return "SHA256";
}
return "(unknown)";
}

22
crypto/skf/skf_dgst.c
View File

@@ -67,7 +67,7 @@ ULONG DEVAPI SKF_DigestInit(DEVHANDLE hDev,
const EVP_MD *md;
EVP_MD_CTX *mdctx = NULL;
EC_KEY *ec_key = NULL;
SKF_HANDLE *handle;
SKF_HANDLE *hHash;
unsigned char dgst[EVP_MAX_MD_SIZE];
unsigned int dgstlen = 0;
@@ -137,17 +137,20 @@ ULONG DEVAPI SKF_DigestInit(DEVHANDLE hDev,
}
}
if (!(handle = SKF_HANDLE_new(SKF_HASH_HANDLE))) {
SKFerr(SKF_F_SKF_DIGESTINIT, SKF_R_MALLOC_FAILED);
ret = SAR_MEMORYERR;
if (!(hHash = OPENSSL_malloc(sizeof(*hHash)))) {
SKFerr(SKF_F_SKF_DIGESTINIT, ERR_R_MALLOC_FAILURE);
goto end;
}
handle->u.md_ctx = mdctx;
bzero(hHash, sizeof(*hHash));
hHash->magic = SKF_HANDLE_MAGIC;
hHash->type = SKF_HASH_HANDLE;
hHash->u.md_ctx = mdctx;
mdctx = NULL;
*phHash = hHash;
ret = SAR_OK;
end:
EVP_MD_CTX_destroy(mdctx);
EC_KEY_free(ec_key);
@@ -204,11 +207,8 @@ ULONG DEVAPI SKF_DigestFinal(HANDLE hHash,
return SAR_FAIL;
}
if (!SKF_HANDLE_free(hHash)) {
SKFerr(SKF_F_SKF_DIGESTFINAL, SKF_R_FREE_HANDLE_FAILED);
return SAR_FAIL;
}
EVP_MD_CTX_destroy(mdctx);
((SKF_HANDLE *)hHash)->u.md_ctx = NULL;
return SAR_OK;
}

24
crypto/skf/skf_ec.c
View File

@@ -56,6 +56,30 @@
#include <openssl/skf_ex.h>
#include "skf_lcl.h"
ULONG DEVAPI SKF_GenExtECCKeyPair(DEVHANDLE hDev,
ECCPRIVATEKEYBLOB *priKey,
ECCPUBLICKEYBLOB *pubKey)
{
ULONG ret = SAR_FAIL;
EC_KEY *ec_key;
if(!(ec_key = EC_KEY_new_by_curve_name(NID_sm2p256v1))) {
SKFerr(SKF_F_SKF_GENEXTECCKEYPAIR, ERR_R_EC_LIB);
return SAR_FAIL;
}
if (!EC_KEY_get_ECCPRIVATEKEYBLOB(ec_key, priKey)) {
SKFerr(SKF_F_SKF_GENEXTECCKEYPAIR, SKF_R_GET_PRIVATE_KEY_FAILED);
goto end;
}
if (!EC_KEY_get_ECCPUBLICKEYBLOB(ec_key, pubKey)) {
SKFerr(SKF_F_SKF_GENEXTECCKEYPAIR, SKF_R_GET_PUBLIC_KEY_FAILED);
goto end;
}
ret = SAR_OK;
end:
EC_KEY_free(ec_key);
return ret;
}
ULONG DEVAPI SKF_ExtECCSign(DEVHANDLE hDev,
ECCPRIVATEKEYBLOB *pECCPriKeyBlob,

138
crypto/skf/skf_enc.c
View File

@@ -59,6 +59,101 @@
#define PADDING_TYPE_NO_PADDING 0
#define PADDING_TYPE_PKCS5 1
/*
229 typedef struct Struct_BLOCKCIPHERPARAM {
230 BYTE IV[MAX_IV_LEN];
231 ULONG IVLen;
232 ULONG PaddingType;
233 ULONG FeedBitLen;
234 } BLOCKCIPHERPARAM, *PBLOCKCIPHERPARAM;
*/
int SKF_nid_to_encparams(int nid, ULONG *algID, BLOCKCIPHERPARAM *params)
{
ULONG ulAlgID = 0;
switch (nid) {
case NID_ssf33_ecb:
ulAlgID = SGD_SSF33_ECB;
break;
case NID_ssf33_cbc:
ulAlgID = SGD_SSF33_CBC;
break;
case NID_ssf33_cfb1:
case NID_ssf33_cfb8:
case NID_ssf33_cfb128:
ulAlgID = SGD_SSF33_CFB;
break;
case NID_ssf33_ofb128:
ulAlgID = SGD_SSF33_OFB;
break;
case NID_sm1_ecb:
ulAlgID = SGD_SM1_ECB;
break;
case NID_sm1_cbc:
ulAlgID = SGD_SM1_CBC;
break;
case NID_sm1_cfb1:
case NID_sm1_cfb8:
case NID_sm1_cfb128:
ulAlgID = SGD_SM1_CFB;
break;
case NID_sm1_ofb128:
ulAlgID = SGD_SM1_OFB;
break;
case NID_sms4_ecb:
ulAlgID = SGD_SM4_ECB;
break;
case NID_sms4_cbc:
ulAlgID = SGD_SM4_CBC;
break;
case NID_sms4_cfb1:
case NID_sms4_cfb8:
case NID_sms4_cfb128:
ulAlgID = SGD_SM4_CFB;
break;
case NID_sms4_ofb128:
ulAlgID = SGD_SM4_OFB;
break;
default:
return 0;
}
*algID = ulAlgID;
switch (nid) {
case NID_sm1_cfb1:
case NID_sms4_cfb1:
case NID_ssf33_cfb1:
params->FeedBitLen = 1;
break;
case NID_sm1_cfb8:
case NID_sms4_cfb8:
case NID_ssf33_cfb8:
params->FeedBitLen = 8;
break;
case NID_sm1_cfb128:
case NID_sms4_cfb128:
case NID_ssf33_cfb128:
params->FeedBitLen = 128;
break;
default:
params->FeedBitLen = 0;
}
switch (nid) {
case NID_sm1_cbc:
case NID_sms4_cbc:
case NID_ssf33_cbc:
params->PaddingType = SKF_PKCS5_PADDING;
break;
default:
params->PaddingType = SKF_NO_PADDING;
}
return 1;
}
ULONG DEVAPI SKF_EncryptInit(HANDLE hKey,
BLOCKCIPHERPARAM encryptParam)
@@ -70,25 +165,25 @@ ULONG DEVAPI SKF_EncryptInit(HANDLE hKey,
unsigned char *key;
unsigned char *iv;
//FIXME: CFB bits!
if (!(cipher = SKF_HANDLE_get_cipher(hKey, encparam))) {
SKFerr(SKF_F_SKF_ENCRYPTINIT, SKF_R_INVALID_KEY_HANDLE);
return SAR_INVALIDPARAMERR;
}
if (!(key = SKF_HANDLE_get_key(hKey))) {
SKFerr(SKF_F_SKF_ENCRYPTINIT, SKF_R_INVALID_KEY_HANDLE);
ret = SAR_INVALIDPARAMERR;
goto end;
return SAR_INVALIDPARAMERR;
}
if (encparam->IVLen != SMS4_IV_LENGTH) {
SKFerr(SKF_F_SKF_ENCRYPTINIT, SKF_R_INVALID_IV_LENGTH);
ret = SAR_INVALIDPARAMERR;
goto end;
return SAR_INVALIDPARAMERR;
}
iv = encparam->IV;
if (!(ctx = EVP_CIPHER_CTX_new())) {
SKFerr(SKF_F_SKF_ENCRYPTINIT, ERR_R_EVP_LIB);
goto end;
return SAR_INVALIDPARAMERR;
}
if (!EVP_EncryptInit_ex(ctx, cipher, NULL, key, iv)) {
@@ -96,10 +191,8 @@ ULONG DEVAPI SKF_EncryptInit(HANDLE hKey,
goto end;
}
if (!SKF_HANDLE_set1_cipher_ctx(hKey, ctx)) {
SKFerr(SKF_F_SKF_ENCRYPTINIT, SKF_R_SET_CIPHER_CTX_FAILED);
goto end;
}
((SKF_HANDLE *)hKey)->type = SKF_CIPHER_HANDLE;
((SKF_HANDLE *)hKey)->u.cipher_ctx = ctx;
ctx = NULL;
ret = SAR_OK;
@@ -153,7 +246,9 @@ ULONG DEVAPI SKF_EncryptFinal(HANDLE hKey,
}
*pulEncryptedDataLen = outlen;
SKF_HANDLE_free_cipher_ctx(hKey);
EVP_CIPHER_CTX_free(ctx);
((SKF_HANDLE *)hKey)->u.cipher_ctx = NULL;
((SKF_HANDLE *)hKey)->type = SKF_KEY_HANDLE;
return SAR_OK;
}
@@ -167,18 +262,19 @@ ULONG DEVAPI SKF_DecryptInit(HANDLE hKey,
unsigned char *key;
unsigned char *iv;
if (!(cipher = SKF_HANDLE_get_cipher(hKey, param))) {
SKFerr(SKF_F_SKF_DECRYPTINIT, SKF_R_INVALID_KEY_HANDLE);
return SAR_INVALIDPARAMERR;
}
if (!(key = SKF_HANDLE_get_key(hKey))) {
SKFerr(SKF_F_SKF_DECRYPTINIT, SKF_R_INVALID_KEY_HANDLE);
ret = SAR_INVALIDPARAMERR;
goto end;
return SAR_INVALIDPARAMERR;
}
if (param->IVLen != SMS4_IV_LENGTH) {
SKFerr(SKF_F_SKF_DECRYPTINIT, SKF_R_INVALID_IV_LENGTH);
ret = SAR_INVALIDPARAMERR;
goto end;
}
iv = param->IV;
if (!(ctx = EVP_CIPHER_CTX_new())) {
@@ -191,10 +287,8 @@ ULONG DEVAPI SKF_DecryptInit(HANDLE hKey,
goto end;
}
if (!SKF_HANDLE_set1_cipher_ctx(hKey, ctx)) {
SKFerr(SKF_F_SKF_DECRYPTINIT, SKF_R_SET_CIPHER_CTX_FAILED);
goto end;
}
((SKF_HANDLE *)hKey)->type = SKF_CIPHER_HANDLE;
((SKF_HANDLE *)hKey)->u.cipher_ctx = ctx;
ctx = NULL;
ret = SAR_OK;
@@ -248,7 +342,9 @@ ULONG DEVAPI SKF_DecryptFinal(HANDLE hKey,
}
*pulDecryptedDataLen = len;
SKF_HANDLE_free_cipher_ctx(hKey);
EVP_CIPHER_CTX_free(ctx);
((SKF_HANDLE *)hKey)->u.cipher_ctx = NULL;
((SKF_HANDLE *)hKey)->type = SKF_KEY_HANDLE;
return SAR_OK;
}

11
crypto/skf/skf_err.c
View File

@@ -89,6 +89,7 @@ static ERR_STRING_DATA SKF_str_functs[] = {
{ERR_FUNC(SKF_F_EC_KEY_SET_ECCPUBLICKEYBLOB),
"EC_KEY_set_ECCPUBLICKEYBLOB"},
{ERR_FUNC(SKF_F_RSA_GET_RSAPRIVATEKEYBLOB), "RSA_get_RSAPRIVATEKEYBLOB"},
{ERR_FUNC(SKF_F_RSA_GET_RSAPUBLICKEYBLOB), "RSA_get_RSAPUBLICKEYBLOB"},
{ERR_FUNC(SKF_F_RSA_NEW_FROM_RSAPRIVATEKEYBLOB),
"RSA_new_from_RSAPRIVATEKEYBLOB"},
{ERR_FUNC(SKF_F_RSA_NEW_FROM_RSAPUBLICKEYBLOB),
@@ -127,6 +128,7 @@ static ERR_STRING_DATA SKF_str_functs[] = {
{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_GENEXTECCKEYPAIR), "SKF_GENEXTECCKEYPAIR"},
{ERR_FUNC(SKF_F_SKF_GENEXTRSAKEY), "SKF_GENEXTRSAKEY"},
{ERR_FUNC(SKF_F_SKF_GENRANDOM), "SKF_GENRANDOM"},
{ERR_FUNC(SKF_F_SKF_GETDEVINFO), "SKF_GETDEVINFO"},
@@ -134,7 +136,9 @@ static ERR_STRING_DATA SKF_str_functs[] = {
{ERR_FUNC(SKF_F_SKF_GETFILEINFO), "SKF_GETFILEINFO"},
{ERR_FUNC(SKF_F_SKF_GETPININFO), "SKF_GETPININFO"},
{ERR_FUNC(SKF_F_SKF_HANDLE_GET_CBCMAC_CTX), "SKF_HANDLE_GET_CBCMAC_CTX"},
{ERR_FUNC(SKF_F_SKF_HANDLE_GET_CIPHER), "SKF_HANDLE_GET_CIPHER"},
{ERR_FUNC(SKF_F_SKF_HANDLE_GET_CIPHER_CTX), "SKF_HANDLE_GET_CIPHER_CTX"},
{ERR_FUNC(SKF_F_SKF_HANDLE_GET_KEY), "SKF_HANDLE_GET_KEY"},
{ERR_FUNC(SKF_F_SKF_HANDLE_GET_MD_CTX), "SKF_HANDLE_GET_MD_CTX"},
{ERR_FUNC(SKF_F_SKF_LOCKDEV), "SKF_LOCKDEV"},
{ERR_FUNC(SKF_F_SKF_MAC), "SKF_MAC"},
@@ -171,11 +175,15 @@ static ERR_STRING_DATA SKF_str_reasons[] = {
{ERR_REASON(SKF_R_DECRYPT_FAILED), "decrypt failed"},
{ERR_REASON(SKF_R_ENCODE_CIPHERTEXT_FAILED), "encode ciphertext failed"},
{ERR_REASON(SKF_R_ENCODE_FAILED), "encode failed"},
{ERR_REASON(SKF_R_ENCODE_RSA_PUBLIC_KEY_FAILED),
"encode rsa public key failed"},
{ERR_REASON(SKF_R_ENCODE_SIGNATURE_FAILED), "encode signature failed"},
{ERR_REASON(SKF_R_ENCRYPT_FAILED), "encrypt failed"},
{ERR_REASON(SKF_R_FAIL), "fail"},
{ERR_REASON(SKF_R_FREE_HANDLE_FAILED), "free handle failed"},
{ERR_REASON(SKF_R_GEN_RSA_FAILED), "gen rsa failed"},
{ERR_REASON(SKF_R_GET_PRIVATE_KEY_FAILED), "get private key failed"},
{ERR_REASON(SKF_R_GET_PUBLIC_KEY_FAILED), "get public key failed"},
{ERR_REASON(SKF_R_INVALID_ALGID), "invalid algid"},
{ERR_REASON(SKF_R_INVALID_ALGOR), "invalid algor"},
{ERR_REASON(SKF_R_INVALID_APP_HANDLE), "invalid app handle"},
@@ -194,7 +202,9 @@ static ERR_STRING_DATA SKF_str_reasons[] = {
{ERR_REASON(SKF_R_INVALID_EC_KEY), "invalid ec key"},
{ERR_REASON(SKF_R_INVALID_EC_PRIVATE_KEY), "invalid ec private key"},
{ERR_REASON(SKF_R_INVALID_EC_PUBLIC_KEY), "invalid ec public key"},
{ERR_REASON(SKF_R_INVALID_FEED_BIT_LENGTH), "invalid feed bit length"},
{ERR_REASON(SKF_R_INVALID_HANDLE), "invalid handle"},
{ERR_REASON(SKF_R_INVALID_HANDLE_ALGOR), "invalid handle algor"},
{ERR_REASON(SKF_R_INVALID_HANDLE_MAGIC), "invalid handle magic"},
{ERR_REASON(SKF_R_INVALID_HANDLE_TYPE), "invalid handle type"},
{ERR_REASON(SKF_R_INVALID_HASH_HANDLE), "invalid hash handle"},
@@ -208,6 +218,7 @@ static ERR_STRING_DATA SKF_str_reasons[] = {
{ERR_REASON(SKF_R_INVALID_PRIVATE_KEY), "invalid private key"},
{ERR_REASON(SKF_R_INVALID_PUBLIC_KEY), "invalid public key"},
{ERR_REASON(SKF_R_INVALID_RANDOM_LENGTH), "invalid random length"},
{ERR_REASON(SKF_R_INVALID_RSA_KEY_LENGTH), "invalid rsa key length"},
{ERR_REASON(SKF_R_INVALID_RSA_PRIVATE_KEY), "invalid rsa private key"},
{ERR_REASON(SKF_R_INVALID_RSA_PUBLIC_KEY), "invalid rsa public key"},
{ERR_REASON(SKF_R_INVALID_SIGNATURE), "invalid signature"},

4
crypto/skf/skf_errstr.c
View File

@@ -115,10 +115,10 @@ char *SKF_get_errstr(ULONG ulError)
int i;
for (i = 0; i < sizeof(skf_errstr)/sizeof(skf_errstr[0]); i++) {
if (ulError == skf_errstr[i].err_no) {
return (LPSTR)skf_errstr[i].err_str;
return skf_errstr[i].err_str;
}
}
return (LPSTR)"(undef)";
return "(undef)";
}

16
crypto/skf/skf_ex.h
View File

@@ -65,7 +65,9 @@ extern "C" {
#endif
int SKF_print_dev_info(DEVINFO *devInfo);
char *SKF_get_alg_name(ULONG ulAlgID);
char *SKF_get_errstr(ULONG ulError);
int SKF_nid_to_encparams(int nid, ULONG *algID, BLOCKCIPHERPARAM *params);
RSA *RSA_new_from_RSAPUBLICKEYBLOB(const RSAPUBLICKEYBLOB *blob);
RSA *RSA_new_from_RSAPRIVATEKEYBLOB(const RSAPRIVATEKEYBLOB *blob);
@@ -74,6 +76,10 @@ int RSA_get_RSAPUBLICKEYBLOB(RSA *rsa, RSAPUBLICKEYBLOB *blob);
int RSA_set_RSAPRIVATEKEYBLOB(RSA *rsa, const RSAPRIVATEKEYBLOB *blob);
int RSA_get_RSAPRIVATEKEYBLOB(RSA *rsa, RSAPRIVATEKEYBLOB *blob);
ULONG DEVAPI SKF_GenExtECCKeyPair(DEVHANDLE hDev,
ECCPRIVATEKEYBLOB *priKey,
ECCPUBLICKEYBLOB *pubKey);
EC_KEY *EC_KEY_new_from_ECCPUBLICKEYBLOB(const ECCPUBLICKEYBLOB *blob);
EC_KEY *EC_KEY_new_from_ECCPRIVATEKEYBLOB(const ECCPRIVATEKEYBLOB *blob);
int EC_KEY_set_ECCPUBLICKEYBLOB(EC_KEY *ec_key, const ECCPUBLICKEYBLOB *blob);
@@ -110,6 +116,7 @@ void ERR_load_SKF_strings(void);
# define SKF_F_EC_KEY_SET_ECCPRIVATEKEYBLOB 157
# define SKF_F_EC_KEY_SET_ECCPUBLICKEYBLOB 158
# define SKF_F_RSA_GET_RSAPRIVATEKEYBLOB 169
# define SKF_F_RSA_GET_RSAPUBLICKEYBLOB 173
# define SKF_F_RSA_NEW_FROM_RSAPRIVATEKEYBLOB 163
# define SKF_F_RSA_NEW_FROM_RSAPUBLICKEYBLOB 164
# define SKF_F_RSA_SET_RSAPRIVATEKEYBLOB 170
@@ -146,6 +153,7 @@ void ERR_load_SKF_strings(void);
# define SKF_F_SKF_EXTECCVERIFY 151
# define SKF_F_SKF_EXTRSAPRIKEYOPERATION 166
# define SKF_F_SKF_EXTRSAPUBKEYOPERATION 167
# define SKF_F_SKF_GENEXTECCKEYPAIR 174
# define SKF_F_SKF_GENEXTRSAKEY 132
# define SKF_F_SKF_GENRANDOM 133
# define SKF_F_SKF_GETDEVINFO 116
@@ -153,7 +161,9 @@ void ERR_load_SKF_strings(void);
# define SKF_F_SKF_GETFILEINFO 118
# define SKF_F_SKF_GETPININFO 119
# define SKF_F_SKF_HANDLE_GET_CBCMAC_CTX 140
# define SKF_F_SKF_HANDLE_GET_CIPHER 171
# define SKF_F_SKF_HANDLE_GET_CIPHER_CTX 141
# define SKF_F_SKF_HANDLE_GET_KEY 172
# define SKF_F_SKF_HANDLE_GET_MD_CTX 142
# define SKF_F_SKF_LOCKDEV 120
# define SKF_F_SKF_MAC 168
@@ -183,11 +193,14 @@ void ERR_load_SKF_strings(void);
# define SKF_R_DECRYPT_FAILED 133
# define SKF_R_ENCODE_CIPHERTEXT_FAILED 134
# define SKF_R_ENCODE_FAILED 114
# define SKF_R_ENCODE_RSA_PUBLIC_KEY_FAILED 162
# define SKF_R_ENCODE_SIGNATURE_FAILED 135
# define SKF_R_ENCRYPT_FAILED 136
# define SKF_R_FAIL 104
# define SKF_R_FREE_HANDLE_FAILED 128
# define SKF_R_GEN_RSA_FAILED 115
# define SKF_R_GET_PRIVATE_KEY_FAILED 164
# define SKF_R_GET_PUBLIC_KEY_FAILED 165
# define SKF_R_INVALID_ALGID 122
# define SKF_R_INVALID_ALGOR 156
# define SKF_R_INVALID_APP_HANDLE 105
@@ -206,7 +219,9 @@ void ERR_load_SKF_strings(void);
# define SKF_R_INVALID_EC_KEY 151
# define SKF_R_INVALID_EC_PRIVATE_KEY 145
# define SKF_R_INVALID_EC_PUBLIC_KEY 146
# define SKF_R_INVALID_FEED_BIT_LENGTH 160
# define SKF_R_INVALID_HANDLE 107
# define SKF_R_INVALID_HANDLE_ALGOR 161
# define SKF_R_INVALID_HANDLE_MAGIC 125
# define SKF_R_INVALID_HANDLE_TYPE 126
# define SKF_R_INVALID_HASH_HANDLE 127
@@ -220,6 +235,7 @@ void ERR_load_SKF_strings(void);
# define SKF_R_INVALID_PRIVATE_KEY 152
# define SKF_R_INVALID_PUBLIC_KEY 153
# define SKF_R_INVALID_RANDOM_LENGTH 119
# define SKF_R_INVALID_RSA_KEY_LENGTH 163
# define SKF_R_INVALID_RSA_PRIVATE_KEY 158
# define SKF_R_INVALID_RSA_PUBLIC_KEY 159
# define SKF_R_INVALID_SIGNATURE 148

121
crypto/skf/skf_handle.c
View File

@@ -54,21 +54,84 @@
#include <openssl/skf_ex.h>
#include "skf_lcl.h"
EVP_MD_CTX *SKF_HANDLE_get_md_ctx(SKF_HANDLE *handle)
unsigned char *SKF_HANDLE_get_key(HANDLE hKey)
{
EVP_MD_CTX *ret;
SKF_HANDLE *handle;
if (!handle) {
SKFerr(SKF_F_SKF_HANDLE_GET_MD_CTX, SKF_R_NULL_ARGUMENT);
if (!(handle = (SKF_HANDLE *)hKey)) {
SKFerr(SKF_F_SKF_HANDLE_GET_KEY, ERR_R_PASSED_NULL_PARAMETER);
return NULL;
}
if (handle->magic != SKF_HANDLE_MAGIC) {
SKFerr(SKF_F_SKF_HANDLE_GET_KEY, SKF_R_INVALID_HANDLE_MAGIC);
return NULL;
}
if (handle->type < SKF_KEY_HANDLE) {
SKFerr(SKF_F_SKF_HANDLE_GET_KEY, SKF_R_INVALID_HANDLE_TYPE);
return NULL;
}
switch (handle->algid) {
case SGD_SM4_ECB:
case SGD_SM4_CBC:
case SGD_SM4_CFB:
case SGD_SM4_OFB:
case SGD_SM4_MAC:
break;
default:
SKFerr(SKF_F_SKF_HANDLE_GET_KEY, SKF_R_INVALID_ALGOR);
return NULL;
}
if (!handle->keylen) {
SKFerr(SKF_F_SKF_HANDLE_GET_KEY, SKF_R_INVALID_KEY_HANDLE);
return NULL;
}
return handle->key;
}
const EVP_CIPHER *SKF_HANDLE_get_cipher(HANDLE hKey, BLOCKCIPHERPARAM *param)
{
SKF_HANDLE *handle = (SKF_HANDLE *)hKey;
if (!SKF_HANDLE_get_key(hKey)) {
SKFerr(SKF_F_SKF_HANDLE_GET_CIPHER, SKF_R_INVALID_KEY_HANDLE);
return NULL;
}
switch (handle->algid) {
case SGD_SM4_ECB:
return EVP_sms4_ecb();
case SGD_SM4_CBC:
return EVP_sms4_cbc();
case SGD_SM4_OFB:
return EVP_sms4_ofb();
case SGD_SM4_CFB:
switch (param->FeedBitLen) {
case 1: return EVP_sms4_cfb1();
case 8: return EVP_sms4_cfb8();
case 128: return EVP_sms4_cfb128();
}
SKFerr(SKF_F_SKF_HANDLE_GET_CIPHER, SKF_R_INVALID_FEED_BIT_LENGTH);
return NULL;
}
SKFerr(SKF_F_SKF_HANDLE_GET_CIPHER, SKF_R_INVALID_HANDLE_ALGOR);
return NULL;
}
EVP_MD_CTX *SKF_HANDLE_get_md_ctx(HANDLE hHash)
{
EVP_MD_CTX *ret;
SKF_HANDLE *handle;
if (!(handle = (SKF_HANDLE *)hHash)) {
SKFerr(SKF_F_SKF_HANDLE_GET_MD_CTX, ERR_R_PASSED_NULL_PARAMETER);
return NULL;
}
if (handle->magic != SKF_HANDLE_MAGIC) {
SKFerr(SKF_F_SKF_HANDLE_GET_MD_CTX, SKF_R_INVALID_HANDLE_MAGIC);
return NULL;
}
if (handle->type != SKF_HASH_HANDLE) {
SKFerr(SKF_F_SKF_HANDLE_GET_MD_CTX, SKF_R_INVALID_HANDLE_TYPE);
return NULL;
@@ -78,24 +141,22 @@ EVP_MD_CTX *SKF_HANDLE_get_md_ctx(SKF_HANDLE *handle)
SKFerr(SKF_F_SKF_HANDLE_GET_MD_CTX, SKF_R_CTX_NOT_CREATED);
return NULL;
}
return ret;
}
CBCMAC_CTX *SKF_HANDLE_get_cbcmac_ctx(SKF_HANDLE *handle)
CBCMAC_CTX *SKF_HANDLE_get_cbcmac_ctx(HANDLE hMac)
{
CBCMAC_CTX *ret;
SKF_HANDLE *handle;
if (!handle) {
SKFerr(SKF_F_SKF_HANDLE_GET_CBCMAC_CTX, SKF_R_NULL_ARGUMENT);
if (!(handle = (SKF_HANDLE *)hMac)) {
SKFerr(SKF_F_SKF_HANDLE_GET_CBCMAC_CTX, ERR_R_PASSED_NULL_PARAMETER);
return NULL;
}
if (handle->magic != SKF_HANDLE_MAGIC) {
SKFerr(SKF_F_SKF_HANDLE_GET_CBCMAC_CTX, SKF_R_INVALID_HANDLE_MAGIC);
return NULL;
}
if (handle->type != SKF_MAC_HANDLE) {
SKFerr(SKF_F_SKF_HANDLE_GET_CBCMAC_CTX, SKF_R_INVALID_HANDLE_TYPE);
return NULL;
@@ -105,24 +166,22 @@ CBCMAC_CTX *SKF_HANDLE_get_cbcmac_ctx(SKF_HANDLE *handle)
SKFerr(SKF_F_SKF_HANDLE_GET_CBCMAC_CTX, SKF_R_CTX_NOT_CREATED);
return NULL;
}
return ret;
}
EVP_CIPHER_CTX *SKF_HANDLE_get_cipher_ctx(SKF_HANDLE *handle)
EVP_CIPHER_CTX *SKF_HANDLE_get_cipher_ctx(HANDLE hKey)
{
EVP_CIPHER_CTX *ret;
SKF_HANDLE *handle;
if (!handle) {
SKFerr(SKF_F_SKF_HANDLE_GET_CIPHER_CTX, SKF_R_NULL_ARGUMENT);
if (!(handle = (SKF_HANDLE *)hKey)) {
SKFerr(SKF_F_SKF_HANDLE_GET_CIPHER_CTX, ERR_R_PASSED_NULL_PARAMETER);
return NULL;
}
if (handle->magic != SKF_HANDLE_MAGIC) {
SKFerr(SKF_F_SKF_HANDLE_GET_CIPHER_CTX, SKF_R_INVALID_HANDLE_MAGIC);
return NULL;
}
if (handle->type != SKF_CIPHER_HANDLE) {
SKFerr(SKF_F_SKF_HANDLE_GET_CIPHER_CTX, SKF_R_INVALID_HANDLE_TYPE);
return NULL;
@@ -132,44 +191,28 @@ EVP_CIPHER_CTX *SKF_HANDLE_get_cipher_ctx(SKF_HANDLE *handle)
SKFerr(SKF_F_SKF_HANDLE_GET_CIPHER_CTX, SKF_R_CTX_NOT_CREATED);
return NULL;
}
return ret;
}
int SKF_HANDLE_free_cipher_ctx(SKF_HANDLE *handle)
int SKF_HANDLE_free(HANDLE handle)
{
return 0;
}
int SKF_HANDLE_free(SKF_HANDLE *handle)
{
return 0;
}
unsigned char *SKF_HANDLE_get_key(SKF_HANDLE *handle)
HANDLE SKF_HANDLE_new(int type)
{
return NULL;
}
SKF_HANDLE *SKF_HANDLE_new(int type)
{
return NULL;
}
int SKF_HANDLE_set1_cipher_ctx(SKF_HANDLE *handle, EVP_CIPHER_CTX *ctx)
{
return 0;
}
ULONG DEVAPI SKF_CloseHandle(HANDLE hHandle)
{
SKF_HANDLE *handle;
return SAR_OK; //FIXME:
if (!(handle = (SKF_HANDLE *)hHandle)) {
SKFerr(SKF_F_SKF_CLOSEHANDLE, SKF_R_NULL_ARGUMENT);
return SAR_INVALIDPARAMERR;
return SAR_OK;
}
if (handle->magic != SKF_HANDLE_MAGIC) {

16
crypto/skf/skf_lcl.h
View File

@@ -83,15 +83,13 @@ struct SKF_HANDLE {
typedef struct SKF_HANDLE SKF_HANDLE;
SKF_HANDLE *SKF_HANDLE_new(int type);
EVP_MD_CTX *SKF_HANDLE_get_md_ctx(SKF_HANDLE *hHash);
CBCMAC_CTX *SKF_HANDLE_get_cbcmac_ctx(SKF_HANDLE *hMac);
EVP_CIPHER_CTX *SKF_HANDLE_get_cipher_ctx(SKF_HANDLE *hKey);
unsigned char *SKF_HANDLE_get_key(SKF_HANDLE *hKey);
int SKF_HANDLE_set1_md_ctx(SKF_HANDLE *hHash, EVP_MD_CTX *ctx);
int SKF_HANDLE_set1_cbcmac_ctx(SKF_HANDLE *hMac, CBCMAC_CTX *ctx);
int SKF_HANDLE_set1_cipher_ctx(SKF_HANDLE *hKey, EVP_CIPHER_CTX *ctx);
int SKF_HANDLE_free(SKF_HANDLE *handle);
EVP_MD_CTX *SKF_HANDLE_get_md_ctx(HANDLE hHash);
CBCMAC_CTX *SKF_HANDLE_get_cbcmac_ctx(HANDLE hMac);
const EVP_CIPHER *SKF_HANDLE_get_cipher(HANDLE hKey, BLOCKCIPHERPARAM *param);
EVP_CIPHER_CTX *SKF_HANDLE_get_cipher_ctx(HANDLE hKey);
unsigned char *SKF_HANDLE_get_key(HANDLE hKey);
#ifdef __cplusplus

10
crypto/skf/skf_mac.c
View File

@@ -61,7 +61,6 @@ ULONG DEVAPI SKF_MacInit(HANDLE hKey,
BLOCKCIPHERPARAM *pMacParam,
HANDLE *phMac)
{
int ok = 0;
SKF_HANDLE *key;
SKF_HANDLE *hMac = NULL;
const EVP_CIPHER *cipher;
@@ -71,14 +70,14 @@ ULONG DEVAPI SKF_MacInit(HANDLE hKey,
return SAR_INVALIDPARAMERR;
}
OPENSSL_assert(!pMacParam);
//TODO: check pMacParam
if (key->magic != SKF_HANDLE_MAGIC) {
SKFerr(SKF_F_SKF_MACINIT, SKF_R_INVALID_HANDLE_MAGIC);
return SAR_INVALIDPARAMERR;
}
if (key->type <= SKF_KEY_HANDLE) {
if (key->type < SKF_KEY_HANDLE) {
SKFerr(SKF_F_SKF_MACINIT, SKF_R_INVALID_KEY_HANDLE);
return SAR_INVALIDPARAMERR;
}
@@ -142,17 +141,20 @@ ULONG DEVAPI SKF_MacFinal(HANDLE hMac,
ULONG *pulMacDataLen)
{
CBCMAC_CTX *ctx;
size_t size;
if (!(ctx = SKF_HANDLE_get_cbcmac_ctx(hMac))) {
SKFerr(SKF_F_SKF_MACFINAL, SKF_R_INVALID_MAC_HANDLE);
return SAR_INVALIDPARAMERR;
}
if (!CBCMAC_Final(ctx, pbMacData, pulMacDataLen)) {
size = *pulMacDataLen;
if (!CBCMAC_Final(ctx, pbMacData, &size)) {
SKFerr(SKF_F_SKF_MACFINAL, ERR_R_CBCMAC_LIB);
return SAR_FAIL;
}
*pulMacDataLen = (ULONG)size;
return SAR_OK;
}

103
crypto/skf/skf_rsa.c
View File

@@ -54,8 +54,7 @@
#include <openssl/skf.h>
#include <openssl/skf_ex.h>
#include "skf_lcl.h"
#if 0
#if 1
ULONG DEVAPI SKF_GenExtRSAKey(DEVHANDLE hDev,
ULONG ulBitsLen,
RSAPRIVATEKEYBLOB *pBlob)
@@ -226,104 +225,101 @@ ULONG DEVAPI SKF_RSAVerify(DEVHANDLE hDev,
RSA *RSA_new_from_RSAPUBLICKEYBLOB(const RSAPUBLICKEYBLOB *blob)
{
RSA *ret;
if (!(ret = RSA_new())) {
SKFerr(SKF_F_RSA_NEW_FROM_RSAPUBLICKEYBLOB, ERR_R_RSA_LIB);
return NULL;
}
if (!RSA_set_RSAPUBLICKEYBLOB(ret, blob)) {
SKFerr(SKF_F_RSA_NEW_FROM_RSAPUBLICKEYBLOB, SKF_R_INVALID_RSA_PUBLIC_KEY);
RSA_free(ret);
return NULL;
}
return ret;
}
RSA *RSA_new_from_RSAPRIVATEKEYBLOB(const RSAPRIVATEKEYBLOB *blob)
{
RSA *ret;
if (!(ret = RSA_new())) {
SKFerr(SKF_F_RSA_NEW_FROM_RSAPRIVATEKEYBLOB, ERR_R_RSA_LIB);
return NULL;
}
if (!RSA_set_RSAPRIVATEKEYBLOB(ret, blob)) {
SKFerr(SKF_F_RSA_NEW_FROM_RSAPRIVATEKEYBLOB, SKF_R_INVALID_RSA_PRIVATE_KEY);
RSA_free(ret);
return NULL;
}
return ret;
}
int RSA_set_RSAPUBLICKEYBLOB(RSA *rsa, const RSAPUBLICKEYBLOB *blob)
{
int ret = 0;
if (!rsa || !blob) {
SKFerr(SKF_F_RSA_SET_RSAPUBLICKEYBLOB, SKF_R_NULL_ARGUMENT);
SKFerr(SKF_F_RSA_SET_RSAPUBLICKEYBLOB,
ERR_R_PASSED_NULL_PARAMETER);
return 0;
}
if (!(rsa->n = BN_bin2bn(blob->Modulus, blob->BitLen/8, rsa->n))) {
goto end;
if ((blob->BitLen < 1024) || (blob->BitLen > MAX_RSA_MODULUS_LEN*8) ||
(blob->BitLen / 8 != 0)) {
SKFerr(SKF_F_RSA_SET_RSAPUBLICKEYBLOB, SKF_R_INVALID_RSA_KEY_LENGTH);
return 0;
}
if (!(rsa->e = BN_bin2bn(blob->PublicExponent, blob->BitLen/8, rsa->e))) {
goto end;
if (!(rsa->n = BN_bin2bn(blob->Modulus, blob->BitLen/8, rsa->n))) {
SKFerr(SKF_F_RSA_SET_RSAPUBLICKEYBLOB, SKF_R_INVALID_RSA_PUBLIC_KEY);
return 0;
}
if (!(rsa->e = BN_bin2bn(blob->PublicExponent, MAX_RSA_EXPONENT_LEN, rsa->e))) {
SKFerr(SKF_F_RSA_SET_RSAPUBLICKEYBLOB, SKF_R_INVALID_RSA_PUBLIC_KEY);
return 0;
}
if (!RSA_check_key(rsa)) {
goto end;
SKFerr(SKF_F_RSA_SET_RSAPUBLICKEYBLOB, SKF_R_INVALID_RSA_PUBLIC_KEY);
return 0;
}
end:
return ret;
return 1;
}
int RSA_get_RSAPUBLICKEYBLOB(RSA *rsa, RSAPUBLICKEYBLOB *blob)
{
int ret = 0;
int nbytes;
if (!rsa || !blob) {
SKFerr(SKF_F_RSA_GET_RSAPUBLICKEYBLOB,
ERR_R_PASSED_NULL_PARAMETER);
return 0;
}
if (!rsa->n || !rsa->e) {
goto end;
SKFerr(SKF_F_RSA_GET_RSAPUBLICKEYBLOB,
SKF_R_INVALID_RSA_PUBLIC_KEY);
return 0;
}
nbytes = BN_num_bytes(rsa->n);
if (!BN_bn2bin(rsa->n, blob->Modulus + bnlen - BN_num_bytes(rsa->n)) ||
!BN_bn2bin(rsa->e, blob->PublicExponent + bnlen - BN_num_bytes(rsa->e))) {
if (!BN_bn2bin(rsa->n, blob->Modulus) || !BN_bn2bin(rsa->e,
blob->PublicExponent + MAX_RSA_EXPONENT_LEN - BN_num_bytes(rsa->e))) {
SKFerr(SKF_F_RSA_GET_RSAPUBLICKEYBLOB,
SKF_R_ENCODE_RSA_PUBLIC_KEY_FAILED);
return 0;
}
return ret;
return 1;
}
int RSA_set_RSAPRIVATEKEYBLOB(RSA *rsa, const RSAPRIVATEKEYBLOB *blob)
{
int ret = 0;
int nbytes;
if (!rsa || !blob) {
SKFerr(SKF_F_RSA_SET_RSAPRIVATEKEYBLOB, SKF_R_NULL_ARGUMENT);
return SAR_INVALIDPARAMERR;
SKFerr(SKF_F_RSA_SET_RSAPRIVATEKEYBLOB,
ERR_R_PASSED_NULL_PARAMETER);
return 0;
}
if (blob->AlgID != SGD_RSA) {
SKFerr(SKF_F_RSA_SET_RSAPRIVATEKEYBLOB, SKR_R_INVALID_ALGOR);
return SAR_INVALIDPARAMERR;
SKFerr(SKF_F_RSA_SET_RSAPRIVATEKEYBLOB, SKF_R_INVALID_ALGOR);
return 0;
}
if ((blob->BitLen < 1024) || (blob->BitLen > MAX_RSA_MODULUS_LEN*8) ||
(blob->BitLen % 8 != 0) || (blob->BitLen % 16 != 0)) {
SKFerr(SKF_F_RSA_SET_RSAPRIVATEKEYBLOB, SKR_R_INVALID_KEY_LENGTH);
return SAR_INVALIDPARAMERR;
SKFerr(SKF_F_RSA_SET_RSAPRIVATEKEYBLOB, SKF_R_INVALID_KEY_LENGTH);
return 0;
}
nbytes = blob->BitLen/8;
if (!(rsa->n = BN_bin2bn(blob->Modulus, nbytes, rsa->n)) ||
!(rsa->e = BN_bin2bn(blob->PublicExponent, MAX_RSA_EXPONENT_LEN, rsa->e)) ||
!(rsa->d = BN_bin2bn(blob->PrivateExponent, nbytes, rsa->d)) ||
@@ -332,26 +328,24 @@ int RSA_set_RSAPRIVATEKEYBLOB(RSA *rsa, const RSAPRIVATEKEYBLOB *blob)
!(rsa->dmp1 = BN_bin2bn(blob->Prime1Exponent, nbytes/2, rsa->dmp1)) ||
!(rsa->dmq1 = BN_bin2bn(blob->Prime2Exponent, nbytes/2, rsa->dmq1)) ||
!(rsa->iqmp = BN_bin2bn(blob->Coefficient, nbytes/2, rsa->iqmp))) {
SKFerr(SKF_F_RSA_SET_RSAPRIVATEKEYBLOB, SKR_R_INVALID_RSA_PRIVATE_KEY);
return SAR_INVALIDPARAMERR;
SKFerr(SKF_F_RSA_SET_RSAPRIVATEKEYBLOB, SKF_R_INVALID_RSA_PRIVATE_KEY);
return 0;
}
return SAR_OK;
return 1;
}
int RSA_get_RSAPRIVATEKEYBLOB(RSA *rsa, RSAPRIVATEKEYBLOB *blob)
{
int nbytes;
if (!rsa || !blob) {
SKFerr(SKF_F_RSA_GET_RSAPRIVATEKEYBLOB, SKF_R_NULL_ARGUMENT);
return SAR_INVALIDPARAMERR;
SKFerr(SKF_F_RSA_GET_RSAPRIVATEKEYBLOB,
ERR_R_PASSED_NULL_PARAMETER);
return 0;
}
if (!rsa->n || !rsa->e || !rsa->d || !rsa->p || !rsa->q ||
!rsa->dmp1 || !rsa->dmq1 || !rsa->iqmp)
!rsa->dmp1 || !rsa->dmq1 || !rsa->iqmp) {
SKFerr(SKF_F_RSA_GET_RSAPRIVATEKEYBLOB, SKF_R_INVALID_RSA_PRIVATE_KEY);
return SAR_INVALIDPARAMERR;
return 0;
}
bzero(blob, sizeof(*blob));
@@ -367,11 +361,10 @@ int RSA_get_RSAPRIVATEKEYBLOB(RSA *rsa, RSAPRIVATEKEYBLOB *blob)
!BN_bn2bin(rsa->dmp1, blob->Prime1Exponent + nbytes/2 - BN_num_bytes(rsa->dmp1)) ||
!BN_bn2bin(rsa->dmq1, blob->Prime2Exponent + nbytes/2 - BN_num_bytes(rsa->dmq1)) ||
!BN_bn2bin(rsa->iqmp, blob->Coefficient + nbytes/2 - BN_num_bytes(rsa->iqmp))) {
SKFerr(SKF_F_RSA_GET_RSAPRIVATEKEYBLOB, SKF_R_INVALID_RSA_PRIVATE_KEY);
return SAR_INVALIDPARAMERR;
return 0;
}
return SAR_OK;
return 1;
}
#endif

383
crypto/skf/skftest.c Normal file
View File

@@ -0,0 +1,383 @@
/* crypto/skf/skftest.c */
/* ====================================================================
* Copyright (c) 2015-2016 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 <string.h>
#include <stdlib.h>
#include <openssl/evp.h>
#include <openssl/skf.h>
#include <openssl/skf_ex.h>
#define PRINT_ERRSTR(rv) \
fprintf(stderr, "error: %s %d: %s\n", __FILE__, __LINE__, SKF_get_errstr(rv))
DEVHANDLE open_dev(LPSTR devName, int verbose)
{
DEVHANDLE hDev;
ULONG rv;
if ((rv = SKF_ConnectDev(devName, &hDev)) != SAR_OK) {
PRINT_ERRSTR(rv);
return NULL;
}
if (verbose > 1) {
DEVINFO devInfo;
if ((rv = SKF_GetDevInfo(hDev, &devInfo)) != SAR_OK) {
PRINT_ERRSTR(rv);
SKF_DisConnectDev(hDev);
return NULL;
}
SKF_print_dev_info(&devInfo);
}
return hDev;
}
int test_skf_mac(DEVHANDLE hDev, ULONG ulAlgID, int verbose)
{
int ret = 0;
HANDLE hKey = NULL;
HANDLE hMac = NULL;
BLOCKCIPHERPARAM param;
BYTE key[EVP_MAX_KEY_LENGTH];
BYTE data[128] = {0};
BYTE mac[EVP_MAX_MD_SIZE];
ULONG dataLen, macLen;
ULONG rv;
if ((rv = SKF_SetSymmKey(hDev, key, ulAlgID, &hKey)) != SAR_OK) {
PRINT_ERRSTR(rv);
goto end;
}
bzero(&param, sizeof(param));
param.IVLen = 0;
param.PaddingType = SKF_NO_PADDING;
if ((rv = SKF_MacInit(hKey, &param, &hMac)) != SAR_OK) {
PRINT_ERRSTR(rv);
goto end;
}
dataLen = (ULONG)sizeof(data);
macLen = (ULONG)sizeof(mac);
if ((rv = SKF_Mac(hMac, data, dataLen, mac, &macLen)) != SAR_OK) {
PRINT_ERRSTR(rv);
goto end;
}
if (macLen != 16) {
printf("macLen = %d\n", (int)macLen);
fprintf(stderr, "error: %s %d: %s\n", __FILE__, __LINE__, "mac length != 16");
goto end;
}
ret = 1;
end:
if ((rv = SKF_CloseHandle(hMac)) != SAR_OK) {
PRINT_ERRSTR(rv);
ret = 0;
}
if ((rv = SKF_CloseHandle(hKey)) != SAR_OK) {
PRINT_ERRSTR(rv);
ret = 0;
}
if (ret && verbose) {
printf("%s(%s) passed\n", __FUNCTION__, SKF_get_alg_name(ulAlgID));
}
return ret;
}
int test_skf_dgst(DEVHANDLE hDev, ULONG ulAlgID, int verbose)
{
int ret = 0;
HANDLE hHash = NULL;
BYTE data[200] = {0};
BYTE dgst[EVP_MAX_MD_SIZE];
ULONG dataLen, dgstLen;
ULONG rv;
if ((rv = SKF_DigestInit(hDev, ulAlgID, NULL, NULL, 0, &hHash)) != SAR_OK) {
PRINT_ERRSTR(rv);
return 0;
}
dataLen = (ULONG)sizeof(data);
dgstLen = (ULONG)sizeof(dgst);
if ((rv = SKF_Digest(hHash, data, dataLen, dgst, &dgstLen)) != SAR_OK) {
PRINT_ERRSTR(rv);
goto end;
}
if (verbose > 1) {
ULONG i;
printf("%s (%u-Byte) = ", SKF_get_alg_name(ulAlgID), dgstLen);
for (i = 0; i < dgstLen; i++) {
printf("%02x", dgst[i]);
}
printf("\n");
}
ret = 1;
end:
if ((rv = SKF_CloseHandle(hHash)) != SAR_OK) {
PRINT_ERRSTR(rv);
ret = 0;
}
if (ret && verbose) {
printf("%s(%s) passed\n", __FUNCTION__, SKF_get_alg_name(ulAlgID));
}
return ret;
}
int test_skf_enc(DEVHANDLE hDev, ULONG ulAlgID, BLOCKCIPHERPARAM param, int verbose)
{
int ret = 0;
HANDLE hKey = NULL;
BYTE key[EVP_MAX_KEY_LENGTH];
BYTE data[] = "message to be encrypted";
BYTE cbuf[256];
BYTE mbuf[256];
ULONG mlen, clen;
ULONG rv;
if ((rv = SKF_SetSymmKey(hDev, key, ulAlgID, &hKey)) != SAR_OK) {
PRINT_ERRSTR(rv);
goto end;
}
if ((rv = SKF_EncryptInit(hKey, param)) != SAR_OK) {
PRINT_ERRSTR(rv);
goto end;
}
mlen = (ULONG)sizeof(data);
clen = (ULONG)sizeof(cbuf);
if ((rv = SKF_Encrypt(hKey, data, mlen, cbuf, &clen)) != SAR_OK) {
PRINT_ERRSTR(rv);
goto end;
}
if ((rv = SKF_DecryptInit(hKey, param)) != SAR_OK) {
PRINT_ERRSTR(rv);
goto end;
}
mlen = (ULONG)sizeof(mbuf);
if ((rv = SKF_Decrypt(hKey, cbuf, clen, mbuf, &mlen)) != SAR_OK) {
PRINT_ERRSTR(rv);
goto end;
}
//FIXME: compare data with mbuf
if (verbose > 1) {
//FIXME: print ciphertext
}
ret = 1;
end:
if ((rv = SKF_CloseHandle(hKey)) != SAR_OK) {
PRINT_ERRSTR(rv);
ret = 0;
}
if (ret && verbose) {
//FIXME: print success info
}
return ret;
}
int test_skf_rsa(DEVHANDLE hDev, ULONG ulBitsLen, int verbose)
{
int ret = 0;
RSAPRIVATEKEYBLOB rsa;
RSAPUBLICKEYBLOB rsaPubKey;
BYTE data[] = "message to be encrypted or signed";
BYTE cbuf[512];
BYTE mbuf[256];
BYTE sig[512];
ULONG len, clen, mlen, siglen;
ULONG rv;
if ((rv = SKF_GenExtRSAKey(hDev, 2048, &rsa)) != SAR_OK) {
PRINT_ERRSTR(rv);
goto end;
}
memcpy(&rsaPubKey, &rsa, sizeof(rsaPubKey));
len = (ULONG)sizeof(data);
clen = (ULONG)sizeof(cbuf);
if ((rv = SKF_ExtRSAPubKeyOperation(hDev, &rsaPubKey, data, len, cbuf, &clen)) != SAR_OK) {
PRINT_ERRSTR(rv);
goto end;
}
mlen = (ULONG)sizeof(mbuf);
if ((rv = SKF_ExtRSAPriKeyOperation(hDev, &rsa, cbuf, clen, mbuf, &mlen)) != SAR_OK) {
PRINT_ERRSTR(rv);
goto end;
}
ret = 1;
end:
return 0;
}
int test_skf_ec(DEVHANDLE hDev, int verbose)
{
ECCPRIVATEKEYBLOB priKey;
ECCPUBLICKEYBLOB pubKey;
ECCSIGNATUREBLOB sig;
BYTE cbuf[sizeof(ECCCIPHERBLOB) + 512];
BYTE msg[] = "message to be signed and encrypted";
BYTE mbuf[128];
ULONG mlen, clen;
ULONG rv;
bzero(&priKey, sizeof(priKey));
bzero(&pubKey, sizeof(pubKey));
if ((rv = SKF_GenExtECCKeyPair(hDev, &priKey, &pubKey)) != SAR_OK) {
PRINT_ERRSTR(rv);
return 0;
}
mlen = (ULONG)sizeof(msg);
bzero(&sig, sizeof(sig));
if ((rv = SKF_ExtECCSign(hDev, &priKey, msg, mlen, &sig)) != SAR_OK) {
PRINT_ERRSTR(rv);
return 0;
}
if ((rv = SKF_ExtECCVerify(hDev, &pubKey, msg, mlen, &sig)) != SAR_OK) {
PRINT_ERRSTR(rv);
return 0;
}
mlen = (ULONG)sizeof(msg);
bzero(cbuf, sizeof(cbuf));
if ((rv = SKF_ExtECCEncrypt(hDev, &pubKey, msg, mlen, (ECCCIPHERBLOB *)cbuf)) != SAR_OK) {
PRINT_ERRSTR(rv);
return 0;
}
mlen = (ULONG)sizeof(mbuf);
bzero(mbuf, sizeof(mbuf));
if ((rv = SKF_ExtECCDecrypt(hDev, &priKey, (ECCCIPHERBLOB *)cbuf, mbuf, &mlen)) != SAR_OK) {
PRINT_ERRSTR(rv);
return 0;
}
return 1;
}
int main(int argc, char **argv)
{
int verbose = 2;
DEVHANDLE hDev = NULL;
ULONG digestAlgors[] = {
SGD_SM3,
SGD_SHA1,
SGD_SHA256
};
ULONG cipherAlgors[] = {
SGD_SM4_ECB,
SGD_SM4_CBC,
SGD_SM4_CFB,
SGD_SM4_CFB,
SGD_SM4_CFB,
SGD_SM4_OFB
};
BLOCKCIPHERPARAM cipherParams[] = {
{{0}, 0, SKF_NO_PADDING, 0},
{{0}, 16, SKF_PKCS5_PADDING, 0},
{{0}, 16, SKF_NO_PADDING, 1},
{{0}, 16, SKF_NO_PADDING, 8},
{{0}, 16, SKF_NO_PADDING, 128},
{{0}, 16, SKF_NO_PADDING, 0},
};
ULONG rsaBits[] = { 1024, 2048 };
int i;
hDev = open_dev((LPSTR)"name", verbose);
/*
if (!test_skf_mac(hDev, SGD_SM4_MAC, verbose)) {
goto end;
}
*/
for (i = 0; i < sizeof(digestAlgors)/sizeof(digestAlgors[0]); i++) {
if (!test_skf_dgst(hDev, digestAlgors[i], verbose)) {
goto end;
}
}
for (i = 0; i < sizeof(cipherAlgors)/sizeof(cipherAlgors[0]); i++) {
if (!test_skf_enc(hDev, cipherAlgors[i], cipherParams[i], verbose)) {
goto end;
}
}
for (i = 0; i < sizeof(rsaBits)/sizeof(rsaBits[0]); i++) {
if (!test_skf_rsa(hDev, test_skf_rsa(hDev, rsaBits[i], verbose))) {
goto end;
}
}
if (!test_skf_ec(hDev, verbose)) {
goto end;
}
end:
ERR_print_errors_fp(stderr);
SKF_DisConnectDev(hDev);
return -1;
}