Skip to content

P
plugin
Commit a1468575 authored by hezhengjun's avatar hezhengjun
Browse files
Options

remove tasshsm

parent 9ed41107
Hide whitespace changes
Inline Side-by-side
Showing with 0 additions and 3826 deletions
plugin/crypto/tasshsm/Makefile deleted 100644 → 0
View file @ 9ed41107
proj := "tass"
.PHONY: default build sm2
default: build
build:
g++ -o tass demo/main.cpp -I include -std=c++11 -Llinux64 -lTassSDF4PCIeSM -lTassAPI4PCIECrypotoCard -ltass_pcie_api
sm2:
g++ -o test_sm2 sm2/main.cpp -I include -std=c++11 -Llinux64 -lTassSDF4PCIeSM -lTassAPI4PCIECrypotoCard -ltass_pcie_api
plugin/crypto/tasshsm/adapter/adapter.go deleted 100644 → 0
View file @ 9ed41107
package adapter
//#cgo CFLAGS: -I../include
//#cgo LDFLAGS: -L../linux64 -lTassSDF4PCIeSM -ltass_pcie_api -lTassSDF4PCIeSM
//#cgo LDFLAGS: -ldl -lpthread -lc
//#include <stdlib.h>
//#include <stdio.h>
//#include <SDF4PCIeSM.h>
//#include <TassAPI4PCIeSM.h>
//unsigned char SM2ID[16] = {0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38};
//unsigned char sm3Hash[32] = { 0 };
//unsigned char RS[64] = { 0 };
//void* g_hDev = NULL, *g_hSess = NULL;
//const unsigned char*skCipherByKek = NULL;
//unsigned char*RSPtr = RS;
//unsigned int signatureLen = 64;
//unsigned int *signatureLenPtr = &signatureLen;
//int setupHSM()
//{
// auto rt = SDF_OpenDevice(&g_hDev);
// if (rt) {
// printf("SDF_OpenDevice failed %#08x\n", rt);
// return rt;
// }
// rt = SDF_OpenSession(g_hDev, &g_hSess);
// if (rt) {
// printf("SDF_OpenSession failed %#08x\n", rt);
// SDF_CloseDevice(g_hDev);
// return rt;
// }
//}
//int pass_voidHandle(void *handle) {
// (void)handle;
//}
//void closeHSM() {
// SDF_CloseSession(g_hSess);
// SDF_CloseDevice(g_hDev);
//}
import "C"
import (
"errors"
"fmt"
"unsafe"
"github.com/33cn/chain33/common/crypto"
)
var (
//g_hDev *C.int
//g_hSess *C.void
//g_passwd []byte
//g_passwdLen int
//SM2ID = []byte{0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38}
)
const (
SDF_Success = C.int(0)
SM2IDSize = C.uint(16)
)
//OpenHSMSession:打开TASS HSM PCIe设备并建立session
func OpenHSMSession() error {
C.pass_voidHandle(C.g_hDev)
if rt := C.setupHSM(); int(rt) != 0 {
return errors.New(fmt.Sprintf("Failde to setup HSM with error code:%#08x", int(rt)))
}
return nil
}
//CloseHSMSession:关闭设备
func CloseHSMSession() error {
C.closeHSM()
return nil
}
//获取私钥访问权限
func GetPrivateKeyAccessRight(passwordStr string, keyIndex int) error {
passwd := (*C.uchar)(unsafe.Pointer(C.CString(passwordStr)))
defer C.free(unsafe.Pointer(passwd))
passwdLen := len(passwordStr)
rt := C.TassGetPrivateKeyAccessRight(C.g_hSess, C.uint(keyIndex), C.TA_ALG_ECC_SECP_256K1, passwd, C.uint(passwdLen))
if SDF_Success != rt {
return errors.New(fmt.Sprintf("GetPrivateKeyAccessRight failed %#08x", int(rt)))
}
return nil
}
//释放私钥访问权限
func ReleaeAccessRight(keyIndex int) error {
rt := C.SDF_ReleasePrivateKeyAccessRight(C.g_hSess, C.uint(keyIndex))
if SDF_Success != rt {
return errors.New(fmt.Sprintf("ReleaeAccessRight failed %#08x", int(rt)))
}
return nil
}
//获取签名
func SignSecp256k1(msg []byte, keyIndex int) (signatureR, signatureS []byte, err error) {
hash := crypto.Sha256(msg)
hash2sign := (*C.uchar)(C.CBytes(hash))
defer C.free(unsafe.Pointer(hash2sign))
rt := C.TassECCPrivateKeySign_Eth(C.g_hSess, C.TA_ALG_ECC_SECP_256K1, C.uint(keyIndex), C.uint(256), C.skCipherByKek, C.uint(0), hash2sign, C.uint(32), C.RSPtr, C.signatureLenPtr)
if SDF_Success != rt {
return nil, nil, errors.New(fmt.Sprintf("TassECCPrivateKeySign failed %#08x", int(rt)))
}
r := C.GoBytes(unsafe.Pointer(&C.RS[0]), C.int(32))
s := C.GoBytes(unsafe.Pointer(&C.RS[32]), C.int(32))
return r, s, nil
}
func SignSM2Internal(msg []byte, keyIndex int) (signatureR, signatureS []byte, err error) {
var signPubKey C.ECCrefPublicKey
rt := C.SDF_ExportSignPublicKey_ECC(C.g_hSess, C.uint(keyIndex), &signPubKey)
if SDF_Success != rt {
return nil, nil, errors.New(fmt.Sprintf("SDF_ExportSignPublicKey_ECC failed:%08x", int(rt)))
}
//fmt.Println("SDF_ExportSignPublicKey_ECC success for chain33 verification\n")
//fmt.Printf("chain33 PubKey.bits: %d\n", int(signPubKey.bits))
//fmt.Printf("chain33 PubKey.x: %s\n", common.ToHex(C.GoBytes(unsafe.Pointer(&signPubKey.x[0]), C.int(64))))
//fmt.Printf("chain33 PubKey.y: %s\n", common.ToHex(C.GoBytes(unsafe.Pointer(&signPubKey.y[0]), C.int(64))))
rt = C.SDF_HashInit(C.g_hSess, C.SGD_SM3, &signPubKey, &C.SM2ID[0], SM2IDSize)
if SDF_Success != rt {
return nil, nil, errors.New(fmt.Sprintf("SDF_HashInit failed %#08x", int(rt)))
}
//fmt.Println("SDF_HashInit success\n")
msg2C := (*C.uchar)(C.CBytes(msg))
defer C.free(unsafe.Pointer(msg2C))
rt = C.SDF_HashUpdate(C.g_hSess, msg2C, C.uint(len(msg)))
if SDF_Success != rt {
return nil, nil, errors.New(fmt.Sprintf("SDF_HashUpdate failed %#08x", int(rt)))
}
//fmt.Println("SDF_HashUpdate success\n")
hashlen := C.uint(32)
rt = C.SDF_HashFinal(C.g_hSess, &C.sm3Hash[0], &hashlen)
if SDF_Success != rt {
return nil, nil, errors.New(fmt.Sprintf("SDF_HashFinal failed %#08x", int(rt)))
}
//fmt.Printf("SDF_HashFinal success! sm3Hash = %s\n", common.ToHex(C.GoBytes(unsafe.Pointer(&C.sm3Hash[0]), C.int(32))))
//0x726106a793a45af8ee1b9b6781b87391e4b49304a5f12f6dff82c7edb5f58390
var sign C.ECCSignature
rt = C.SDF_InternalSign_ECC(C.g_hSess, C.uint(keyIndex), &C.sm3Hash[0], hashlen, &sign)
if SDF_Success != rt {
return nil, nil, errors.New(fmt.Sprintf("SDF_InternalSign_ECC failed %#08x", int(rt)))
}
//fmt.Println("SDF_InternalSign_ECC success! ")
r := C.GoBytes(unsafe.Pointer(&sign.r[0]), C.int(64))
s := C.GoBytes(unsafe.Pointer(&sign.s[0]), C.int(64))
return r, s, nil
}
func MakeDERsignature(rb, sb []byte) []byte {
if rb[0] > 0x7F {
rb = append([]byte{0}, rb...)
}
if sb[0] > 0x7F {
sb = append([]byte{0}, sb...)
}
// total length of returned signature is 1 byte for each magic and
// length (6 total), plus lengths of r and s
length := 6 + len(rb) + len(sb)
b := make([]byte, length)
b[0] = 0x30
b[1] = byte(length - 2)
b[2] = 0x02
b[3] = byte(len(rb))
offset := copy(b[4:], rb) + 4
b[offset] = 0x02
b[offset+1] = byte(len(sb))
copy(b[offset+2:], sb)
return b
}
plugin/crypto/tasshsm/app/main.go deleted 100644 → 0
View file @ 9ed41107
package main
import (
"fmt"
"math/big"
"time"
"github.com/33cn/chain33/system/crypto/secp256k1"
"github.com/33cn/chain33/common/crypto"
ethCrypto "github.com/ethereum/go-ethereum/crypto"
"github.com/33cn/chain33/system/crypto/sm2"
gmsm_sm2 "github.com/tjfoc/gmsm/sm2"
"github.com/33cn/chain33/common"
"github.com/33cn/plugin/plugin/crypto/tasshsm/adapter"
)
func verifySM2Signature(rBytes, sBytes, msg []byte) bool {
xBytes, _ := common.FromHex("0000000000000000000000000000000000000000000000000000000000000000FD4241057FEC6CBEEC501F7E1763751B8F6DFCFB910FB634FBB76A16639EF172")
yBytes, _ := common.FromHex("00000000000000000000000000000000000000000000000000000000000000001C6DA89F9C1A5EE9B6108E5A2A5FE336962630A34DBA1AF428451E1CE63BB3CF")
x := new(big.Int).SetBytes(xBytes)
y := new(big.Int).SetBytes(yBytes)
publicKey := &gmsm_sm2.PublicKey{
X: x,
Y: y,
}
var pubSM2 sm2.PubKeySM2
copy(pubSM2[:], gmsm_sm2.Compress(publicKey))
r := new(big.Int).SetBytes(rBytes)
s := new(big.Int).SetBytes(sBytes)
signature := sm2.SignatureSM2(sm2.Serialize(r, s))
return pubSM2.VerifyBytes(msg, signature)
}
func main() {
if err := adapter.OpenHSMSession(); nil != err {
panic("Failed to OpenHSMSession")
}
fmt.Println("Succeed to OpenHSMSession")
fmt.Println(" ")
fmt.Println(" ")
fmt.Println(" ")
keyIndex := 1
passwd := "a1234567"
//passwd := []byte("a1234567")
if err := adapter.GetPrivateKeyAccessRight(passwd, keyIndex); nil != err {
panic("Failed to GetPrivateKeyAccessRight")
}
verifySecp256k1(keyIndex)
if err := adapter.ReleaeAccessRight(keyIndex); nil != err {
panic("Failed to GetPrivateKeyAccessRight")
}
adapter.CloseHSMSession()
}
func verifySecp256k1(keyIndex int) {
msg, _ := common.FromHex("456789")
r, s, err := adapter.SignSecp256k1(msg, keyIndex)
if err != nil {
panic("Failed to SignSecp256k1 due to:" + err.Error())
}
fmt.Println("signature R=", common.ToHex(r))
fmt.Println("signature S=", common.ToHex(s))
///////构建公钥////////
pub, _ := common.FromHex("04C24FBA65F8CD81223D2935EDEA663048A1BEFB5A78BC67C80DCB5A1D601F898C35EA242D2E76CACE9EE5A61DBDA29A5076707325FE20B5A80DB0CA6D02C5D983")
///////构建以太坊签名并验证////////
ethSig := append(r, s...)
hash := crypto.Sha256(msg)
VerifyResult4Eth := ethCrypto.VerifySignature(pub, hash[:], ethSig[:64])
if !VerifyResult4Eth {
panic("Failed to do Signature verification for Ethereum")
}
fmt.Println(" ^-^ Succeed to do signature verification for Ethereum ^-^ ")
fmt.Println(" ")
fmt.Println(" ")
fmt.Println(" ")
///////构建chain33签名并验证////////
derSig := adapter.MakeDERsignature(r, s)
fmt.Println(" derSig ", common.ToHex(derSig))
secpPubKey, err := ethCrypto.UnmarshalPubkey(pub)
pub33Bytes := ethCrypto.CompressPubkey(secpPubKey)
c := &secp256k1.Driver{}
chain33PubKey, _ := c.PubKeyFromBytes(pub33Bytes)
chain33Sig, err := c.SignatureFromBytes(derSig)
VerifyResult4Chain33 := chain33PubKey.VerifyBytes(msg, chain33Sig)
if !VerifyResult4Chain33 {
panic("Failed to do Signature verification for Chain33")
}
fmt.Println(" ^-^ Succeed to do signature verification for Chain33 ^-^ ")
}
func verifySM2() {
//msg := []byte("112233445566112233445566112233445566112233445566")
msg, _ := common.FromHex("112233445566112233445566112233445566112233445566")
r, s, err := adapter.SignSM2Internal(msg, 10)
if err != nil {
panic("Failed to SignSM2Internal due to:" + err.Error())
}
fmt.Println("signature R=", common.ToHex(r))
fmt.Println("signature S=", common.ToHex(s))
///////构建公钥////////
xBytes, _ := common.FromHex("0000000000000000000000000000000000000000000000000000000000000000FD4241057FEC6CBEEC501F7E1763751B8F6DFCFB910FB634FBB76A16639EF172")
yBytes, _ := common.FromHex("00000000000000000000000000000000000000000000000000000000000000001C6DA89F9C1A5EE9B6108E5A2A5FE336962630A34DBA1AF428451E1CE63BB3CF")
x := new(big.Int).SetBytes(xBytes)
y := new(big.Int).SetBytes(yBytes)
publicKey := &gmsm_sm2.PublicKey{
X: x,
Y: y,
}
var pubSM2 sm2.PubKeySM2
copy(pubSM2[:], gmsm_sm2.Compress(publicKey))
///////开始循环验证签名////////
now := time.Now()
now.Nanosecond()
msLater := now.Nanosecond()
fmt.Printf("msLater = %d\n", msLater)
time.Sleep(time.Millisecond)
msLater = now.Nanosecond()
fmt.Printf("msLater = %d\n", time.Now().Nanosecond())
fmt.Printf("msLater Sec = %d\n", time.Now().Second())
for i := 0; i < 10*1000; i++ {
adapter.SignSM2Internal(msg, 10)
//rBytes, sBytes, _ := adapter.SignSM2Internal(msg, 10)
//fmt.Println("rBytes = ", common.ToHex(rBytes))
//fmt.Println("sBytes = ", common.ToHex(sBytes))
//r := new(big.Int).SetBytes(rBytes)
//s := new(big.Int).SetBytes(sBytes)
//signature := sm2.SignatureSM2(sm2.Serialize(r, s))
//if !pubSM2.VerifyBytes(msg, signature) {
// panic("Failed to do VerifyBytes")
//}
//fmt.Println("Succeed to do VerifyBytes for times = ", i)
}
fmt.Println(" ")
fmt.Printf("testLater = %d\n", time.Now().Nanosecond())
fmt.Printf("testLater sec = %d\n", time.Now().Second())
fmt.Println(" ")
fmt.Println(" ^-^ Successful ^-^ ")
}
plugin/crypto/tasshsm/include/SDF4PCIeSM.h deleted 100644 → 0
View file @ 9ed41107
/**
* Copyright (C) 2010-2023 TASS
* @file TassSDF4PCIECrypotoCard.h
* @brief 根据GM/T 0018 《密码设备应用接口规范》声明相关函数
* @detail 本文件为实现SDF接口提供了相应的模板，使用者可根据该模板完成
* 特定设备的SDF接口开发
* @author Lgl
* @version 1.0.0
* @date 2021/02/19
* Change History :
* <Date> | <Version> | <Author> | <Description>
*---------------------------------------------------------------------
* 2021/02/19 | 1.0.0 | Lgl | Create file
*---------------------------------------------------------------------
* 2021/09/19 | 2.0.0 | Lgl | Optimized interface function
*---------------------------------------------------------------------
*/
#pragma once
#ifdef __cplusplus
extern "C" {
#endif
/**
*分组密码算法标识
*/
#define SGD_SM1_ECB 0X00000101 //SM1算法ECB加密模式
#define SGD_SM1_CBC 0X00000102 //SM1算法CBC加密模式
#define SGD_SM1_CFB 0X00000104 //SM1算法CFB加密模式
#define SGD_SM1_OFB 0X00000108 //SM1算法OFB加密模式
#define SGD_SM1_MAC 0X00000110 //SM1算法MAC运算
#define SGD_SSF33_ECB 0X00000201 //SSF33算法ECB加密模式
#define SGD_SSF33_CBC 0X00000202 //SSF33算法CBC加密模式
#define SGD_SSF33_CFB 0X00000204 //SSF33算法CFB加密模式
#define SGD_SSF33_OFB 0X00000208 //SSF33算法OFB加密模式
#define SGD_SSF33_MAC 0X00000210 //SSF33算法MAC运算
#define SGD_SM4_ECB 0X00000401 //SM4算法ECB加密模式
#define SGD_SM4_CBC 0X00000402 //SM4算法CBC加密模式
#define SGD_SM4_CFB 0X00000404 //SM4算法CFB加密模式
#define SGD_SM4_OFB 0X00000408 //SM4算法OFB加密模式
#define SGD_SM4_MAC 0X00000410 //SM4算法MAC运算
#define SGD_ZUC_EEA3 0X00000801 //ZUC祖冲之机密性算法128-EEA3算法
#define SGD_ZUC_EIA3 0X00000802 //ZUC祖冲之机密性算法128-EIA3算法
/*TASS扩展*/
#define SGD_DES_ECB 0x80000101 // DES算法ECB加密模式
#define SGD_DES_CBC 0x80000102 // DES算法CBC加密模式
#define SGD_DES_CFB 0x80000104 // DES算法CFB加密模式
#define SGD_DES_OFB 0x80000108 // DES算法OFB加密模式
#define SGD_DES_MAC 0X80000110 // DES算法MAC运算
#define SGD_AES_ECB 0x80000201 // AES算法ECB加密模式
#define SGD_AES_CBC 0x80000202 // AES算法CBC加密模式
#define SGD_AES_CFB 0x80000204 // AES算法CFB加密模式
#define SGD_AES_OFB 0x80000208 // AES算法OFB加密模式
#define SGD_AES_MAC 0x80000210 // AES算法MAC运算
/**
*非对称密码算法标识
*/
#define SGD_RSA 0X00010000 //RSA算法
#define SGD_SM2 0X00020100 //SM2椭圆曲线密码算法
#define SGD_SM2_1 0X00020200 //SM2椭圆曲线签名算法
#define SGD_SM2_2 0X00020400 //SM2椭圆曲线密钥交换协议
#define SGD_SM2_3 0X00020800 //SM2椭圆曲线加密算法
/**
*密码杂凑算法标识
*/
#define SGD_SM3 0X00000001 //SM3杂凑算法
#define SGD_SHA256 0X00000004 //SHA_256杂凑算法
typedef struct DeviceInfo_st {
unsigned char IssuerName[40];//设备生产厂商名称
unsigned char DeviceName[16];//设备型号
unsigned char DeviceSerial[16];//设备编号，包含日期（8字符）、批次号（3字符）、流水号（5字符）
unsigned int DeviceVersion;//密码设备内部软件版本号
unsigned int StandardVersion;//密码设备支持的接口规范版本号
unsigned int AsymAlgAbility[2];///<非对称算法能力，前4字节表示支持的算法，非对称算法标识按位异或，后4字节表示算法的最大模长，表示方法为支持模长按位异或的结果
unsigned int SymAlgAbility;//对称算法能力，对称算法标识按位异或
unsigned int HashAlgAbility;//杂凑算法能力，杂凑算法标识按位异或
unsigned int BufferSize;//支持的最大文件存储空间（单位字节）
}DEVICEINFO;
#define RSAref_MAX_BITS 2048//4096
#define RSAref_MAX_LEN ((RSAref_MAX_BITS + 7) / 8)
#define RSAref_MAX_PBITS ((RSAref_MAX_BITS + 1) / 2)
#define RSAref_MAX_PLEN ((RSAref_MAX_PBITS + 7) / 8)
typedef struct RSArefPublicKey_st {
unsigned int bits;
unsigned char m[RSAref_MAX_LEN];
unsigned char e[RSAref_MAX_LEN];
}RSArefPublicKey;
typedef struct RSArefPrivateKey_st {
unsigned int bits;
unsigned char m[RSAref_MAX_LEN];
unsigned char e[RSAref_MAX_LEN];
unsigned char d[RSAref_MAX_LEN];
unsigned char prime[2][RSAref_MAX_PLEN];
unsigned char pexp[2][RSAref_MAX_PLEN];
unsigned char coef[RSAref_MAX_PLEN];
}RSArefPrivateKey;
#define ECCref_MAX_BITS 512
#define ECCref_MAX_LEN ((ECCref_MAX_BITS + 7) / 8)
typedef struct ECCrefPublicKey_st {
unsigned int bits;
unsigned char x[ECCref_MAX_LEN];
unsigned char y[ECCref_MAX_LEN];
}ECCrefPublicKey;
typedef struct ECCrefPrivateKey_st {
unsigned int bits;
unsigned char K[ECCref_MAX_LEN];
}ECCrefPrivateKey;
typedef struct ECCCipher_st {
unsigned char x[ECCref_MAX_LEN];
unsigned char y[ECCref_MAX_LEN];
unsigned char M[32];
unsigned int L;
unsigned char C[1024];
}ECCCipher;
typedef struct ECCSignature_st {
unsigned char r[ECCref_MAX_LEN];
unsigned char s[ECCref_MAX_LEN];
}ECCSignature;
/**
*@brief GMT 0018-2012 未定义ECCCIPHERBLOB/ECCPUBLICKEYBLOB，推测使用如下定义
*/
typedef ECCCipher ECCCIPHERBLOB;
typedef ECCrefPublicKey ECCPUBLICKEYBLOB;
typedef struct SDF_ENVELOPEDKEYBLOB {
unsigned long ulAsymmAlgID;
unsigned long ulSymmAlgID;
ECCCIPHERBLOB ECCCipherBlob;
ECCPUBLICKEYBLOB PubKey;
unsigned char cbEncryptedPriKey[ECCref_MAX_LEN];
}ENVELOPEDKEYBLOB, * PENVELOPEDKEYBLOB;
/**
*以下设备管理类函数
*/
/**
* @brief 打开密码设备
* @param phDeviceHandle [OUT] 返回设备句柄
* @return
* @retval 0 成功
* @retval 非0 失败，返回错误代码
* @note phDeviceHandle由函数初始化并填写内容
*/
int SDF_OpenDevice(void** phDeviceHandle);
/**
* @brief 关闭密码设备，并释放相关资源
* @param hDeviceHandle [IN] 已打开的设备句柄
* @return
* @retval 0 成功
* @retval 非0 失败，返回错误代码
*/
int SDF_CloseDevice(void* hDeviceHandle);
/**
* @brief 创建与密码设备的会话
* @param hDeviceHandle [IN] 已打开的设备句柄
* @param phSessionHandle [OUT] 返回与密码设备建立的新会话句柄
* @return
* @retval 0 成功
* @retval 非0 失败，返回错误代码
*/
int SDF_OpenSession(void* hDeviceHandle, void** phSessionHandle);
/**
* @brief 关闭与密码设备已建立的会话，并释放相关资源
* @param hSessionHandle [IN] 与密码设备已建立的会话句柄
* @return
* @retval 0 成功
* @retval 非0 失败，返回错误代码
*/
int SDF_CloseSession(void* hSessionHandle);
/**
* @brief 获取密码设备能力描述
* @param hSessionHandle [IN] 与设备建立的会话句柄
* @param pstDeviceInfo [OUT] 设备能力描述信息
* @return
* @retval 0 成功
* @retval 非0 失败，返回错误代码
*/
int SDF_GetDeviceInfo(
void* hSessionHandle,
DEVICEINFO* pstDeviceInfo);
/**
* @brief 产生随机数
* @param hSessionHandle [IN] 与设备建立的会话句柄
* @param uiLength [IN] 欲获取的随机数长度
* @param pucRandom [OUT] 缓冲区指针，用于存放获取的随机数
* @return
* @retval 0 成功
* @retval 非0 失败，返回错误代码
*/
int SDF_GenerateRandom(
void* hSessionHandle,
unsigned int uiLength,
unsigned char* pucRandom);
/**
* @brief 获取密码设备内部存储的指定索引私钥的使用权
* @param hSessionHandle [IN] 与设备建立的会话句柄
* @param uiKeyIndex [IN] 密码设备存储私钥的索引值
* TASS补充：正数获取SM2密钥权限，负数获取RSA密钥权限
* @param pucPassword [IN] 使用私钥权限的识别码，默认为a1234567
* @param uiPwdLength [IN] 私钥访问控制码长度
* @return
* @retval 0 成功
* @retval 非0 失败，返回错误代码
* @note 本标准涉及密码设备存储的密钥对索引值的起始索引值为1，最大为n，
* 密码设备的实际存储容量决定n值
*/
int SDF_GetPrivateKeyAccessRight(
void* hSessionHandle,
unsigned int uiKeyIndex,
unsigned char* pucPassword,
unsigned int uiPwdLength);
/**
* @brief 释放密码设备存储的指定索引私钥的使用授权
* @param hSessionHandle [IN] 与设备建立的会话句柄
* @param uiKeyIndex [IN] 密码设备存储私钥的索引值
* TASS补充：正数释放SM2密钥权限，负数释放RSA密钥权限
* @return
* @retval 0 成功
* @retval 非0 失败，返回错误代码
*/
int SDF_ReleasePrivateKeyAccessRight(
void* hSessionHandle,
unsigned int uiKeyIndex);
/**
*以下密钥管理类函数
*/
/**
* @brief 导出密码设备内部存储的指定索引位置的签名公钥
* @param hSessionHandle [IN] 与设备建立的会话句柄
* @param uiKeyIndex [IN] 密码设备存储的RSA密钥对索引值
* @param pucPublicKey [OUT] RSA公钥结构
* @return
* @retval 0 成功
* @retval 非0 失败，返回错误代码
*/
int SDF_ExportSignPublicKey_RSA(
void* hSessionHandle,
unsigned int uiKeyIndex,
RSArefPublicKey* pucPublicKey);
/**
* @brief 导出密码设备内部存储的指定索引位置的加密公钥
* @param hSessionHandle [IN] 与设备建立的会话句柄
* @param uiKeyIndex [IN] 密码设备存储的RSA密钥对索引值
* @param pucPublicKey [OUT] RSA公钥结构
* @return
* @retval 0 成功
* @retval 非0 失败，返回错误代码
*/
int SDF_ExportEncPublicKey_RSA(
void* hSessionHandle,
unsigned int uiKeyIndex,
RSArefPublicKey* pucPublicKey);
/**
* @brief 请求密码设备产生指定模长的RSA密钥对（明文）
* @param hSessionHandle [IN] 与设备建立的会话句柄
* @param uiKeyIndex [IN] 指定密钥模长
* @param pucPublicKey [OUT] RSA公钥结构
* TASS补充：若需要保存到加密机内部加密密钥对
* 可设置pucPublicKey->bits为索引值，此时不输出pucPrivateKey
* @param pucPrivateKey [OUT] RSA私钥结构（pucPublicKey->bits输出为私钥实际长度，可从私钥结构体的成员m、e、d依次拷贝pucPublicKey->bits长度的数据，即为真实的私钥密文数据）
* @return
* @retval 0 成功
* @retval 非0 失败，返回错误代码
*/
int SDF_GenerateKeyPair_RSA(
void* hSessionHandle,
unsigned int uiKeyBits,
RSArefPublicKey* pucPublicKey,
RSArefPrivateKey* pucPrivateKey);
/**
* @brief 生成会话密钥并用指定索引的内部加密公钥加密输出，同时返回密钥句柄
* @param hSessionHandle [IN] 与设备建立的会话句柄
* @param uiIPKIndex [IN] 密码设备内部存储公钥的索引值
* @param uiKeyBits [IN] 指定产生的会话密钥长度，支持2048bits（256字节）
* @param pucKey [OUT] 缓冲区指针，用于存放返回的密钥密文
* @param puiKeyLength [IN/OUT] 返回的密钥密文长度
* @param phKeyHandle [OUT] 返回的密钥句柄，传入前需先赋值为NULL
* @return
* @retval 0 成功
* @retval 非0 失败，返回错误代码
* @note 公钥加密数据是填充方式按照PKCS#1 v1.5的要求进行
*/
int SDF_GenerateKeyWithIPK_RSA(
void* hSessionHandle,
unsigned int uiIPKIndex,
unsigned int uiKeyBits,
unsigned char* pucKey,
unsigned int* puiKeyLength,
void** phKeyHandle);
/**
* @brief 生成会话密钥并用外部公钥加密输出，同时返回密钥句柄
* @param hSessionHandle [IN] 与设备建立的会话句柄
* @param uiKeyBits [IN] 指定产生的会话密钥长度，仅支持128（16字节）
* @param pucPublicKey [IN] 输入的外部RSA公钥结构
* @param pucKey [OUT] 缓冲区指针，用于存放返回的密钥密文
* @param puiKeyLength [OUT] 返回的密钥密文长度
* @param phKeyHandle [OUT] 返回的密钥句柄，传入前需先赋值为NULL
* @return
* @retval 0 成功
* @retval 非0 失败，返回错误代码
* @note 公钥加密数据是填充方式按照PKCS#1 v1.5的要求进行
*/
int SDF_GenerateKeyWithEPK_RSA(
void* hSessionHandle,
unsigned int uiKeyBits,
RSArefPublicKey* pucPublicKey,
unsigned char* pucKey,
unsigned int* puiKeyLength,
void** phKeyHandle);
/**
* @brief 导入会话密钥并用内部私钥解密，同时返回密钥句柄
* @param hSessionHandle [IN] 与设备建立的会话句柄
* @param uiISKIndex [IN] 密码设备内部存储加密私钥的索引值，对应于加密时的公钥
* @param pucKey [IN] 缓冲区指针，用于存放输入的密钥密文
* @param puiKeyLength [IN] 输入密钥密文长度
* @param phKeyHandle [OUT] 返回的密钥句柄，传入前需先赋值为NULL
* @return
* @retval 0 成功
* @retval 非0 失败，返回错误代码
* @note 填充方式与公钥加密时相同
*/
int SDF_ImportKeyWithISK_RSA(
void* hSessionHandle,
unsigned int uiISKIndex,
unsigned char* pucKey,
unsigned int uiKeyLength,
void** phKeyHandle);
/**
* @brief 将由内部公钥加密的会话密钥转换为由外部指定的公钥加密，可用于数字信封转换
* @param hSessionHandle [IN] 与设备建立的会话句柄
* @param uiKeyIndex [IN] 密码设备存储的内部RSA密钥对索引值
* @param pucPublicKey [IN] 外部RSA公钥结构
* @param pucDEInput [IN] 缓冲区指针，用于存放输入的会话密钥密文
* @param uiDELength [IN] 输入的会话密钥密文长度
* @param pucDEOuput [OUT] 缓冲区指针，用于存放输出的会话密钥密文
* @param puiDELength [OUT] 输出的会话密钥密文长度
* @return
* @retval 0 成功
* @retval 非0 失败，返回错误代码
* @note 填充方式与公钥加密时相同
*/
int SDF_ExchangeDigitEnvelopeBaseOnRSA(
void* hSessionHandle,
unsigned int uiKeyIndex,
RSArefPublicKey* pucPublicKey,
unsigned char* pucDEInput,
unsigned int uiDELength,
unsigned char* pucDEOuput,
unsigned int* puiDELength);
/**
* @brief 导出密码设备内部存储的指定索引位置的签名公钥
* @param hSessionHandle [IN] 与设备建立的会话句柄
* @param uiKeyIndex [IN] 密码设备存储的ECC密钥对索引值
* @param pucPublicKey [OUT] ECC公钥结构
* @return
* @retval 0 成功
* @retval 非0 失败，返回错误代码
*/
int SDF_ExportSignPublicKey_ECC(
void* hSessionHandle,
unsigned int uiKeyIndex,
ECCrefPublicKey* pucPublicKey);
/**
* @brief 导出密码设备内部存储的指定索引位置的加密公钥
* @param hSessionHandle [IN] 与设备建立的会话句柄
* @param uiKeyIndex [IN] 密码设备存储的ECC密钥对索引值
* @param pucPublicKey [OUT] ECC公钥结构
* @return
* @retval 0 成功
* @retval 非0 失败，返回错误代码
*/
int SDF_ExportEncPublicKey_ECC(
void* hSessionHandle,
unsigned int uiKeyIndex,
ECCrefPublicKey* pucPublicKey);
/**
* @brief 请求密码设备产生指定和模长的ECC密钥对
* @param hSessionHandle [IN] 与设备建立的会话句柄
* @param uiAlgID [IN] 指定算法标识
* @param uiKeyBits [IN] 指定密钥模长，只支持256bit（32字节）
* @param pucPublicKey [OUT] ECC公钥结构
* TASS补充：若需要保存到加密机内部加密密钥对
* 可设置pucPublicKey->bits为索引值，此时不输出pucPrivateKey
* @param pucPrivateKey [OUT] RSA私钥结构
* TASS补充：若需要保存到加密机内部签名密钥对，
* 可设置pucPrivateKey->bits为索引值，此时不输出pucPrivateKey
* @return
* @retval 0 成功
* @retval 非0 失败，返回错误代码
*/
int SDF_GenerateKeyPair_ECC(
void* hSessionHandle,
unsigned int uiAlgID,
unsigned int uiKeyBits,
ECCrefPublicKey* pucPublicKey,
ECCrefPrivateKey* pucPrivateKey);
/**
* @brief 生成会话密钥并用指定索引的内部ECC加密公钥加密输出，同时返回密钥句柄
* @param hSessionHandle [IN] 与设备建立的会话句柄
* @param uiIPKIndex [IN] 密码设备内部存储公钥的索引值
* @param uiKeyBits [IN] 指定产生的会话密钥长度，支持128bits（16字节）
* @param pucKey [OUT] 缓冲区指针，用于存放返回的密钥密文
* @param phKeyHandle [OUT] 返回的密钥句柄，传入前需先赋值为NULL
* @return
* @retval 0 成功
* @retval 非0 失败，返回错误代码
* @note 公钥加密数据是填充方式按照PKCS#1 v1.5的要求进行
*/
int SDF_GenerateKeyWithIPK_ECC(
void* hSessionHandle,
unsigned int uiIPKIndex,
unsigned int uiKeyBits,
ECCCipher* pucKey,
void** phKeyHandle);
/**
* @brief 生成会话密钥并用外部ECC公钥加密输出，同时返回密钥句柄
* @param hSessionHandle [IN] 与设备建立的会话句柄
* @param uiKeyBits [IN] 指定产生的会话密钥长度，支持128bits（16字节）
* @param uiAlgID [IN] 外部ECC公钥的算法标识
* @param pucPublicKey [IN] 输入的外部ECC公钥结构
* @param pucKey [OUT] 缓冲区指针，用于存放返回的密钥密文
* @param phKeyHandle [OUT] 返回的密钥句柄，传入前需先赋值为NULL
* @return
* @retval 0 成功
* @retval 非0 失败，返回错误代码
* @note 公钥加密数据是填充方式按照PKCS#1 v1.5的要求进行
*/
int SDF_GenerateKeyWithEPK_ECC(
void* hSessionHandle,
unsigned int uiKeyBits,
unsigned int uiAlgID,
ECCrefPublicKey* pucPublicKey,
ECCCipher* pucKey,
void** phKeyHandle);
/**
* @brief 导入会话密钥并用内部ECC加密私钥解密，同时返回密钥句柄
* @param hSessionHandle [IN] 与设备建立的会话句柄
* @param uiISKIndex [IN] 密码设备内部存储加密私钥的索引值，对应于加密时的公钥
* @param pucKey [IN] 缓冲区指针，用于存放输入的密钥密文
* @param phKeyHandle [OUT] 返回的密钥句柄，传入前需先赋值为NULL
* @return
* @retval 0 成功
* @retval 非0 失败，返回错误代码
* @note 填充方式与公钥加密时相同
*/
int SDF_ImportKeyWithISK_ECC(
void* hSessionHandle,
unsigned int uiISKIndex,
ECCCipher* pucKey,
void** phKeyHandle);
/**
* @brief 使用ECC密钥协商算法，为计算会话密钥而产生协商参数，同时返回指定索引位置的ECC公钥、临时ECC密钥对的公钥及协商句柄
* @param hSessionHandle [IN] 与设备建立的会话句柄
* @param uiISKIndex [IN] 密码设备内部存储加密私钥的索引值，该私钥用于参与密钥协商
* @param uiKeyBits [IN] 要求协商的密钥长度，支持128bits（16字节）
* @param pucSponsorID [IN] 参与密钥协商的发起方ID值
* @param uiSponsorIDLength [IN] 发起方ID长度
* @param pucSponsorPublicKey [OUT] 返回的发起方ECC公钥结构
* @param pucSponsorTmpPublicKey [OUT] 返回的发起方临时ECC公钥结构
* @param phAgreementHandle [OUT] 返回的协商句柄，用于计算协商密钥
* @return
* @retval 0 成功
* @retval 非0 失败，返回错误代码
* @note 为协商会话密钥，协商的发起方应首先调用本函数
*/
int SDF_GenerateAgreementDataWithECC(
void* hSessionHandle,
unsigned int uiISKIndex,
unsigned int uiKeyBits,
unsigned char* pucSponsorID,
unsigned int uiSponsorIDLength,
ECCrefPublicKey* pucSponsorPublicKey,
ECCrefPublicKey* pucSponsorTmpPublicKey,
void** phAgreementHandle);
/**
* @brief 使用ECC密钥协商算法，使用自身协商句柄和响应方的协商参数计算会话密钥，同时返回会话密钥句柄
* @param hSessionHandle [IN] 与设备建立的会话句柄
* @param pucResponseID [IN] 外部输入的响应方ID值
* @param uiResponseIDLength [IN] 外部输入的响应方ID长度
* @param pucResponsePublicKey [IN] 外部输入的响应方ECC公钥结构
* @param pucResponseTmpPublicKey [IN] 外部输入的响应方临时ECC公钥结构
* @param hAgreementHandle [IN] 协商句柄，用于计算协商密钥
* @param phKeyHandle [OUT] 返回的密钥句柄，传入前需先赋值为NULL
* @return
* @retval 0 成功
* @retval 非0 失败，返回错误代码
* @note 协商的发起方获得响应方的协商参数后调用本函数，计算会话密钥，使用SM2算法计算会话密钥的过程见GM/T 0009
*/
int SDF_GenerateKeyWithECC(
void* hSessionHandle,
unsigned char* pucResponseID,
unsigned int uiResponseIDLength,
ECCrefPublicKey* pucResponsePublicKey,
ECCrefPublicKey* pucResponseTmpPublicKey,
void* hAgreementHandle,
void** phKeyHandle);
/**
* @brief 使用ECC密钥协商算法，产生协商参数并计算会话密钥，同时返回产生的协商参数和密钥句柄
* @param hSessionHandle [IN] 与设备建立的会话句柄
* @param uiISKIndex [IN] 密码设备内部存储加密私钥的索引值，该私钥用于参与密钥协商
* @param uiKeyBits [IN] 要求协商的密钥长度，支持128bits（16字节）
* @param pucResponseID [IN] 响应方ID值
* @param uiResponseIDLength [IN] 响应方ID长度
* @param pucSponsorID [IN] 发起方ID值
* @param uiSponsorIDLength [IN] 发起方ID长度
* @param pucSponsorPublicKey [IN] 外部输入的发起方ECC公钥结构
* @param pucSponsorTmpPublicKey [IN] 外部输入的发起方临时ECC公钥结构
* @param pucResponsePublicKey [OUT] 返回的响应方ECC公钥结构
* @param pucResponseTmpPublicKey [OUT] 返回的响应方临时ECC公钥结构
* @param phKeyHandle [OUT] 返回的密钥句柄，传入前需先赋值为NULL
* @return
* @retval 0 成功
* @retval 非0 失败，返回错误代码
* @note 本函数由响应方调用。使用SM2算法计算会话密钥的过程见GM/T 0009
*/
int SDF_GenerateAgreementDataAndKeyWithECC(
void* hSessionHandle,
unsigned int uiISKIndex,
unsigned int uiKeyBits,
unsigned char* pucResponseID,
unsigned int uiResponseIDLength,
unsigned char* pucSponsorID,
unsigned int uiSponsorIDLength,
ECCrefPublicKey* pucSponsorPublicKey,
ECCrefPublicKey* pucSponsorTmpPublicKey,
ECCrefPublicKey* pucResponsePublicKey,
ECCrefPublicKey* pucResponseTmpPublicKey,
void** phKeyHandle);
/**
* @brief 将由内部公钥加密的会话密钥转换为由外部指定的公钥加密，可用于数字信封转换
* @param hSessionHandle [IN] 与设备建立的会话句柄
* @param uiKeyIndex [IN] 密码设备存储的内部ECC密钥对索引值
* @param uiAlgID [IN] 外部ECC公钥的算法标识
* @param pucPublicKey [IN] 外部ECC公钥结构
* @param pucEncDataIn [IN] 缓冲区指针，用于存放输入的会话密钥密文
* @param pucEncDataOut [OUT] 缓冲区指针，用于存放输出的会话密钥密文
* @return
* @retval 0 成功
* @retval 非0 失败，返回错误代码
* @note 填充方式与公钥加密时相同
*/
int SDF_ExchangeDigitEnvelopeBaseOnECC(
void* hSessionHandle,
unsigned int uiKeyIndex,
unsigned int uiAlgID,
ECCrefPublicKey* pucPublicKey,
ECCCipher* pucEncDataIn,
ECCCipher* pucEncDataOut);
/**
* @brief 生成会话密钥并用密钥加密密钥加密输出，同时返回密钥句柄
* @param hSessionHandle [IN] 与设备建立的会话句柄
* @param uiKeyBits [IN] 指定产生的会话密钥长度，支持128bits（16字节）
* @param uiAlgID [IN] 算法标识，指定对称加密算法,仅支持SGD_SM1_ECB
* @param uiKEKIndex [IN] 密码设备内部存储的加密密钥的索引值
* @param pucKey [OUT] 缓冲区指针，用于存放返回的密钥密文
* @param puiKeyLength [OUT] 返回的密钥密文长度
* @param phKeyHandle [OUT] 返回的密钥句柄，传入前需先赋值为NULL
* TASS补充：若需要保存到加密机内部，可使用如下方式
* 如保存到1号索引密钥（仅支持SM4算法），则int idx = 1; void* pIdx = &idx; 传入 &pIdx 即可
* uiKeyBits=128，导入SM4算法
* 此时phKeyHandle不能调用SDF_DestroyKey释放
* @return
* @retval 0 成功
* @retval 非0 失败，返回错误代码
* @note 加密模式使用ECB模式
*/
int SDF_GenerateKeyWithKEK(
void* hSessionHandle,
unsigned int uiKeyBits,
unsigned int uiAlgID,
unsigned int uiKEKIndex,
unsigned char* pucKey,
unsigned int* puiKeyLength,
void** phKeyHandle);
/**
* @brief 导入会话密钥并用密钥加密密钥解密，同时返回密钥句柄
* @param hSessionHandle [IN] 与设备建立的会话句柄
* @param uiAlgID [IN] 算法标识，指定对称加密算法
* @param uiKEKIndex [IN] 密码设备内部存储的加密密钥的索引值
* @param pucKey [IN] 缓冲区指针，用于存放输入的密钥密文
* @param puiKeyLength [IN] 返回的密钥密文长度
* @param phKeyHandle [OUT] 返回的密钥句柄，传入前需先赋值为NULL
* TASS补充：若需要保存到加密机内部（仅支持SM4算法），可使用如下方式
* 如保存到1号索引密钥，则int idx = 1; void* pIdx = &idx; 传入 &pIdx 即可
* uiKeyBits=128，导入SM4算法
* 此时phKeyHandle不能调用SDF_DestroyKey释放
* @return
* @retval 0 成功
* @retval 非0 失败，返回错误代码
* @note 加密模式使用ECB模式
*/
int SDF_ImportKeyWithKEK(
void* hSessionHandle,
unsigned int uiAlgID,
unsigned int uiKEKIndex,
unsigned char* pucKey,
unsigned int uiKeyLength,
void** phKeyHandle);
/**
* @brief 导入明文会话密钥，同时返回密钥句柄
* @param hSessionHandle [IN] 与设备建立的会话句柄
* @param pucKey [IN] 缓冲区指针，用于存放输入的密钥明文
* @param puiKeyLength [IN] 输入的密钥明文长度
* @param phKeyHandle [OUT] 返回的密钥句柄，传入前需先赋值为NULL
* TASS补充：若需要保存到加密机内部（仅支持SM4算法），可使用如下方式
* 如保存到1号索引密钥，则int idx = 1; void* pIdx = &idx; 传入 &pIdx 即可
* uiKeyBits=128，导入SM4算法
* 此时phKeyHandle不能调用SDF_DestroyKey释放
* @return
* @retval 0 成功
* @retval 非0 失败，返回错误代码
*/
int SDF_ImportKey(
void* hSessionHandle,
unsigned char* pucKey,
unsigned int uiKeyLength,
void** phKeyHandle);
/**
* @brief 销毁会话密钥，并释放为密钥句柄分配的内存等资源
* @param hSessionHandle [IN] 与设备建立的会话句柄
* @param hKeyHandle [IN] 输入的密钥句柄，若输入指向索引的指针则删除该内部对称密钥
* TASS补充：若需要删除加密机内部密钥，可使用如下方式
* 如删除1号索引密钥，则int idx = 1; 传入 &idx 即可
* @return
* @retval 0 成功
* @retval 非0 失败，返回错误代码
* @note 在对称算法运算完成后，应调用本函数销毁会话密钥
*/
int SDF_DestroyKey(
void* hSessionHandle,
void* hKeyHandle);
/**
*以下非对称算法运算类函数
*/
/**
* @brief 指定使用外部公钥对数据进行运算
* @param hSessionHandle [IN] 与设备建立的会话句柄
* @param pucPublicKey [IN] 外部RSA公钥结构
* @param pucDataInput [IN] 缓冲区指针，用于存放输入的数据
* @param uiInputLength [IN] 输入的数据长度
* @param pucDataOutput [OUT] 缓冲区指针，用于存放输出的数据
* @param puiOutputLength [OUT] 输出的数据长度
* @return
* @retval 0 成功
* @retval 非0 失败，返回错误代码
* @note 数据格式由应用层封装
*/
int SDF_ExternalPublicKeyOperation_RSA(
void* hSessionHandle,
RSArefPublicKey* pucPublicKey,
unsigned char* pucDataInput,
unsigned int uiInputLength,
unsigned char* pucDataOutput,
unsigned int* puiOutputLength);
/**
* @brief 使用内部指定索引的公钥对数据进行运算
* @param hSessionHandle [IN] 与设备建立的会话句柄
* @param uiKeyIndex [IN] 密码设备内部存储公钥的索引值
* @param pucDataInput [IN] 缓冲区指针，用于存放输入的数据
* @param uiInputLength [IN] 输入的数据长度
* @param pucDataOutput [OUT] 缓冲区指针，用于存放输出的数据
* @param puiOutputLength [OUT] 输出的数据长度
* @return
* @retval 0 成功
* @retval 非0 失败，返回错误代码
* @note 索引范围仅限于内部签名密钥对，数据格式由应用层封装
*/
int SDF_InternalPublicKeyOperation_RSA(
void* hSessionHandle,
unsigned int uiKeyIndex,
unsigned char* pucDataInput,
unsigned int uiInputLength,
unsigned char* pucDataOutput,
unsigned int* puiOutputLength);
/**
* @brief 使用内部指定索引的私钥对数据进行运算
* @param hSessionHandle [IN] 与设备建立的会话句柄
* @param uiKeyIndex [IN] 密码设备内部存储私钥的索引值
* @param pucDataInput [IN] 缓冲区指针，用于存放输入的数据
* @param uiInputLength [IN] 输入的数据长度
* @param pucDataOutput [OUT] 缓冲区指针，用于存放输出的数据
* @param puiOutputLength [OUT] 输出的数据长度
* @return
* @retval 0 成功
* @retval 非0 失败，返回错误代码
* @note 索引范围仅限于内部签名密钥对，数据格式由应用层封装
*/
int SDF_InternalPrivateKeyOperation_RSA(
void* hSessionHandle,
unsigned int uiKeyIndex,
unsigned char* pucDataInput,
unsigned int uiInputLength,
unsigned char* pucDataOutput,
unsigned int* puiOutputLength);
/**
* @brief 使用外部 ECC 私钥对数据进行签名运算
* @param hSessionHandle [IN] 与设备建立的会话句柄
* @param uiAlgID [IN] 算法标识，指定使用的ECC算法
* @param pucPrivateKey [IN] 外部 ECC 私钥结构
* @param pucData [IN] 缓冲区指针，用于存放外部输入的数据
* @param uiDataLength [IN] 输入的数据长度
* @param pucSignature [OUT] 缓冲区指针，用于存放输入的签名值数据
* @return
* @retval 0 成功
* @retval 非0 失败，返回错误代码
* @note 输入数据为待签数据的杂凑值。当使用 SM2 算法时，该输入数据为待签数据经过SM2 签名预处理的结果，预处理过程见 GM/T AAAA。
*/
int SDF_ExternalSign_ECC(
void* hSessionHandle,
unsigned int uiAlgID,
ECCrefPrivateKey* pucPrivateKey,
unsigned char* pucData,
unsigned int uiDataLength,
ECCSignature* pucSignature);
/**
* @brief 使用外部ECC公钥对ECC签名值进行验证运算
* @param hSessionHandle [IN] 与设备建立的会话句柄
* @param uiAlgID [IN] 算法标识，指定使用的ECC算法
* @param pucPublicKey [IN] 外部ECC公钥结构
* @param pucData [IN] 缓冲区指针，用于存放输入的数据
* @param uiDataLength [IN] 输入的数据长度
* @param pucSignature [IN] 缓冲区指针，用于存放输入的签名值数据
* @return
* @retval 0 成功
* @retval 非0 失败，返回错误代码
* @note 输入数据为待签数据的杂凑值。当使用SM2算法时，该输入数据位待签数据经过SM2签名预处理的结果，预处理过程见GM/T0009
*/
int SDF_ExternalVerify_ECC(
void* hSessionHandle,
unsigned int uiAlgID,
ECCrefPublicKey* pucPublicKey,
unsigned char* pucData,
unsigned int uiDataLength,
ECCSignature* pucSignature);
/**
* @brief 使用内部ECC公钥对ECC签名值进行验证运算
* @param hSessionHandle [IN] 与设备建立的会话句柄
* @param uiISKIndex [IN] 密码设备内部存储的ECC签名私钥的索引值
* @param pucData [IN] 缓冲区指针，用于存放外部输入的数据
* @param uiDataLength [IN] 输入的数据长度
* @param pucSignature [OUT] 缓冲区指针，用于存放输出的签名值数据
* @return
* @retval 0 成功
* @retval 非0 失败，返回错误代码
* @note 输入数据为待签数据的杂凑值。当使用SM2算法时，该输入数据位待签数据经过SM2签名预处理的结果，预处理过程见GM/T0009
*/
int SDF_InternalSign_ECC(
void* hSessionHandle,
unsigned int uiISKIndex,
unsigned char* pucData,
unsigned int uiDataLength,
ECCSignature* pucSignature);
/**
* @brief 使用内部ECC公钥对ECC签名值进行验证运算
* @param hSessionHandle [IN] 与设备建立的会话句柄
* @param uiIPKIndex [IN] 密码设备内部存储的ECC签名公钥的索引值
* @param pucData [IN] 缓冲区指针，用于存放外部输入的数据
* @param uiDataLength [IN] 输入的数据长度
* @param pucSignature [IN] 缓冲区指针，用于存放输入的签名值数据
* @return
* @retval 0 成功
* @retval 非0 失败，返回错误代码
* @note 输入数据为待签数据的杂凑值。当使用SM2算法时，该输入数据位待签数据经过SM2签名预处理的结果，预处理过程见GM/T0009
*/
int SDF_InternalVerify_ECC(
void* hSessionHandle,
unsigned int uiIPKIndex,
unsigned char* pucData,
unsigned int uiDataLength,
ECCSignature* pucSignature);
/**
* @brief 使用外部ECC公钥对数据进行加密运算
* @param hSessionHandle [IN] 与设备建立的会话句柄
* @param uiAlgID [IN] 算法标识，指定使用的ECC算法
* @param pucPublicKey [IN] 外部ECC公钥结构
* @param pucData [IN] 缓冲区指针，用于存放输入的数据
* @param uiDataLength [IN] 输入的数据长度
* @param pucEncData [OUT] 缓冲区指针，用于存放输出的数据密文
* @return
* @retval 0 成功
* @retval 非0 失败，返回错误代码
*/
int SDF_ExternalEncrypt_ECC(
void* hSessionHandle,
unsigned int uiAlgID,
ECCrefPublicKey* pucPublicKey,
unsigned char* pucData,
unsigned int uiDataLength,
ECCCipher* pucEncData);
/**
* @brief 使用外部 ECC 私钥进行解密运算
* @param hSessionHandle [IN] 与设备建立的会话句柄
* @param uiAlgID [IN] 算法标识，指定使用的ECC算法
* @param pucPrivateKey [IN] 外部ECC私钥结构
* @param pucEncData [IN] 缓冲区指针，用于存放输入的数据密文
* @param pucData [OUT] 缓冲区指针，用于存放输出的数据明文
* @param puiDataLength [OUT] 缓冲区指针，输出的数据明文长度
* @return
* @retval 0 成功
* @retval 非0 失败，返回错误代码
*/
int SDF_ExternalDecrypt_ECC(
void* hSessionHandle,
unsigned int uiAlgID,
ECCrefPrivateKey* pucPrivateKey,
ECCCipher* pucEncData,
unsigned char* pucData,
unsigned int* puiDataLength);
/**
*以下函数并未包含在GM/T 0018中，但从功能完整性考虑，定义为扩展实现
*/
/**
* @brief 使用内部ECC私钥对数据进行解密运算
* @param hSessionHandle [IN] 与设备建立的会话句柄
* @param uiISKIndex [IN] 密码设备内部存储的ECC解密私钥的索引值
* @param pucEncData [IN] 缓冲区指针，用于存放输入的数据密文
* @param pucData [OUT] 缓冲区指针，用于存放输出的数据
* @param uiDataLength [OUT] 输出的数据长度
*
* @return
* @retval 0 成功
* @retval 非0 失败，返回错误代码
*/
int SDF_InternalDecrypt_ECC(
void* hSessionHandle,
unsigned int uiISKIndex,
ECCCipher* pucEncData,
unsigned char* pucData,
unsigned int* puiDataLength);
/**
* @brief 使用内部ECC公钥对数据进行加密运算
* @param hSessionHandle [IN] 与设备建立的会话句柄
* @param uiIPKIndex [IN] 密码设备内部存储的ECC加密公钥的索引值
* @param pucData [IN] 缓冲区指针，用于存放输入的数据
* @param uiDataLength [IN] 输入的数据长度
* @param pucEncData [OUT] 缓冲区指针，用于存放输出的数据密文
* @return
* @retval 0 成功
* @retval 非0 失败，返回错误代码
*/
int SDF_InternalEncrypt_ECC(
void* hSessionHandle,
unsigned int uiIPKIndex,
unsigned char* pucData,
unsigned int uiDataLength,
ECCCipher* pucEncData);
/**
*对称算法运算类函数
*/
/**
* @brief 使用指定的密钥句柄和IV对数据进行对称加密运算
* @param hSessionHandle [IN] 与设备建立的会话句柄
* @param hKeyHandle [IN] 指定的密钥句柄
* TASS补充：若需要使用加密机内部索引的对称密钥，可使用如下方式
* 如使用1号索引密钥，则int idx = 1; 传入 &idx 即可
* @param uiAlgID [IN] 算法标识，指定的对称加密算法
* @param pucIV [IN/OUT] 缓冲区指针，用于存放输入和返回的IV数据
* @param pucData [IN] 缓冲区指针，用于存放输入的数据明文
* @param uiDataLength [IN] 输入的数据明文长度
* @param pucEncData [OUT] 缓冲区指针，用于存放输出的数据密文
* @param puiEncDataLength [OUT] 输出的数据密文长度
* @return
* @retval 0 成功
* @retval 非0 失败，返回错误代码
* @note 此函数不对数据进行填充处理，输入的数据必须是指定算法分组长度的整数倍
*/
int SDF_Encrypt(
void* hSessionHandle,
void* hKeyHandle,
unsigned int uiAlgID,
unsigned char* pucIV,
unsigned char* pucData,
unsigned int uiDataLength,
unsigned char* pucEncData,
unsigned int* puiEncDataLength);
/**
* @brief 使用指定的密钥句柄和IV对数据进行对称解密运算
* @param hSessionHandle [IN] 与设备建立的会话句柄
* @param hKeyHandle [IN] 指定的密钥句柄
* TASS补充：若需要使用加密机内部索引的对称密钥，可使用如下方式
* 如使用1号索引密钥，则int idx = 1; 传入 &idx 即可
* @param uiAlgID [IN] 算法标识，指定的对称加密算法
* @param pucIV [IN/OUT] 缓冲区指针，用于存放输入和返回的IV数据
* @param pucEncData [IN] 缓冲区指针，用于存放输入的数据密文
* @param puiEncDataLength [IN] 输入的数据密文长度
* @param pucData [OUT] 缓冲区指针，用于存放输出的数据明文
* @param puiDataLength [OUT] 输出的数据明文长度
* @return
* @retval 0 成功
* @retval 非0 失败，返回错误代码
* @note 此函数不对数据进行填充处理，输入的数据必须是指定算法分组长度的整数倍
*/
int SDF_Decrypt(
void* hSessionHandle,
void* hKeyHandle,
unsigned int uiAlgID,
unsigned char* pucIV,
unsigned char* pucEncData,
unsigned int uiEncDataLength,
unsigned char* pucData,
unsigned int* puiDataLength);
/**
* @brief 使用指定的密钥句柄和IV对数据进行对称加密运算
* @param hSessionHandle [IN] 与设备建立的会话句柄
* @param hKeyHandle [IN] 指定的密钥句柄
* TASS补充：若需要使用加密机内部索引的密钥，可使用如下方式
* 如使用1号索引密钥，则int idx = 1; 传入 &idx 即可
* @param uiAlgID [IN] 算法标识，指定的对称加密算法
* @param pucIV [IN/OUT] 缓冲区指针，用于存放输入和返回的IV数据
* @param pucData [IN] 缓冲区指针，用于存放输入的数据明文
* @param uiDataLength [IN] 输入的数据明文长度
* @param pucMAC [OUT] 缓冲区指针，用于存放输出的MAC值
* @param puiMACLength [OUT] 输出的MAC值长度
* @return
* @retval 0 成功
* @retval 非0 失败，返回错误代码
* @note 此函数不对数据进行填充处理，输入的数据必须是指定算法分组长度的整数倍
*/
int SDF_CalculateMAC(
void* hSessionHandle,
void* hKeyHandle,
unsigned int uiAlgID,
unsigned char* pucIV,
unsigned char* pucData,
unsigned int uiDataLength,
unsigned char* pucMAC,
unsigned int* puiMACLength);
/**
*杂凑运算类函数
*/
/**
* @brief 三步式数据杂凑运算第一步
* @param hSessionHandle [IN] 与设备建立的会话句柄
* @param uiAlgID [IN] 指定杂凑算法标识
* @param pucPublicKey [IN] 签名者公钥。当uiAlgID位SGD_SM3时有效
* @param pucID [IN] 签名者的ID值。当uiAlgID位SGD_SM3时有效
* @param uiIDLength [IN] 签名者ID长度。当uiAlgID位SGD_SM3时有效
* @return
* @retval 0 成功
* @retval 非0 失败，返回错误代码
* @note uiIDLength非零且uiAlgID为SGD_SM3时，函数执行SM2的预处理1操作。计算过程见GM/T 0009
*/
int SDF_HashInit(
void* hSessionHandle,
unsigned int uiAlgID,
ECCrefPublicKey* pucPublicKey,
unsigned char* pucID,
unsigned int uiIDLength);
/**
* @brief 三步式数据杂凑运算第二步，对输入的明文进行杂凑运算
* @param hSessionHandle [IN] 与设备建立的会话句柄
* @param pucData [IN] 缓冲区指针，用于存放输入的数据明文
* @param uiDataLength [IN] 输入的数据明文长度
* @return
* @retval 0 成功
* @retval 非0 失败，返回错误代码
*/
int SDF_HashUpdate(
void* hSessionHandle,
unsigned char* pucData,
unsigned int uiDataLength);
/**
* @brief 三步式数据杂凑运算第三步，杂凑运算结束返回杂凑数据并清除中间数据
* @param hSessionHandle [IN] 与设备建立的会话句柄
* @param pucHash [OUT] 缓冲区指针，用于存放输出的杂凑数据
* @param puiHashLength [OUT] 返回的杂凑数据长度
* @return
* @retval 0 成功
* @retval 非0 失败，返回错误代码
*/
int SDF_HashFinal(
void* hSessionHandle,
unsigned char* pucHash,
unsigned int* puiHashLength);
/**
*用户文件操作类函数
*/
/**
* @brief 在密码设备内部创建用于存储用户数据的文件
* @param hSessionHandle [IN] 与设备建立的会话句柄
* @param pucFileName [IN] 缓冲区指针，用于存放输入的文件名，最大长度128字节。
* @param uiNameLen [IN] 文件名长度
* @param uiFileSize [IN] 文件所占存储空间的长度
* @return
* @retval 0 成功
* @retval 非0 失败，返回错误代码
*/
int SDF_CreateFile(
void* hSessionHandle,
unsigned char* pucFileName,
unsigned int uiNameLen,
unsigned int uiFileSize);
/**
* @brief 读取在密码设备内部存储用户数据的文件的内容
* @param hSessionHandle [IN] 与设备建立的会话句柄
* @param pucFileName [IN] 缓冲区指针，用于存放输入的文件名，最大长度128字节
* @param uiNameLen [IN] 文件名长度
* @param uiOffset [IN] 指定读取文件时的偏移值
* @param puiFileLength [IN/OUT] 入参时指定读取文件内容的长度；出参时返回实际读取文件内容的长度
* @param pucBuffer [OUT] 缓冲区指针，用于存放读取的文件数据
* @return
* @retval 0 成功
* @retval 非0 失败，返回错误代码
*/
int SDF_ReadFile(
void* hSessionHandle,
unsigned char* pucFileName,
unsigned int uiNameLen,
unsigned int uiOffset,
unsigned int* puiFileLength,
unsigned char* pucBuffer);
/**
* @brief 向密码设备内部存储用户数据的文件中写入内容
* @param hSessionHandle [IN] 与设备建立的会话句柄
* @param pucFileName [IN] 缓冲区指针，用于存放输入的文件名，最大长度128字节
* @param uiNameLen [IN] 文件名长度
* @param uiOffset [IN] 指定写入文件时的偏移值
* @param uiFileLength [IN] 指定写入文件内容的长度
* @param pucBuffer [IN] 缓冲区指针，用于存放输入的写文件数据
* @return
* @retval 0 成功
* @retval 非0 失败，返回错误代码
*/
int SDF_WriteFile(
void* hSessionHandle,
unsigned char* pucFileName,
unsigned int uiNameLen,
unsigned int uiOffset,
unsigned int uiFileLength,
unsigned char* pucBuffer);
/**
* @brief 在密码设备内部创建用于存储用户数据的文件
* @param hSessionHandle [IN] 与设备建立的会话句柄
* @param pucFileName [IN] 缓冲区指针，用于存放输入的文件名，最大长度128字节
* @param uiNameLen [IN] 文件名长度
* @return
* @retval 0 成功
* @retval 非0 失败，返回错误代码
*/
int SDF_DeleteFile(
void* hSessionHandle,
unsigned char* pucFileName,
unsigned int uiNameLen);
/*
* 以下接口仅作为扩展功能使用
*/
/**
* @brief 通过指定id打开设备，并获取设备句柄
*
* @param id [in] 要打开的设备ID
* @param phDevice [out] 返回设备句柄
*
* @return 成功返回0，失败返回非0
*
*/
int TassGetDeviceHandleByID(unsigned char id[16], void** phDevice);
/**
* @brief 设置配置文件路径
* @param cfgPath [IN] 配置文件路径，不包含配置文件名字
*
* @return
* @retval 0 成功
* @retval 非0 失败，返回错误代码
* @note cfgPath只传路径，不用传配置文件的名字
*/
int TassSetCfgPath(const char* cfgPath);
/**
*函数返回代码定义
*/
#define SDR_OK 0X0 //操作成功
#define SDR_BASE 0X01000000 //错误码基础值
#define SDR_UNKNOWERR SDR_BASE + 0X00000001 //未知错误
#define SDR_NOTSUPPORT SDR_BASE + 0X00000002 //不支持的接口调用
#define SDR_COMMFAIL SDR_BASE + 0X00000003 //与设备通讯失败
#define SDR_HARDFAIL SDR_BASE + 0X00000004 //运算模块无响应
#define SDR_OPENDEVICE SDR_BASE + 0X00000005 //打开设备失败
#define SDR_OPENSESSION SDR_BASE + 0X00000006 //创建会话失败
#define SDR_PARDENY SDR_BASE + 0X00000007 //无私钥使用权限
#define SDR_KEYNOTEXIST SDR_BASE + 0X00000008 //不存在的密钥调用
#define SDR_ALGNOTSUPPORT SDR_BASE + 0X00000009 //不支持的算法调用
#define SDR_ALGMODNOTSUPPORT SDR_BASE + 0X0000000A //不支持的算法模式调用
#define SDR_PKOPERR SDR_BASE + 0X0000000B //公钥运算失败
#define SDR_SKOPERR SDR_BASE + 0X0000000C //私钥运算失败
#define SDR_SIGNERR SDR_BASE + 0X0000000D //签名运算失败
#define SDR_VERIFYERR SDR_BASE + 0X0000000E //验证签名失败
#define SDR_SYMOPERR SDR_BASE + 0X0000000F //对称算法运算失败
#define SDR_STEPERR SDR_BASE + 0X00000010 //多步运算步骤错误
#define SDR_FILESIZEERR SDR_BASE + 0X00000011 //文件长度超出限制
#define SDR_FILENOEXIST SDR_BASE + 0X00000012 //指定的文件不存在
#define SDR_FILEOFSERR SDR_BASE + 0X00000013 //文件起始位置错误
#define SDR_KEYTYPEERR SDR_BASE + 0X00000014 //密钥类型错误
#define SDR_KEYERR SDR_BASE + 0X00000015 //密钥错误
#define SDR_ENCDATAERR SDR_BASE + 0X00000016 //ECC加密数据错误
#define SDR_RANDERR SDR_BASE + 0X00000017 //随机数产生失败
#define SDR_PRKRERR SDR_BASE + 0X00000018 //私钥使用权限获取失败
#define SDR_MACERR SDR_BASE + 0X00000019 //MAC运算失败
#define SDR_FILEEXISTS SDR_BASE + 0X0000001A //指定文件已存在
#define SDR_FILEWERR SDR_BASE + 0X0000001B //文件写入失败
#define SDR_NOBUFFER SDR_BASE + 0X0000001C //存储空间不足
#define SDR_INARGERR SDR_BASE + 0X0000001D //输入参数错误
#define SDR_OUTARGERR SDR_BASE + 0X0000001E //输出参数错误
#define TASSR_OK 0X0 //操作成功
#define TASSR_BASE 0X02000000 //天安错误码基础值
#define TASSR_UNKNOWERR TASSR_BASE + 0X00000001 //未知错误
#define TASSR_BUFFTOOSMALL TASSR_BASE + 0X00000002 //缓冲区不足
#ifdef __cplusplus
}
#endif
plugin/crypto/tasshsm/include/TassAPI4PCIeSM.h deleted 100644 → 0
View file @ 9ed41107
#pragma once
#include "TassType4PCIeSM.h"
#include <time.h>
#ifdef __cplusplus
extern "C" {
#endif
/**
* @brief 搜索设备
*
* @param id [out] 设备句柄集合
* @param idLen [in|out] 输入时，标识id缓冲区大小
* 输出时，标识输出id长度，通过 *idLen / TA_DEVICE_ID_SIZE 获取设备数量
*
* @return 成功返回0，失败返回非0
*
*/
int TassScanDevice(unsigned char* id, unsigned int* idLen);
/**
* @brief 打开设备
*
* @param id [in] 要打开的设备ID
* @param phDevice [out] 返回设备句柄
*
* @return 成功返回0，失败返回非0
*
*/
int TassOpenDevice(unsigned char id[TA_DEVICE_ID_SIZE], void** phDevice);
/**
* @brief 关闭设备
*
* @param pDevice [in] 已打开的设备句柄
*
* @return 成功返回0，失败返回非0
*
*/
int TassCloseDevice(void* hDevice);
/**
* @brief 打开会话
*
* @param pDevice [in] 已打开的设备句柄
* @param hSess [out] 打开的会话句柄
*
* @return 成功返回0，失败返回非0
*
*/
int TassOpenSession(void* hDevice, void** phSess);
/**
* @brief 关闭会话
*
* @param hSess [in] 已打开的会话句柄
*
* @return 成功返回0，失败返回非0
*
*/
int TassCloseSession(void* hSess);
/**
* @brief 设置超时时间
*
* @param timout [in] 超时时间，毫秒
*
* @return 成功返回0，失败返回非0
*
*/
int TassSetTimeout(void* hDevice, int timout);
/**
* @brief 获取超时时间
*
* @param timout [out] 超时时间，毫秒
*
* @return 成功返回0，失败返回非0
*
*/
int TassGetTimeout(void* hDevice, int* timout);
/**
* @brief 获取错误码描述信息
*
* @param err [in] 错误码
*
* @return 错误码描述信息
*
*/
const char* TassGetErrorDesc(int err);
/*
* 设备管理类指令
*/
/**
* @brief 获取密码卡信息
*
* @param hSess [in] 会话句柄
* @param devInfo [out] 设备信息
*
* @return 成功返回0，失败返回非0
*
*/
int TassGetDeviceInfo(void* hSess, TassDevInfo* devInfo);
/**
* @brief 设备自检
*
* @param hSess [in] 会话句柄
* @param res [in] 自检结果
* 1B：SM4 IP结果
* 1B：SM2 IP结果
* 1B：密管芯片结果
* 1B：WNG8芯片结果
*
* @return
* @retval 成功返回0，失败返回非0
*
*/
int TassDeviceSelfCheck(void* hSess,
unsigned char res[4]);
/**
* @brief 恢复出厂设置
*
* @param hSess [in] 会话句柄
* @param cb [in] 管理平台私钥签名回调函数
*
* @return
* @retval 成功返回0，失败返回非0
*
*/
int TassRestoreFactory(void* hSess,
const TassSignCb cb);
/**
* @brief 设置设备基础信息
*
* @param hSess [in] 会话句柄
* @param devSn [in] 设备序列号
* @param selfCheckCycle [in] 自检周期
* @param cb [in] 管理平台私钥签名回调函数
*
* @return
* @retval 成功返回0，失败返回非0
*
*/
int TassSetDeviceBaseInfo(void* hSess,
const unsigned char devSn[4],
unsigned int selfCheckCycle,
const TassSignCb cb);
/*
* 设备密钥管理类指令
*/
/**
* @brief 生成设备密钥
*
* @param hSess [in] 会话句柄
* @param type [in] 生成的设备密钥类型
* TA_DEV_SIGN/TA_DEV_ENC/TA_DEV_KEK有效
* @param keyInfo [in] 密钥信息
* @param bootAuth [in] 是否开机认证，0--否，非0--是
* type=TA_DEV_KEK时有效
* @param kekcv [out] KEK校验值，为NULL时不输出
* type=TA_DEV_KEK时有效
*
* @retval 成功返回0，失败返回非0
*
*/
int TassGenDeviceKey(void* hSess,
TassDevKeyType type,
const unsigned char keyInfo[4],
TassBool bootAuth,
unsigned char kekcv[16]);
/**
* @brief 获取设备公钥
*
* @param hSess [in] 会话句柄
* @param type [in] 获取的设备密钥类型
* TA_DEV_KEY_PLATFORM/TA_DEV_KEY_SIGN/TA_DEV_KEY_ENC有效
* @param keyInfo [out] 密钥信息，为NULL时不输出
* @param pk [out] 公钥
*
* @retval 成功返回0，失败返回非0
*
*/
int TassGetDevicePublicKey(void* hSess,
TassDevKeyType type,
unsigned char keyInfo[4],
unsigned char pk[64]);
/**
* @brief 设置平台公钥
*
* @param hSess [in] 会话句柄
* @param keyInfo [in] 密钥信息
* @param pk [in] 公钥
*
* @retval 成功返回0，失败返回非0
*
*/
int TassSetPlatformPublicKey(void* hSess,
const unsigned char keyInfo[4],
const unsigned char pk[64]);
/**
* @brief 导入管理员公钥
*
* @param hSess [in] 会话句柄
* @param keyInfo [in] 密钥信息
* @param pk [in] 导入的公钥
* @param cb [in] （管理平台私钥）签名回调
*
* @retval 成功返回0，失败返回非0
*
*/
int TassImportAdminPublicKey(void* hSess,
const unsigned char keyInfo[4],
const unsigned char pk[64],
const TassSignCb cb);
/**
* @brief 增加管理员公钥
*
* @param hSess [in] 会话句柄
* @param keyInfo [in] 密钥信息
* @param pk [in] 增加的公钥
* @param adminPk [in] （已经存在的）管理员公钥
* @param cb [in] （adminPk对应私钥）签名回调
*
* @retval 成功返回0，失败返回非0
*
*/
int TassAddAdminPublicKey(void* hSess,
const unsigned char keyInfo[4],
const unsigned char pk[64],
const unsigned char adminPk[64],
const TassSignCb cb);
/**
* @brief 删除管理员公钥
*
* @param hSess [in] 会话句柄
* @param keyInfo [in] 密钥信息
* @param pk [in] 删除的公钥
* @param adminPk [in] （已经存在的）管理员公钥，可以与pubKey相同
* @param cb [in] （adminPk对应私钥）签名回调
*
* @retval 成功返回0，失败返回非0
*
*/
int TassDeleteAdminPublicKey(void* hSess,
const unsigned char keyInfo[4],
const unsigned char pk[64],
const unsigned char adminPk[64],
const TassSignCb cb);
/**
* @brief 导出设备加密密钥对
*
* @param hSess [in] 会话句柄
* @param protectPk [in] 保护公钥，一般为另一个密码卡的签名公钥
* @param adminPk [in] 管理员公钥
* @param adminCb [in] （adminPk对应私钥）签名回调
* @param platformCb [in] （平台公钥对应私钥）签名回调
* @param keyInfo [out] 密钥信息，为NULL时不输出
* @param devEncPk [out] 设备加密公钥，为NULL时不输出
* @param devEncSkEnvelopByProtectPk [out] 设备加密私钥信封，通过protectPk加密
*
* @retval 成功返回0，失败返回非0
*
*/
int TassExportDeviceEncKeyPair(void* hSess,
const unsigned char protectPk[64],
const unsigned char adminPk[64], const TassSignCb adminCb,
const TassSignCb platformCb,
unsigned char keyInfo[4],
unsigned char devEncPk[64],
unsigned char devEncSkEnvelopByProtectPk[144]);
/**
* @brief 导出设备KEK
*
* @param hSess [in] 会话句柄
* @param protectPk [in] 保护公钥，一般为另一个密码卡的加密公钥
* @param adminPk [in] 管理员公钥
* @param adminCb [in] （adminPk对应私钥）签名回调
* @param platformCb [in] （平台公钥对应私钥）签名回调
* @param keyInfo [out] 密钥信息，为NULL时不输出
* @param kekCipherByProtectPk [out] 设备KEK密文，通过protectPk加密
*
* @retval 成功返回0，失败返回非0
*
*/
int TassExportDeviceKEK(void* hSess,
const unsigned char protectPk[64],
const unsigned char adminPk[64], const TassSignCb adminCb,
const TassSignCb platformCb,
unsigned char keyInfo[4],
unsigned char kekCipherByProtectPk[112]);
/**
* @brief 导入设备加密密钥对
*
* @param hSess [in] 会话句柄
* @param keyInfo [in] 密钥信息
* @param pk [in] 公钥
* @param skEnvelopByDevSignPk [in] 设备签名公钥加密的私钥私钥信封
* @param cb [in] （平台公钥对应私钥）签名回调
*
* @retval 成功返回0，失败返回非0
*
*/
int TassImportDeviceEncKeyPair(void* hSess,
const unsigned char keyInfo[4],
const unsigned char pk[64],
const unsigned char skEnvelopByDevSignPk[144],
const TassSignCb cb);
/**
* @brief 导入设备KEK
*
* @param hSess [in] 会话句柄
* @param bootAuth [in] 是否开机认证，0--否，非0--是
* @param keyInfo [in] 密钥信息
* @param kekCipherByDevEncPk [in] 设备加密密钥对加密的KEK密文
* @param cb [in] （平台公钥对应私钥）签名回调
*
* @retval 成功返回0，失败返回非0
*
*/
int TassImportDeviceKEK(void* hSess,
TassBool bootAuth,
const unsigned char keyInfo[4],
const unsigned char kekCipherByDevEncPk[112],
const TassSignCb cb);
/**
* @brief 开机认证
*
* @param hSess [in] 会话句柄
* @param cb [in] （平台公钥对应私钥）签名回调
*
* @retval 成功返回0，失败返回非0
*
*/
int TassBootAuth(void* hSess, const TassSignCb cb);
/**
* @brief 开机认证
*
* @param hSess [in] 会话句柄
* @param state [in] 要设置的工作状态
* TA_DEV_STATE_WORK/TA_DEV_STATE_MNG有效
* @param cb [in] （平台公钥对应私钥）签名回调
*
* @retval 成功返回0，失败返回非0
*
*/
int TassSetDeviceState(void* hSess, TassDevState state, const TassSignCb cb);
/*
* 应用密钥管理类指令
*/
/*
3.3.1
后续废弃，仅用于测试。
仅在管理状态下可用
*/
int TassAuthSM2PublicKey(void* hSess,
const unsigned char pk[64],
unsigned char authCode[4]);
/*
3.3.1
* @brief 扩展认证保护密钥
*
* @param hSess [in] 会话句柄
* @param alg [in] 保护密钥类型, 0–SM4，2-SM2，4–RSA
* @param protectKey [in] 保护密钥，当保护密钥类型是 0 时，保护密钥是16字节的 SM4 密钥；
* 当保护密钥类型是 2 时，保护密钥是 64字节 SM2 公钥；
* 当保护密钥类型是 4 时，保护密钥是RSA2048公钥，此时是4字节的公钥长度+公钥内容
* @param protectKeyLen [in] 保护密钥长度
* @param cb [in] （平台公钥对应私钥）签名回调
* @param authCode [out] 认证码
*
* @retval 成功返回0，失败返回非0
*
*/
int TassAuthPortectKey(void* hSess,
TassAlg alg,
const unsigned char* protectKey, unsigned int protectKeyLen,
const TassSignCb cb,
unsigned char authCode[4]);
/*
3.3.3
同时适用于19150
*/
int TassGenSM2KeyPair(void* hSess,
unsigned char skCipherByKek[32],
unsigned char pk[64]);
/*
3.3.4
同时适用于19150
密钥信息校验值，为NULL时不输出
*/
int TassGenSM4Key(void* hSess,
unsigned char keyCipherByKek[16],
unsigned char kcv[16]);
/*
3.3.7
同时适用于19150
密钥信息校验值，为NULL时不输出
*/
int TassGen_ExportSM4KeyBySM4Key(void* hSess,
const unsigned char protectKeyCipherByKek[16],
unsigned char keyCipherByProtectKey[16],
unsigned char keyCipherByKek[16],
unsigned char kcv[16]);
/*
3.3.8
同时适用于19150
*/
int TassExportSM2PrivateKeyBySM2PublicKey(void* hSess,
const unsigned char protectPk[64],
const unsigned char authCode[4],
const unsigned char skCipherByKek[32],
unsigned char skEnvelopByProtectPk[144]);
/*
3.3.9
同时适用于19150
*/
int TassImportSM2PrivateKeyBySM2PrivateKey(void* hSess,
const unsigned char protectSkCipherByKek[32],
const unsigned char skEnvelopByProtectPk[144],
unsigned char skCipherByKek[32]);
/*
3.3.12
同时适用于19150
密钥信息校验值，为NULL时不输出
*/
int TassExportSM4KeyBySM2PublicKey(void* hSess,
const unsigned char protectPk[64],
const unsigned char authCode[4],
const unsigned char keyCipherByKek[16],
unsigned char keyCipherByProtectPk[112],
unsigned char kcv[16]);
/*
3.3.13
同时适用于19150
*/
int TassImportSM4KeyBySM2PrivateKey(void* hSess,
const unsigned char protectSkCipherByKek[32],
const unsigned char keyCipherByProtectPk[112],
const unsigned char kcv[16],
unsigned char keyCipherByKek[16]);
/*
3.3.16
同时适用于19150
*/
int TassImportSM4KeyBySM4Key(void* hSess,
const unsigned char protectKeyCipherByKek[16],
const unsigned char keyCipherByProtectKey[16],
const unsigned char kcv[16],
unsigned char keyCipherByKek[16]);
/*
3.3.17
密钥信息校验值，为NULL时不输出
仅导出SM2和SM4密钥
*/
int TassExportKeyBySM4Key(void* hSess,
const unsigned char protectKeyCipherByKek[16],
const unsigned char authCode[4],
TassAlg alg,
const unsigned char* keyCipherByKek, unsigned int keyCipherByKekLen,
unsigned char* keyCipherByProtectKey, unsigned int* keyCipherByProtectKeyLen,
unsigned char kcv[16]);
/*
3.3.4
*/
int TassGenSymmKey(void* hSess,
TassAlg keyAlg,
unsigned int keyBits, //密钥类型为 9 时，支持模长是128、256、384、512bit,其他类型仅支持 128(0x00000080)
unsigned char* keyCipherByKek, unsigned int* keyCipherByKekLen,
unsigned char kcv[16]);
/*
3.3.5
* @brief 生成非对称密钥
*
* @param hSess [in] 会话句柄
* @param keyAlg [in] 密钥类型, 2-SM2, 3–SECP_256R1, 4–RSA，8-SECP_256K1
* @param keyBits [in] 模长, 密钥类型是2或3 时都只支持256，密钥类型是4时只支持 2048
* @param rsaE [in] 公钥指数
* @param skCipherByKek [out] 私钥密文
* @param skCipherByKekLen [out] 私钥密文长度
* @param pk [out] 公钥
* @param pkLen [out] 公钥长度
*
* @retval 成功返回0，失败返回非0
*
*/
int TassGenAsymKeyPair(void* hSess,
TassAlg keyAlg,
unsigned int keyBits,
TassRSA_E rsaE,
unsigned char* skCipherByKek, unsigned int* skCipherByKekLen,
unsigned char* pk, unsigned int* pkLen);
/*
3.3.9
* @brief 将非对称私钥转加密（本地保护密钥 KEK 加密转为SM2加密）
*
* @param hSess [in] 会话句柄
* @param protectPk [in] 经认证的SM2公钥
* @param authCode [in] 认证码
* @param keyAlg [in] 密钥类型，2-SM2、3–ECC（SECP 256r1）、4–RSA、8–ECC（SECP 256k1）
* @param keyBits [in] 模长
* @param skCipherByKek [in] 私钥密文
* @param skCipherByKekLen [in] 私钥密文长度
* @param symmKeyCipher [out] 随机对称密钥密文
* @param symmKeyCipherLen [out] 随机对称密钥密文长度
* @param skEnvelopByProtectPk [out] 业务密钥私钥密文
* @param skEnvelopByProtectPkLen [out] 业务密钥私钥密文长度
*
* @retval 成功返回0，失败返回非0
*
*/
int TassExportAsymPrivateKeyBySM2PublicKey(void* hSess,
const unsigned char protectPk[64],
const unsigned char authCode[4],
TassAlg keyAlg,
unsigned int keyBits,
const unsigned char* skCipherByKek, unsigned int skCipherByKekLen,
unsigned char* symmKeyCipher, unsigned int *symmKeyCipherLen,
unsigned char* skEnvelopByProtectPk, unsigned int* skEnvelopByProtectPkLen);
/*
3.3.11
* @brief 将非对称私钥转加密（SM2加密转为本地保护密钥KEK加密）
*
* @param hSess [in] 会话句柄
* @param protectSkCipherByKek [in] 解密私钥密文
* @param keyAlg [in] 密钥类型, 2-SM2, 3–ECC 256r1, 4–RSA，8-ECC 256k1
* @param keyBits [in] 模长, 密钥类型是2或3 时都只支持256，密钥类型是4时只支持 2048
* @param symmKeyCipher [in] 随机对称密钥密文
* @param symmKeyCipherLen [in] 随机对称密钥密文长度
* @param skEnvelopByProtectPk [in] 业务密钥私钥密文，（数字信封）
* @param skEnvelopByProtectPkLen [in] 业务密钥私钥密文长度
* @param skCipherByKek [out] KEK加密的业务密钥私钥密文
* @param skCipherByKekLen [out] KEK加密的业务密钥私钥密文长度
*
* @retval 成功返回0，失败返回非0
*
*/
int TassImportAsymPrivateKeyBySM2PrivateKey(void* hSess,
const unsigned char protectSkCipherByKek[32],
TassAlg keyAlg,
unsigned int keyBits,
const unsigned char* symmKeyCipher, unsigned int symmKeyCipherLen,
const unsigned char* skEnvelopByProtectPk, unsigned int skEnvelopByProtectPkLen,
unsigned char* skCipherByKek, unsigned int* skCipherByKekLen);
/*
3.3.14
*/
int TassExportSymmKey(void* hSess,
TassAlg protectKeyAlg,
unsigned int protectKeyBits,
const unsigned char* protectKey, unsigned int protectKeyLen,
const unsigned char authCode[4],
TassAlg keyAlg,
unsigned int keyBits,
const unsigned char* keyCipherByKek, unsigned int keyCipherByKekLen,
unsigned char* keyCipherByProtectKey, unsigned int* keyCipherByProtectKeyLen,
unsigned char kcv[16]);
/*
3.3.15
* @brief 将对称密钥转加密（外部密钥加密转为本地保护密钥 KEK 加密）
*
* @param hSess [in] 会话句柄
* @param protectKeyAlg [in] 外部保护密钥类型，0-SM4，2-SM2, 4–RSA
* @param protectKeyBits [in] 外部保护密钥模长
* @param protectKey [in] 外部保护密钥
* @param protectKeyLen [in] 外部保护密钥长度
* @param keyAlg [in] 对称密钥类型，0-SM4，1-SM1，5--AES，6-DES，7-SM7
* @param keyBits [in] 对称密钥模长，当前仅支持 128
* @param keyCipherByProtectKey [in] 业务密钥密文（即被公钥加密的对称密钥密文）
* @param keyCipherByProtectKeyLen [in] 业务密钥密文长度
* @param kcv [in] 密钥校验值
* @param keyCipherByKek [out] 外部密钥密文（即公钥对应的私钥或者 SM4 密钥密文）
* @param keyCipherByKekLen [out] 外部密钥密文长度
*
* @retval 成功返回0，失败返回非0
*/
int TassImportSymmKey(void* hSess,
TassAlg protectKeyAlg,
unsigned int protectKeyBits,
const unsigned char* protectKey, unsigned int protectKeyLen,
TassAlg keyAlg,
unsigned int keyBits,
const unsigned char* keyCipherByProtectKey, unsigned int keyCipherByProtectKeyLen,
const unsigned char kcv[16],
unsigned char* keyCipherByKek, unsigned int* keyCipherByKekLen);
/*
* 密码运算类指令
*/
int TassGenRandom(void* hSess,
unsigned int randomLen,
unsigned char* random);
/*
3.4.2 + 4.2.1
同时适用于19150
*/
int TassSM2PrivateKeySign(void* hSess,
unsigned int index,
const unsigned char skCipherByKek[32],
const unsigned char hash[32],
unsigned char sig[64]);
/*
3.4.3 + 4.2.2
同时适用于19150
*/
int TassSM2PublicKeyVerify(void* hSess,
unsigned int index,
const unsigned char pk[64],
const unsigned char hash[32],
const unsigned char sig[64]);
/*
3.4.4 + 4.2.3
同时适用于19150
*/
int TassSM2PublicKeyEncrypt(void* hSess,
unsigned int index,
const unsigned char pk[64],
const unsigned char* plain, unsigned int plainLen,
unsigned char* cipher, unsigned int* cipherLen);
/*
3.4.5 + 4.2.4
同时适用于19150
*/
int TassSM2PrivateKeyDecrypt(void* hSess,
unsigned int index,
const unsigned char skCipherByKek[32],
const unsigned char* cipher, unsigned int cipherLen,
unsigned char* plain, unsigned int* plainLen);
/*
3.4.6 + 4.2.5
同时适用于19150
*/
int TassSM2KeyExchange(void* hSess,
TassBool sponsor,
unsigned int selfIndex,
const unsigned char selfSkCipherByKek[32],
const unsigned char selfPk[64],
const unsigned char selfTmpSkCipherByKek[32],
const unsigned char selfTmpPk[64],
const unsigned char* selfId, unsigned int selfIdLen,
const unsigned char peerPk[64],
const unsigned char peerTmpPk[64],
const unsigned char* peerId, unsigned int peerIdLen,
unsigned int keyBytes,
TassBool genPlainKey,
unsigned char* key);
/*
* @brief ECC私钥签名
*
* @param hSess [in] 会话句柄
* @param alg [in] ECC密钥类型
* @param index [in] 索引
* @param keyBits [in] 模长，ECC_256R1和ECC_256K1均为256，索引为0时有效
* @param skCipherByKek [in] 签名私钥，索引为0时有效
* @param skCipherByKekLen [in] 签名私钥长度，索引为0时有效
* @param hash [in] 哈希值
* @param hashLen [in] 哈希值长度
* @param sig [out] 签名值
* @param sigLen [in/out] 签名值长度
*
* @retval 成功返回0，失败返回非0
*/
int TassECCPrivateKeySign(void* hSess,
TassAlg alg,
unsigned int index,
unsigned int keyBits,
const unsigned char* skCipherByKek, unsigned int skCipherByKekLen,
const unsigned char* hash, unsigned int hashLen,
unsigned char* sig, unsigned int* sigLen);
/*
* @brief ECC私钥签名（为复杂美项目特殊需求定制）
*
* @param hSess [in] 会话句柄
* @param alg [in] ECC密钥类型
* @param index [in] 索引
* @param keyBits [in] 模长，ECC_256R1和ECC_256K1均为256，索引为0时有效
* @param skCipherByKek [in] 签名私钥，索引为0时有效
* @param skCipherByKekLen [in] 签名私钥长度，索引为0时有效
* @param hash [in] 哈希值
* @param hashLen [in] 哈希值长度
* @param sig [out] 签名值
* @param sigLen [in/out] 签名值长度
*
* @retval 成功返回0，失败返回非0
*/
int TassECCPrivateKeySign_Eth(void* hSess,
TassAlg alg,
unsigned int index,
unsigned int keyBits,
const unsigned char* skCipherByKek, unsigned int skCipherByKekLen,
const unsigned char* hash, unsigned int hashLen,
unsigned char* sig, unsigned int* sigLen);
/*
* @brief ECC公钥验签
*
* @param hSess [in] 会话句柄
* @param alg [in] ECC密钥类型
* @param index [in] 索引
* @param keyBits [in] 模长，ECC_256R1和ECC_256K1均为256，索引为0时有效
* @param pk [in] 验签公钥，索引为0时有效
* @param pkLen [in] 验签公钥长度，索引为0时有效
* @param hash [in] 哈希值
* @param hashLen [in] 哈希值长度
* @param sig [out] 签名值
* @param sigLen [in/out]签名值长度
*
* @retval 成功返回0，失败返回非0
*/
int TassECCPublicKeyVerify(void* hSess,
TassAlg alg,
unsigned int index,
unsigned int keyBits,
const unsigned char* pk, unsigned int pkLen,
const unsigned char* hash, unsigned int hashLen,
const unsigned char* sig, unsigned int sigLen);
/*
3.4.9
*/
int TassECCKeyAgreement(void* hSess,
TassAlg alg,
unsigned int keyBits,
const unsigned char* selfSkCipherByKek, unsigned int selfSkCipherByKekLen,
const unsigned char* peerPk, unsigned int peerPkLen,
TassBool genPlainKey,
unsigned char* key, unsigned int* keyLen);
/*
3.4.10 + 4.2.9
*/
int TassRSAPrivateKeyOperate(void* hSess,
unsigned int index,
unsigned int keyBits,
const unsigned char* skCipherByKek, unsigned int skCipherByKekLen,
const unsigned char* inData, unsigned int inDataLen,
unsigned char* outData);
/*
3.4.11 + 4.2.10
*/
int TassRSAPublicKeyOperate(void* hSess,
unsigned int index,
unsigned int keyBits,
const unsigned char* pk, unsigned int pkLen,
const unsigned char* inData, unsigned int inDataLen,
unsigned char* outData);
/*
3.4.12 + 4.2.6
同时适用于19150
*/
int TassSM4KeyOperate(void* hSess,
TassSymmOp op,
unsigned int index,
const unsigned char keyCipherByKek[16],
unsigned char* iv,
const unsigned char* inData, unsigned int dataLen,
unsigned char* outData);
/*
3.4.13 + 4.2.11
*/
int TassSymmKeyOperate(void* hSess,
TassAlg alg,
unsigned int keyBits,
TassSymmOp op,
unsigned int index,
const unsigned char* keyCipherByKek, unsigned int keyCipherByKekLen,
unsigned char* iv,
const unsigned char* inData, unsigned int inDataLen,
unsigned char* outData, unsigned int* outDataLen);
int TassSM3Single(void* hSess,
const unsigned char pk[64],
const unsigned char* id, unsigned int idLen,
const unsigned char* data, unsigned int dataLen,
unsigned char hash[32]);
int TassSM3Init(void* hSess,
unsigned int uiAlgID,
const unsigned char pk[64],
const unsigned char* id, unsigned int idLen,
unsigned char ctx[112]);
int TassSM3Update(void* hSess,
const unsigned char* data, unsigned int dataLen,
unsigned char ctx[112]);
int TassSM3Final(void* hSess,
const unsigned char ctx[112],
unsigned char hash[32]);
/*
* PKI扩展命令
*/
/*
* 密钥管理命令
*/
/*
4.1.1
同时适用19150
*/
int TassGetIndexInfo(void* hSess,
TassAlg alg,
unsigned char* info, unsigned int* infoLen);
/*
4.1.2
同时适用19150
*/
int TassSetLabel(void* hSess,
TassAlg alg,
unsigned int index,
const unsigned char* label, unsigned int labelLen);
/*
4.1.3
同时适用19150
*/
int TassGetLabel(void* hSess,
TassAlg alg,
unsigned int index,
unsigned char* label, unsigned int* labelLen);
/*
4.1.4
同时适用19150
*/
int TassGetIndex(void* hSess,
TassAlg alg,
const unsigned char* label, unsigned int labelLen,
unsigned int* index);
/*
4.1.5
同时适用19150
*/
/*
* @brief 依据索引设置密钥属性
*
* @param hSess [in] 会话句柄
* @param alg [in] 密钥类型
* @param index [in] 密钥索引
* @param sk [in] 公私钥标识，0–私钥，1–公钥
* @param attr [in] 密钥属性
* @param attrLen [in] 密钥属性长度
*
* @retval 成功返回0，失败返回非0
*
*/
int TassSetAttr(void* hSess,
TassAlg alg,
unsigned int index,
TassBool sk,
const unsigned char* attr, unsigned int attrLen);
/*
4.1.6
同时适用19150
*/
/*
* @brief 依据索引获取密钥属性
*
* @param hSess [in] 会话句柄
* @param alg [in] 密钥类型
* @param index [in] 密钥索引
* @param sk [in] 公私钥标识，0–私钥，1–公钥
* @param attr [out] 密钥属性
* @param attrLen [out] 密钥属性长度
*
* @retval 成功返回0，失败返回非0
*
*/
int TassGetAttr(void* hSess,
TassAlg alg,
unsigned int index,
TassBool sk,
unsigned char* attr, unsigned int* attrLen);
/*
4.1.10
同时适用19150
*/
int TassStoreSM2KeyPair(void* hSess,
unsigned int index,
const unsigned char* label, unsigned int labelLen,
TassAsymKeyUsage usage,
const unsigned char skCipherByKek[32],
const unsigned char pk[64]);
/**
4.1.11
* @brief 导入非对称密钥到密码卡
*
* @param hSess [in] 会话句柄
* @param alg [in] 密钥类型
* @param index [in] 密钥索引，0-64，当密钥类型是 RSA 是为 0-4
* @param label [in] 密钥标签
* @param labelLen [in] 密钥标签长度
* @param usage [in] 0-签名密钥，1-加密密钥，2-密钥协商密钥
* @param skCipherByKek [in] 私钥密文
* @param skCipherByKekLen [in] 私钥密文长度
* @param pk [in] 公钥
* @param pkLen [in] 公钥长度
*
* @retval 成功返回0，失败返回非0
*
*/
int TassStoreAsymKeyPair(void* hSess,
TassAlg alg,
unsigned int index,
const unsigned char* label, unsigned int labelLen,
TassAsymKeyUsage usage,
const unsigned char* skCipherByKek, unsigned int skCipherByKekLen,
const unsigned char* pk, unsigned int pkLen);
/*
4.1.12
同时适用19150
*/
int TassStoreSM4Key(void* hSess,
unsigned int index,
const unsigned char* label, unsigned int labelLen,
const unsigned char keyCipherByKek[16],
const unsigned char kcv[16]);
/*
4.1.13
*/
int TassStoreSymmKey(void* hSess,
TassAlg alg,
unsigned int index,
const unsigned char* label, unsigned int labelLen,
const unsigned char* keyCipherByKek, unsigned int keyCipherByKekLen,
const unsigned char kcv[16]);
/*
4.1.14
同时适用19150
*/
int TassDestroyKey(void* hSess,
TassAlg alg,
TassAsymKeyUsage usage,
unsigned int index);
/*
4.1.8
同时适用19150
*/
int TassGetSM2PublicKey(void* hSess,
unsigned int index,
TassAsymKeyUsage usage,
unsigned char pk[64]);
int TassGetAsymPublicKey(void* hSess,
TassAlg alg,
unsigned int index,
TassAsymKeyUsage usage,
unsigned char* pk, unsigned int* pkLen);
/*
4.1.14
同时适用19150
*/
/*
* @brief 依据索引设置密钥属性
*
* @param hSess [in] 会话句柄
* @param alg [in] 密钥类型
* @param index [in] 密钥索引
* @param usage [in] 密钥用途，0–签名密钥，1–加密密钥, 2-密钥协商密钥
* @param sk_keyCipherByKek [out] 私钥
* @param sk_keyCipherByKekLen [in/out]私钥长度
* @param sk_keyCipherByKek [out] 公钥
* @param sk_keyCipherByKekLen [in/out]公钥长度
*
* @retval 成功返回0，失败返回非0
*
*/
int TassGetKey(void* hSess,
TassAlg alg,
unsigned int index,
TassAsymKeyUsage usage,
unsigned char* sk_keyCipherByKek, unsigned int* sk_keyCipherByKekLen,
unsigned char* pk_kcv, unsigned int* pk_kcvLen);
/*
4.1.16 + 4.1.17
2K FLASH 操作同时适用19150
*/
int TassFlashOperate(void* hSess,
TassFlashFlag flag,
TassFlashOp op,
unsigned int offset,
unsigned int dataLen,
unsigned char* data);
/**
4.2.10
* @brief ECC 密钥协商
*
* @param hSess [in] 会话句柄
* @param alg [in] 密钥类型, 3–ECC_SECP_256R1, 8-ECC_SECP_256K1
* @param index [in] 密钥索引，1-64
* @param pk [in] 对方公钥
* @param pkLen [in] 对方公钥长度
* @param agreementData [out] 协商结果
* @param agreementDataLen [out] 协商结果长度
*
* @retval 成功返回0，失败返回非0
*
*/
int TassGenerateAgreementDataWithECC(void* hSess,
TassAlg alg,
unsigned int index,
unsigned char* pk, unsigned int pkLen,
unsigned char* agreementData, unsigned int* agreementDataLen);
/*
* HMAC计算
*/
/**
3.4.20、4.2.14
* @brief HMAC单包计算
*
* @param hSess [in] 会话句柄
* @param index [in] 密钥索引
* @param key [in] 密钥密文，索引为0时有效
* @param keyLen [in] 密钥密文长度，16/32/48/64，最大 64 字节，索引为0时有效
* @param data [in] 数据
* @param dataLen [in] 数据长度，最大不超过2000字节
* @param hmac [out] HMAC 结果
* @param hmacLen [out] HMAC 结果长度
*
* @retval 成功返回0，失败返回非0
*
*/
int TassHmacSingle(void* hSess,
unsigned int index,
unsigned char* key, unsigned int keyLen,
unsigned char* data, unsigned int dataLen,
unsigned char* hmac, unsigned int* hmacLen);
/**
3.4.21、4.2.15
* @brief HMAC多包计算init
*
* @param hSess [in] 会话句柄
* @param index [in] 密钥索引，仅支持HMAC密钥
* @param key [in] 密钥密文，索引为0时有效，仅支持HMAC密钥
* @param keyLen [in] 密钥密文长度，16/32/48/64，最大 64 字节，索引为0时有效，仅支持HMAC密钥
*
* @retval 成功返回0，失败返回非0
*
*/
int TassHmacInit(void* hSess,
unsigned int index,
unsigned char* key, unsigned int keyLen);
/**
3.4.22
* @brief HMAC多包计算update
*
* @param hSess [in] 会话句柄
* @param data [in] 数据
* @param dataLen [in] 数据长度，长度只能是64 字节的倍数
*
* @retval 成功返回0，失败返回非0
*
*/
int TassHmacUpdate(void* hSess, unsigned char* data, unsigned int dataLen);
/**
3.4.23、4.2.16
* @brief HMAC多包计算final
*
* @param hSess [in] 会话句柄
* @param hmac [out] HMAC 结果
* @param hmacLen [out] HMAC 结果长度
*
* @retval 成功返回0，失败返回非0
*
*/
int TassHmacFinal(void* hSess, unsigned char* hmac, unsigned int* hmacLen);
/**
* @brief 获取密码设备内部存储的指定索引私钥的使用权
* @param hSessionHandle [IN] 与设备建立的会话句柄
* @param uiKeyIndex [IN] 密码设备存储私钥的索引值
* @param uiAlgID [IN] 密钥类型
* @param pucPassword [IN] 使用私钥权限的识别码，默认为a1234567
* @param uiPwdLength [IN] 私钥访问控制码长度
* @return
* @retval 0 成功
* @retval 非0 失败，返回错误代码
* @note 本标准涉及密码设备存储的密钥对索引值的起始索引值为1，最大为n，
* 密码设备的实际存储容量决定n值
*/
int TassGetPrivateKeyAccessRight(void* hSessionHandle,
unsigned int uiKeyIndex,
TassAlg uiAlgID,
unsigned char* pucPassword,
unsigned int uiPwdLength);
#ifdef __cplusplus
}
#endif
plugin/crypto/tasshsm/include/TassCtlAPI4PCIeSM.h deleted 100644 → 0
View file @ 9ed41107
#pragma once
#include "TassType4PCIeSM.h"
#ifdef __cplusplus
extern "C" {
#endif
#define TASS_DEV_ADMIN_NAME "admin" //设备管理员名称
#define TASS_DEV_ID_STR_SIZE 32 //设备ID长度
#define TASS_NAME_SIZE_MAX 8 //管理员名称最大长度
#define TASS_UKEY_SN_SIZE 5 //UKey序列号长度
#define TASS_KEY_LABEL_SIZE_MAX 128 //密钥标签最大长度
#define TASS_KEY_ATTR_SIZE_MAX 1024 //密钥属性最大长度
#define TASS_SK_SIZE_MAX 4096 //私钥最大长度
#define TASS_PK_SIZE_MAX 1024 //公钥最大长度
#define TASS_KEY_SIZE_MAX 64 //对称密钥最大长度
#define TASS_KCV_SIZE 16 //密钥校验值长度
#define TASS_DEV_ADMIN_CNT_MAX 1 //设备管理员数量
#define TASS_KEY_ADMIN_CNT_MAX 4 //密钥管理员最大数量
#define TASS_ECC_INDEX_MAX 64
#define TASS_SYMM_INDEX_MAX 64
typedef enum {
TA_DEV_ADMIN = 0, //设备管理员
TA_KEY_ADMIN = 1, //密钥管理员
}TassAdminType;
typedef struct {
TassAdminType type;
char name[TASS_NAME_SIZE_MAX + 1]; //名称
char ukeySn[TASS_UKEY_SN_SIZE + 1]; //UKey序列号，制作UKey后有效
}TassAdminInfo;
typedef struct {
TassAlg alg; //算法
int index; //索引
char label[TASS_KEY_LABEL_SIZE_MAX + 1]; //标签
unsigned char sk_key[TASS_SK_SIZE_MAX]; //私钥/对称密钥密文
unsigned int sk_keyLen; //私钥/对称密钥密文长度
unsigned char sk_keyAttr[TASS_KEY_ATTR_SIZE_MAX]; //私钥/对称密钥属性
unsigned int sk_keyAttrLen; //私钥/对称密钥属性长度
unsigned char pk_kcv[TASS_PK_SIZE_MAX]; //公钥/对称密钥校验值
unsigned int pk_kcvLen; //公钥/对称密钥校验值长度
unsigned char pkAttr[TASS_KEY_ATTR_SIZE_MAX]; //公钥属性，非对称时有效
unsigned int pkAttrLen; //公钥属性长度
}TassKeyInfo;
/**
* @brief 搜索设备
*
* @param id [in] 设备ID缓冲区，传NULL时通过len返回需要的缓冲区大小
* @param idLen [in|out] 输入时标识id缓冲区大小
* 输出时标识id实际长度
* 多个设备ID间以‘\0’分隔，最后以两个'\0'结尾
*
* @return
* @retval 0 成功
* @retval other 失败
*
*/
int TassCtlScanDevice(char* id, unsigned int* idLen);
/**
* @brief 打开设备
*
* @param id [in] 要打开的设备ID，通过TassScan获取
* @param phDevice [out] 设备句柄
*
* @return
* @retval 0 成功
* @retval other 失败
*
*/
int TassCtlOpenDevice(const char id[TASS_DEV_ID_STR_SIZE + 1], void** phDevice);
/**
* @brief 关闭设备
*
* @param hDevice [in] 已打开的设备句柄
*
* @return
* @retval 0 成功
* @retval other 失败
*
*/
int TassCtlCloseDevice(void* hDevice);
/**
* @brief 管理员管理功能
*
* @func TassListAdmin
* @func TassLogin
* @func TassLogout
* @func TassMakeAdminUKey
* @func TassUpdatePWD
* @func TassAddAdmin
* @func TassRemoveAdmin
*
*/
/**
* @brief 获取用户列表
* @param hDevice [in] 已打开的设备句柄
* @param info [in] 管理员信息，传NULL时通过len返回需要的缓冲区大小
* @param infoLen [in|out] 输入时标识info缓冲区大小
* 输出时标识info实际长度
* 用户数量可通过计算“len / sizeof(TassAdminInfo)”获取
*
* @return
* @retval 0 成功
* @retval other 失败
*
* @note 打开设备后必须首先执行登录接口，才能执行其他操作
*/
int TassCtlListAdmin(void* hDevice,
TassAdminInfo* info, unsigned int* infoLen);
/**
* @brief 申请口令哈希加密公钥
*
* @param hDevice [in] 已打开的设备句柄
* @param pk [out] 用于加密口令哈希的公钥
*
* @return
* @retval 0 成功
* @retval other 失败
*
* @note 打开设备后必须首先执行登录接口，才能执行其他操作
*/
int TassCtlRequestPwdHashEncPublicKey(void* hDevice, unsigned char pk[64]);
/**
* @brief 通过哈希加密公钥加密口令hash值得到哈希值密文
*
* @param hDevice [in] 已打开的设备句柄
* @param pk [in] 用于加密口令哈希的公钥
* @param pwd [in] 用户登录口令
* @param pwdHashCipher [out] 管理员口令的哈希值密文
*
* @return
* @retval 0 成功
* @retval other 失败
*
*/
int TassCtlEncryptPwdHash(void* hDevice, const unsigned char pk[64], const char* pwd, unsigned char pwdHashCipher[128]);
/**
* @brief 登录
*
* @param hDevice [in] 已打开的设备句柄
* @param name [in] 管理员名称，设备管理员固定为“admin”
* @param pwdHashCipher [in] 管理员口令的哈希值密文
*
* @return
* @retval 0 成功
* @retval other 失败
*
* @note 打开设备后必须首先执行登录接口，才能执行其他操作
*/
int TassCtlLogin(void* hDevice,
const char* name,
const unsigned char pwdHashCipher[128]);
/**
* @brief 登出
*
* @param hDevice [in] 已打开的设备句柄
*
* @return
* @retval 0 成功
* @retval other 失败
*/
int TassCtlLogout(void* hDevice);
/**
* @brief 修改口令
*
* @param hDevice [in] 已打开的设备句柄
* @param name [in] 已登录的用户名
* @param oldPwdHashCipher [in] 旧管理员口令的哈希值密文
* @param newPwdHashCipher [in] 新管理员口令的哈希值密文
*
* @return
* @retval 0 成功
* @retval other 失败
*
*/
int TassCtlUpdatePwdHash(void* hDevice,
const char* name,
const unsigned char oldPwdHashCipher[128],
const unsigned char newPwdHashCipher[128]);
/**
* @brief 绑定UKey（暂未启用）
*
* @param hDevice [in] 已打开的设备句柄
* @param name [in] 已登录的用户名称
* @param pwdHashCipher [in] 管理员口令的哈希值密文
* @param ukeyId [in] UKey序号
*
* @return
* @retval 0 成功
* @retval other 失败
*
* @note 制作UKey后，登录时必须插入该UKey
*/
int TassCtlBindUKey(void* hDevice,
const char* name,
const char pwdHashCipher[128],
const char* ukeyId);
/**
* @brief 添加密钥管理员（暂未启用）
*
* @param hDevice [in] 已打开的设备句柄
* @param devPwdHashCipher [in] 设备管理员口令的哈希值密文
* @param name [in] 增加的密钥管理员名称，不能与已存在管理员名称相同
* @param pwdHashCipher [in] 增加的密钥管理员口令的哈希值密文
*
* @return
* @retval 0 成功
* @retval other 失败
*
* @note 须先登录设备管理员
*
*/
int TassCtlAddKeyAdmin(void* hDevice,
const unsigned char devPwdHashCipher[128],
const char* name,
const unsigned char pwdHashCipher[128]);
/**
* @brief 删除密钥管理员（暂未启用）
*
* @param hDevice [in] 已打开的设备句柄
* @param devPwdHashCipher [in] 设备管理员口令的哈希值密文
* @param name [in] 删除的密钥管理员名称
*
* @return
* @retval 0 成功
* @retval other 失败
*
* @note 须先登录设备管理员
*
*/
int TassCtlRemoveKeyAdmin(void* hDevice,
const unsigned char devPwdHashCipher[128],
const char* name);
/**
* @brief 设备管理功能
*
* @func TassCtlDeviceFormat
* @func TassCtlDeviceInit
* @func TassCtlDeviceInitRestoreFactory
* @func TassCtlBootAuth
* @func TassGetInfo
* @func TassSetInfo
* @func TassSelfCheck
* @func TassRestoreFactory
* @func TassInitialize
* @func TassBootAuth
* @func TassExportDevEncKeyPair
* @func TassExportDevKEK
* @func TassImportDevKEK
*
*/
/**
* @brief 设备格式化
* 清除设备中的全部数据，包括设备密钥FLASH数据等
*
* @param hDevice [in] 已打开的设备句柄
* @param pwdHashCipher [in] 设备管理员口令的哈希值密文
*
* @return
* @retval 0 成功
* @retval other 失败
*
* @note
* 1. 需要设备管理员登录
* 2. 执行成功后会清除登录状态，需要使用默认设备管理员口令登录
*/
int TassCtlDeviceFormat(void* hDevice,
const unsigned char pwdHashCipher[128]);
/**
* @brief 设备初始化
* 使用随机密钥初始化设备
*
* @param hDevice [in] 已打开的设备句柄
* @param newPwdHashCipher [in] 新的设备管理员口令密文
* @param bootAuth [in] 是否开机认证
* @param devSn [in] 设备序列号，可以从设备表面标签或包装盒外部标签获取
* @param selfCheckCycle [in] 设备自检周期，暂时不启用
* @param kekCv [out] 设备本地保护密钥校验值，为NULL时不输出
*
* @return
* @retval 0 成功
* @retval other 失败
*
* @note
* 1. 设备必须为格式化状态（TassCtlDeviceFormat成功）
* 2. 需要设备管理员登录
* 3. 执行成功后会清除登录状态，需要使用新的设备管理员口令登录
*/
int TassCtlDeviceInit(void* hDevice,
const unsigned char newPwdHashCipher[128],
TassBool bootAuth,
const unsigned char devSn[4], unsigned int selfCheckCycle,
unsigned char kekCv[16]);
/**
* @brief 设备初始化恢复出厂
* 使用出厂默认密钥初始化设备
*
* @param hDevice [in] 已打开的设备句柄
* @param devSn [in] 设备序列号，可以从设备表面标签或包装盒外部标签获取
* @param selfCheckCycle [in] 设备自检周期，暂时不启用
*
* @return
* @retval 0 成功
* @retval other 失败
*
* @note
* 1. 设备必须为格式化状态（TassCtlDeviceFormat成功）
* 2. 需要设备管理员登录
*/
int TassCtlDeviceInitRestoreFactory(void* hDevice,
const unsigned char devSn[4],
unsigned int selfCheckCycle);
/**
* @brief 获取密码卡信息（暂未启用）
*
* @param hDevice [in] 已打开的设备句柄
* @param info [in] 信息类型，详见TassInfoType说明
* @param buf [out] 具体信息，传NULL时通过len返回需要的缓冲区大小
* @param len [in|out] 输入时标识buf缓冲区大小
* 输出时标识buf实际长度
*
* @return
* @retval 0 成功
* @retval other 失败
*
*/
int TassCtlGetInfo(void* hDevice,
TassDevInfo info,
void* buf, unsigned int* len);
/**
* @brief 设置密码卡信息（暂未启用）
*
* @param hDevice [in] 已打开的设备句柄
* @param info [in] 信息类型，仅TA_DEV_SN和TA_SELF_CHECK_CYCLE有效
* @param buf [in] 具体信息
* @param len [in] 信息长度
* @param sig [in] 管理员私钥对函数名和除hDevice及sig之外所有入参的签名
*
* @return
* @retval 0 成功
* @retval other 失败
*
* @note 须先登录设备管理员
*
*/
int TassCtlSetInfo(void* hDevice,
TassDevInfo info,
void* buf, unsigned int len,
const unsigned char sig[64]);
/**
* @brief 自检（暂未启用）
* 使用随机密钥替换密码卡默认密钥
*
* @param hDevice [in] 已打开的设备句柄
* @return
* @retval 0 成功
* @retval other 失败
*
*/
int TassCtlSelfCheck(void* hDevice);
/**
* @brief 恢复出厂设置
* 恢复密码卡默认密钥和状态
*
* @param hDevice [in] 已打开的设备句柄
* @param pwdHashCipher [in] 设备管理员口令的哈希值密文
*
* @return
* @retval 0 成功
* @retval other 失败
*
* @note 须先登录设备管理员
*
*/
int TassCtlRestoreFactory(void* hDevice,
const unsigned char pwdHashCipher[128]);
/**
* @brief 生成设备加密密钥对（暂未启用）
*
*
* @param hDevice [in] 已打开的设备句柄
*
* @return
* @retval 0 成功
* @retval other 失败
*
* @note 须先登录设备管理员
*
*/
int TassCtlGenDevEncKeyPair(void* hDevice);
/**
* @brief 生成设备本地保护密钥（暂未启用）
*
*
* @param hDevice [in] 已打开的设备句柄
* @param bootAuth [in] 是否开机认证
*
* @return
* @retval 0 成功
* @retval other 失败
*
* @note 须先登录设备管理员
*
*/
int TassCtlGenDevKEK(void* hDevice,
TassBool bootAuth);
/**
* @brief 导入设备加密密钥对（暂未启用）
*
*
* @param hDevice [in] 已打开的设备句柄
* @param pwdHashCipher [in] 设备管理员口令的哈希值密文
* @param pk [in] 设备加密密钥对公钥
* @param skEnvelopByDevSignPk [in] 设备签名密钥对封装的设备加密密钥对私钥信封
*
* @return
* @retval 0 成功
* @retval other 失败
*
* @note 须先登录设备管理员
*
*/
int TassCtlImportDevEncKeyPair(void* hDevice,
const unsigned char pwdHashCipher[128],
const unsigned char pk[64],
const unsigned char skEnvelopByDevSignPk[144]);
/**
* @brief 导入设备本地保护密钥（暂未启用）
*
*
* @param hDevice [in] 已打开的设备句柄
* @param pwdHashCipher [in] 设备管理员口令的哈希值密文
* @param bootAuth [in] 是否开机认证
* @param kekCipherByDevEncPk [in] 设备加密密钥对加密的设备本地保护密钥密文
*
* @return
* @retval 0 成功
* @retval other 失败
*
* @note 须先登录设备管理员
*
*/
int TassCtlImportDevKEK(void* hDevice,
const unsigned char pwdHashCipher[128],
TassBool bootAuth,
const unsigned char kekCipherByDevEncPk[112]);
/**
* @brief 开机认证
*
* @param hDevice [in] 已打开的设备句柄
* @param pwdHashCipher [in] 设备管理员口令的哈希值密文
*
* @return
* @retval 0 成功
* @retval other 失败
*
* @note 须先登录设备管理员
*/
int TassCtlBootAuth(void* hDevice,
const unsigned char pwdHashCipher[128]);
/**
* @brief 导出设备加密密钥对（暂未启用）
*
* @param hDevice [in] 已打开的设备句柄
* @param keyPwdHashCipher [in] 密钥管理员口令的哈希值密文
* @param devPwdHashCipher [in] 设备管理员口令的哈希值密文
* @param pk [in] 加密公钥，通常为另一个设备的签名公钥
* @param encPk [out] 设备加密密钥对公钥
* @param encSkEnvelopByPk [out] 加密公钥封装的设备加密密钥对私钥信封
* @return
* @retval 0 成功
* @retval other 失败
*
* @note 须先登录密钥管理员，同时需要设备管理员口令进行授权
*/
int TassCtlExportDevEncKeyPair(void* hDevice,
const unsigned char keyPwdHashCipher[128],
const unsigned char devPwdHashCipher[128],
const unsigned char pk[64],
unsigned char encPk[64],
unsigned char encSkEnvelopByPk[144]);
/**
* @brief 导出设备本地保护密钥（暂未启用）
*
* @param hDevice [in] 已打开的设备句柄
* @param keyPwdHashCipher [in] 密钥管理员口令的哈希值密文
* @param devPwdHashCipher [in] 设备管理员口令的哈希值密文
* @param pk [in] 加密公钥，通常为另一个设备的加密公钥
* @param encKek [out] 加密公钥加密的设备本地保护密钥密文
* @return
* @retval 0 成功
* @retval other 失败
*
* @note 须先登录密钥管理员，同时需要设备管理员口令进行授权
*/
int TassCtlExportDevKEK(void* hDevice,
const unsigned char keyPwdHashCipher[128],
const unsigned char devPwdHashCipher[128],
const unsigned char pk[64],
unsigned char encKek[112]);
/**
* @brief 用户密钥管理
*
* @func TassListKey
* @func TassGenerateKey
* @func TassDestroyKey
* @func TassImportPlainKey
* @func TassBackup
* @func TassRecover
*
*/
/**
* @brief 获取密钥列表
*
* @param hDevice [in] 已打开的设备句柄
* @param alg [in] 密钥列表的算法
* @param info [out] 密钥信息，传NULL时通过len返回需要的缓冲区大小
* @param len [in|out] 输入时标识info缓冲区大小
* 输出时标识info实际长度
* 密钥数量可通过计算“len / sizeof(TassKeyInfo)”获取
* @return
* @retval 0 成功
* @retval other 失败
*
*/
int TassCtlListKey(void* hDevice,
TassAlg alg,
TassKeyInfo* info, int* len);
/**
* @brief 生成密钥
*
* @param hDevice [in] 已打开的设备句柄
* @param alg [in] 密钥类型
* @param keyBits [in] 模长,
* 密钥类型为 2-SM2、3-ECC_256R1、8-ECC_256K1时，模长只支持256
* 密钥类型为 4-RSA时，模长只支持2048
* 密钥类型为 9-HMAC时，支持模长是128、256、384、512bit,
* 类型为0-SM4、1-SM1、5-AES、6-DES、7-SM7时，仅模长仅支持128
* @param index [in] 密钥索引，为0时根据标签存储密钥，为-1时不存储
* @param label [in] 密钥标签
* @param pwd [in] 私钥口令，当前未启用
* type为非对称密钥时有效
* @param sk_key [out] 私钥密文或对称密钥密文，传NULL时通过sk_keyLen返回需要的缓冲区大小
* @param sk_keyLen [in|out] 输入时标识sk_key缓冲区大小
* 输出时标识sk_key实际长度
* @param pk_kcv [out] 公钥，传NULL时通过pk_kcvLen返回需要的缓冲区大小
* @param pk_kcvLen [in|out] 输入时标识pk_kcv缓冲区大小
* 输出时标识pk_kcv实际长度
*
* @return
* @retval 0 成功
* @retval other 失败
*
*/
int TassCtlGenerateKey(void* hDevice,
TassAlg alg,
unsigned int keyBits,
unsigned int index,
const char* label,
const char* pwd,
unsigned char* sk_key, unsigned int* sk_keyLen,
unsigned char* pk_kcv, unsigned int* pk_kcvLen);
/**
* @brief 导入明文密钥
*
* @param hDevice [in] 已打开的设备句柄
* @param alg [in] 导入的密钥算法，暂时仅支持TA_ALG_SM2和TA_ALG_SM4
* @param index [in] 导入的密钥索引，为0时根据标签存储密钥，为-1时不存储
* @param label [in] 导入的密钥标签
* @param pwd [in] 私钥口令，当前未启用
* type为非对称密钥时有效
* @param sk_key [in] 私钥或对称密钥明文
* @param sk_keyLen [in] sk_key长度
* @param pk_kcv [in] 公钥
* type为非对称密钥时有效
* @param pk_kcvLen [in] 公钥长度
*
* @return
* @retval 0 成功
* @retval other 失败
*
*/
int TassCtlImportPlainKey(void* hDevice,
TassAlg alg,
unsigned int index,
const char* label,
const char* pwd,
const unsigned char* sk_key, unsigned int sk_keyLen,
const unsigned char* pk_kcv, unsigned int pk_kcvLen);
/**
* @brief 通过sm2密钥保护导出非对称密钥
*
* @param hDevice [in] 已打开的设备句柄
* @param sm2Pk [in] SM2保护公钥
* @param exportedKeyAlg [in] 待导出的密钥算法，支持SM2/ECC_SECP_256R1/RSA/ECC_SECP_256K1
* @param exportedKeyIndex [in] 待导出的密钥索引
* @param devPwdHashCipher [in] 设备管理员口令的哈希值密文
* @param symmKeyCipher [out]随机对称密钥密文
* @param symmKeyCipherkLen [out]随机对称密钥密文长度
* @param exportedPk [out] 待导出的公钥
* @param exportedPkLen [out] 待导出的公钥长度
* @param exportedKeyCipherByPk [out] SM2公钥加密的待导出私钥密钥密文
* @param exportedKeyCipherByPkLen [out] SM2公钥加密的待导出私钥密钥密文长度
*
* @return
* @retval 0 成功
* @retval other 失败
*
*/
int TassCtlExportKey(void* hDevice,
const unsigned char sm2Pk[64],
TassAlg exportedKeyAlg,
unsigned int exportedKeyIndex,
const unsigned char devPwdHashCipher[128],
unsigned char* symmKeyCipher,
unsigned int* symmKeyCipherLen,
unsigned char* exportedPk,
unsigned int* exportedPkLen,
unsigned char* exportedKeyCipherByPk,
unsigned int* exportedKeyCipherByPkLen);
/**
* @brief 通过sm2密钥保护导入非对称密钥
*
* @param hDevice [in] 已打开的设备句柄
* @param sm2Sk [in] SM2私钥
* @param importedKeyAlg [in] 待导入的密钥算法,支持SM2/ECC_SECP_256R1/RSA/ECC_SECP_256K1
* @param importedKeyIndex [in] 待导入的密钥索引
* @param importedKeyLabel [in] 待导入的密钥标签
* @param importedKeyLabelLen [in] 待导入的密钥标签长度
* @param symmKeyCipher [in] 随机对称密钥密文
* @param symmKeyCipherkLen [in] 随机对称密钥密文长度
* @param importedPk [in] 待导入的公钥
* @param importedPkLen [in] 待导入的公钥长度
* @param importedKeyCipherByPk [in] SM2公钥加密的待导入私钥密钥密文
* @param importedKeyCipherByPkLen [in] SM2公钥加密的待导入私钥密钥密文长度
*
* @return
* @retval 0 成功
* @retval other 失败
*
*/
int TassCtlImportKey(void* hDevice,
const unsigned char sm2Sk[32],
TassAlg importedKeyAlg,
unsigned int importedKeyIndex,
const unsigned char* importedKeyLabel,
unsigned int importedKeyLabelLen,
unsigned char* symmKeyCipher,
unsigned int symmKeyCipherLen,
const unsigned char* importedPk,
unsigned int importedPkLen,
const unsigned char* importedKeyCipherByPk,
unsigned int importedKeyCipherByPkLen);
/**
* @brief 删除密钥
*
* @param hDevice [in] 已打开的设备句柄
* @param alg [in] 密钥算法
* @param index [in] 密钥索引
*
* @return
* @retval 0 成功
* @retval other 失败
*
*/
int TassCtlDestroyKey(void* hDevice,
TassAlg alg,
unsigned int index);
/**
* @brief 修改私钥权限口令
*
* @param hDevice [in] 已打开的设备句柄
* @param alg [in] 密钥算法，只支持非对称密钥
* @param index [in] 密钥索引
* @param privateKeyPwd [in] 私钥口令
* @param privateKeyPwdLen [in] 私钥口令长度
*
* @return
* @retval 0 成功
* @retval other 失败
*
*/
int TassCtlChangePrivateKeyAccessRight(void* hDevice,
TassAlg alg, unsigned int index,
const unsigned char* privateKeyPwd,
unsigned int privateKeyPwdLen);
/**
* @brief 备份，包括设备信息、密钥和FLASH索引信息
*
* @param hDevice [in] 已打开的设备句柄
* @param keyPwdHashCipher [in] 密钥管理员口令的哈希值密文
* @param devPwdHashCipher [in] 设备管理员口令的哈希值密文
* @param info [out] 备份信息，传NULL时通过infoLen返回需要的缓冲区大小
* @param infoLen [in|out] 输入时标识info缓冲区大小
* 输出时标识info实际长度
*
* @return
* @retval 0 成功
* @retval other 失败
*
* @note 须先登录密钥管理员，同时需要设备管理员口令进行授权
*
*/
int TassCtlBackup(void* hDevice,
const unsigned char keyPwdHashCipher[128],
const unsigned char devPwdHashCipher[128],
unsigned char* info, unsigned int* infoLen);
/**
* @brief 恢复设备信息
*
* @param hDevice [in] 已打开的设备句柄
* @param pwdHashCipher [in] 设备管理员口令的哈希值密文
* @param info [in] 备份的设备信息
* @param infoLen [in] info长度
*
* @return
* @retval 0 成功
* @retval other 失败
*
* @note 须先登录设备管理员
*
*/
int TassCtlRecover(void* hDevice,
const unsigned char pwdHashCipher[128],
const unsigned char* info, unsigned int infoLen);
/**
* @brief 校验备份数据信息的有效性
*
* @param hDevice [in] 已打开的设备句柄
* @param pwdHashCipher [in] 设备管理员口令的哈希值密文
* @param info [in] 备份的设备信息
* @param infoLen [in] info长度
*
* @return
* @retval 0 成功
* @retval other 失败
*
* @note 须先登录设备管理员
*
*/
int TassCtlCheckBackupInfoValid(void* hDevice,
const unsigned char pwdHashCipher[128],
const unsigned char* info, unsigned int infoLen);
#ifdef __cplusplus
}
#endif
plugin/crypto/tasshsm/include/TassType4PCIeSM.h deleted 100644 → 0
View file @ 9ed41107
#pragma once
#ifdef __cplusplus
extern "C" {
#endif
#define TA_DEVICE_ID_SIZE 16
typedef enum {
TA_DEV_STATE_INIT = 0x0, //初始状态，无密钥
TA_DEV_STATE_WORK = 0x1, //工作状态
TA_DEV_STATE_MNG = 0x2, //管理状态
}TassDevState;
typedef enum {
TA_BOOL_FALSE = 0, //私钥
TA_BOOL_TRUE = !TA_BOOL_FALSE, //公钥
}TassBool;
typedef enum {
TA_DEV_KEY_PLATFORM = 0, //管理平台密钥（公钥）
TA_DEV_KEY_SIGN = 1, //设备签名密钥
TA_DEV_KEY_ENC = 2, //设备加密密钥
TA_DEV_KEY_KEK = 3, //设备KEK
}TassDevKeyType;
typedef enum {
TA_ALG_SM4 = 0,
TA_ALG_SM1 = 1,
TA_ALG_AES = 5,
TA_ALG_DES = 6,
TA_ALG_SM7 = 7,
TA_ALG_SM2 = 2,
TA_ALG_ECC_SECP_256R1 = 3,
TA_ALG_ECC_SECP_256K1 = 8,
TA_ALG_RSA = 4,
TA_ALG_HMAC = 9,
}TassAlg;
typedef enum {
TA_RSA_E_3 = 3,
TA_RSA_E_65537 = 65537,
}TassRSA_E;
typedef enum {
TA_SYMM_ECB_ENC = 0x00000000,
TA_SYMM_ECB_DEC = 0x00000001,
TA_SYMM_CBC_ENC = 0x00000100,
TA_SYMM_CBC_DEC = 0x10000101,
TA_SYMM_CFB_ENC = 0x00000200,
TA_SYMM_CFB_DEC = 0x10000201,
TA_SYMM_OFB_ENC = 0x00000300,
TA_SYMM_OFB_DEC = 0x10000301,
TA_SYMM_MAC = 0x00000400,
}TassSymmOp;
typedef enum {
TA_SM2_KEY_EXCHANGE_SPONSOR = 0,
TA_SM2_KEY_EXCHANGE_RESPONSE = 1,
}TassSM2KeyExchangeRole;
typedef enum {
TA_ASYM_SIGN = 0,
TA_ASYM_ENC = 1,
TA_ASYM_KEY_EX = 2,
}TassAsymKeyUsage;
typedef enum {
TA_ASYM_ENCRYPT = 0,
TA_ASYM_DECRYPT = 1,
}TassSymmKeyUsage;
typedef enum {
TA_FLASH_2K = 0,
TA_FLASH_32K = 1,
}TassFlashFlag;
typedef enum {
TA_FLASH_GET_SIZE = 0,
TA_FLASH_READ = 1,
TA_FLASH_WRITE = 2,
TA_FLASH_ERASE = 3,
}TassFlashOp;
typedef struct {
unsigned char sigHead[16]; //签名数据头
unsigned char hwVer[4]; //硬件版本
unsigned char fpgaVer[4]; //FPGA版本
unsigned char keyMngChipVer[4]; //密管芯片版本
unsigned char devId[16]; //设备唯一标识，不可指定
unsigned char devSn[4]; //设备序列号，可指定
unsigned char fpgaHwCv[32]; //FPGA固件校验值
unsigned char devSignKeyPairInfo[4]; //设备签名密钥对信息
unsigned char platformPkInfo[4]; //管理平台公钥信息
unsigned char devEncKeyPairInfo[4]; //设备加密密钥对信息
unsigned char devKEKInfo[4]; //设备本地保护密钥信息
unsigned char kekCv[16]; //设备本地保护密钥校验值
unsigned char adminPkAblity[4]; //管理员公钥存储能力，大端格式
unsigned char curAdminPkNum[4]; //当前管理员公钥个数，大端格式
unsigned char adminPkInfo[5][4]; //管理员公钥信息5 * 4Bytes= 20Bytes
unsigned char devState[4]; //设备状态，大端格式
unsigned char temp[8]; //温度
unsigned char valtage[8]; //电压
unsigned char current[8]; //电流
unsigned char selfCheckCycle[4]; //自检周期，大端格式
unsigned char lastSelfCheckInfo[8]; //上次自检信息
unsigned char channelNum[4]; //通道总数，大端格式
unsigned char channelAlg[256]; //通道算法
unsigned char sig[64]; //设备签名公钥对上述数据的签名
}TassDevInfo;
/**
* @brief 签名回调函数，用于需要私钥签名的接口调用
*
* @param data [in] 待签名数据
* @param dataLen [in] data长度
* @param sig [out] 签名值
*
* @return 成功返回0，失败返回非0
*
*/
typedef int (*TassSignCb)(const unsigned char* data, int len, unsigned char sig[64]);
#ifdef __cplusplus
}
#endif
plugin/crypto/tasshsm/secp256k1/secp256k1_test.go deleted 100644 → 0
View file @ 9ed41107
package secp256k1
import (
"fmt"
"testing"
"gotest.tools/assert"
"github.com/33cn/chain33/common/crypto"
"github.com/33cn/chain33/system/crypto/secp256k1"
"github.com/33cn/plugin/plugin/dapp/evm/executor/vm/common"
ethCrypto "github.com/ethereum/go-ethereum/crypto"
"github.com/stretchr/testify/require"
)
//secp256k1签名DER编码格式
// 0x30 <length> 0x02
//<length r> r
//0x02 <length s>
//s
//30440220
//7C12FF568B6DA03EF2CD5681EE45EDF846172771AC6F9369B50FEBC95B1CF68F
//0220
//8B6916A3CC7423D9044E77ABECE410B69B7BD82C22ECCC76061B4BE79141D1A3
func Test_VerifySecp256k1SigFromTass_forChain33(t *testing.T) {
require := require.New(t)
//var pubKey secp256k1.PubKeySecp256k1
pubBytes := common.FromHex("04C24FBA65F8CD81223D2935EDEA663048A1BEFB5A78BC67C80DCB5A1D601F898C35EA242D2E76CACE9EE5A61DBDA29A5076707325FE20B5A80DB0CA6D02C5D983")
secpPubKey, err := ethCrypto.UnmarshalPubkey(pubBytes)
require.Equal(nil, err)
pub33Bytes := ethCrypto.CompressPubkey(secpPubKey)
c := &secp256k1.Driver{}
pubKey, err := c.PubKeyFromBytes(pub33Bytes)
require.Equal(nil, err)
//msg := []byte("12345678123456781234567812345678")
msg := []byte("456789")
hash := crypto.Sha256(msg)
fmt.Println("hash = ", common.Bytes2Hex(hash))
//0xfed9efbd5a8ef6820d639dbcb831daf9d6308312cc73d6188beb54a9a148e29a
sig, err := c.SignatureFromBytes(common.FromHex("304502207C12FF568B6DA03EF2CD5681EE45EDF846172771AC6F9369B50FEBC95B1CF68F0221008B6916A3CC7423D9044E77ABECE410B69B7BD82C22ECCC76061B4BE79141D1A3"))
//sig, err := c.SignatureFromBytes(common.FromHex("304402207C12FF568B6DA03EF2CD5681EE45EDF846172771AC6F9369B50FEBC95B1CF68F02208B6916A3CC7423D9044E77ABECE410B69B7BD82C22ECCC76061B4BE79141D1A3"))
require.Equal(nil, err)
result := pubKey.VerifyBytes(msg, sig)
require.Equal(true, result)
}
//在以太坊上的验证签名的有效性
//注意：从加密中导出的签名信息中RS信息中的首字节必须大于０，否则签名验证失败
func Test_Verify4Eth(t *testing.T) {
pub := common.FromHex("04C24FBA65F8CD81223D2935EDEA663048A1BEFB5A78BC67C80DCB5A1D601F898C35EA242D2E76CACE9EE5A61DBDA29A5076707325FE20B5A80DB0CA6D02C5D983")
sig := common.FromHex("2F2F8EF10E6C9075CAB44DE3C4F904817220537C1E7DCFADD502C03F14F5B3974C405EA9BB189B85F15B91C82CE5D6191D66238ECCCE83FA8F8FF83173F1586F00")
msg := []byte("456789")
hash := crypto.Sha256(msg)
fmt.Println("hash = ", common.Bytes2Hex(hash))
pubRecoverd, err := ethCrypto.Ecrecover(hash[:], sig)
require.Equal(t, nil, err)
fmt.Println("pubRecoverd = ", common.Bytes2Hex(pubRecoverd))
VerifyResult := ethCrypto.VerifySignature(pub, hash[:], sig[:64])
assert.Equal(t, true, VerifyResult)
}
func Test_secp256k1(t *testing.T) {
require := require.New(t)
c := &secp256k1.Driver{}
priv, err := c.PrivKeyFromBytes(common.FromHex("CC38546E9E659D15E6B4893F0AB32A06D103931A8230B0BDE71459D2B27D6944"))
require.Nil(err)
t.Logf("priv:%X, len:%d", priv.Bytes(), len(priv.Bytes()))
pub := priv.PubKey()
require.NotNil(pub)
t.Logf("pub:%X, len:%d", pub.Bytes(), len(pub.Bytes()))
//msg := []byte("12345678123456781234567812345678")
//msg := []byte("hello world")
msg := []byte("456789")
signature := priv.Sign(msg)
t.Logf("sign:%X, len:%d", signature.Bytes(), len(signature.Bytes()))
t.Logf("signature in hex format:%s", common.Bytes2Hex(signature.Bytes()))
//0x3045022100f4009ab47dc32880b3e0bfad47885e9cfd1fd2228e804b38fb7f0f5ea6c02405022061422eb681fdd5078aa3971770cf22ce4ef12e9116995e4a3e141e23f5403014
ok := pub.VerifyBytes(msg, signature)
require.Equal(true, ok)
}
plugin/crypto/tasshsm/sm2/sm2_test.go deleted 100644 → 0
View file @ 9ed41107
package sm2
import (
"fmt"
"math/big"
"testing"
"github.com/tjfoc/gmsm/sm3"
"github.com/33cn/plugin/plugin/dapp/evm/executor/vm/common"
"github.com/33cn/chain33/system/crypto/sm2"
"github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"
gmsm_sm2 "github.com/tjfoc/gmsm/sm2"
)
//data = 112233445566112233445566112233445566112233445566
//SDF_HashFinal success! sm3Len = 32, sm3Hash = 6DB75BE80A3EE89F1F049F6F046BFF5B39CF686E502F29906DECCCF8C72E4907
//
//SDF_InternalSign_ECC success
//sign.r: 0000000000000000000000000000000000000000000000000000000000000000F5BBF85D6165F6C027EA80A2930E270DAEF152FB5F090365E2AD55BE31BF2EF4
//sign.s: 00000000000000000000000000000000000000000000000000000000000000001C68E90BFEDE1196F3CB2447EA0A6D81818627C6AA447F4CFC57BD817A42222A
//
//SDF_InternalVerify_ECC success
//SDF_ExportSignPublicKey_ECC success for chain33 verification
//chain33 PubKey.bits: 256
//chain33 PubKey.x: 0000000000000000000000000000000000000000000000000000000000000000FD4241057FEC6CBEEC501F7E1763751B8F6DFCFB910FB634FBB76A16639EF172
//chain33 PubKey.y: 00000000000000000000000000000000000000000000000000000000000000001C6DA89F9C1A5EE9B6108E5A2A5FE336962630A34DBA1AF428451E1CE63BB3CF
func Test_Crypto(t *testing.T) {
require := require.New(t)
c := &sm2.Driver{}
priv, err := c.GenKey()
require.Nil(err)
t.Logf("priv:%X, len:%d", priv.Bytes(), len(priv.Bytes()))
pub := priv.PubKey()
require.NotNil(pub)
t.Logf("pub:%X, len:%d", pub.Bytes(), len(pub.Bytes()))
msg := []byte("hello world")
signature := priv.Sign(msg)
t.Logf("sign:%X, len:%d", signature.Bytes(), len(signature.Bytes()))
ok := pub.VerifyBytes(msg, signature)
require.Equal(true, ok)
}
//SDF_HashFinal success! sm3Len = 32, sm3Hash = 9D6A3506E37DB26538706965689AACE220D32391812A82F6C28A06AE8E2F2434
//
//SDF_InternalSign_ECC success
//sign.r: 00000000000000000000000000000000000000000000000000000000000000003AA29337E7149047FB8AE83F30AA00125E23173C88F284ADDED2E5B59ACAA5B9
//sign.s: 0000000000000000000000000000000000000000000000000000000000000000E2E9338109D74269578216039FD4D1C764E7F6F142CBB2E3035E7E49D375D330
//
//SDF_InternalVerify_ECC success
//SDF_ExportSignPublicKey_ECC success for chain33 verification
//chain33 PubKey.bits: 256
//chain33 PubKey.x: 0000000000000000000000000000000000000000000000000000000000000000FD4241057FEC6CBEEC501F7E1763751B8F6DFCFB910FB634FBB76A16639EF172
//chain33 PubKey.y: 00000000000000000000000000000000000000000000000000000000000000001C6DA89F9C1A5EE9B6108E5A2A5FE336962630A34DBA1AF428451E1CE63BB3CF
func Test_VerifySigFromTass(t *testing.T) {
require := require.New(t)
//c := &sm2.Driver{}
xBytes := common.FromHex("0000000000000000000000000000000000000000000000000000000000000000FD4241057FEC6CBEEC501F7E1763751B8F6DFCFB910FB634FBB76A16639EF172")
yBytes := common.FromHex("00000000000000000000000000000000000000000000000000000000000000001C6DA89F9C1A5EE9B6108E5A2A5FE336962630A34DBA1AF428451E1CE63BB3CF")
x := new(big.Int).SetBytes(xBytes)
y := new(big.Int).SetBytes(yBytes)
publicKey := &gmsm_sm2.PublicKey{
X: x,
Y: y,
}
var pubSM2 sm2.PubKeySM2
copy(pubSM2[:], gmsm_sm2.Compress(publicKey))
rBytes := common.FromHex("00000000000000000000000000000000000000000000000000000000000000003AA29337E7149047FB8AE83F30AA00125E23173C88F284ADDED2E5B59ACAA5B9")
sBytes := common.FromHex("0000000000000000000000000000000000000000000000000000000000000000E2E9338109D74269578216039FD4D1C764E7F6F142CBB2E3035E7E49D375D330")
r := new(big.Int).SetBytes(rBytes)
s := new(big.Int).SetBytes(sBytes)
signature := sm2.SignatureSM2(sm2.Serialize(r, s))
msg := []byte("112233445566112233445566112233445566112233445566")
ok := pubSM2.VerifyBytes(msg, signature)
require.Equal(true, ok)
}
func Test_msgHash(t *testing.T) {
uid := []byte{0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38}
xBytes := common.FromHex("0000000000000000000000000000000000000000000000000000000000000000FD4241057FEC6CBEEC501F7E1763751B8F6DFCFB910FB634FBB76A16639EF172")
yBytes := common.FromHex("00000000000000000000000000000000000000000000000000000000000000001C6DA89F9C1A5EE9B6108E5A2A5FE336962630A34DBA1AF428451E1CE63BB3CF")
x := new(big.Int).SetBytes(xBytes)
y := new(big.Int).SetBytes(yBytes)
publicKey := &gmsm_sm2.PublicKey{
X: x,
Y: y,
}
var pubSM2 sm2.PubKeySM2
copy(pubSM2[:], gmsm_sm2.Compress(publicKey))
pub := gmsm_sm2.Decompress(pubSM2[0:sm2.SM2PublicKeyCompressed])
za, err := gmsm_sm2.ZA(pub, uid)
assert.Equal(t, nil, err)
//msg := []byte("112233445566112233445566112233445566112233445566")
msg := common.FromHex("112233445566112233445566112233445566112233445566")
fmt.Println("msg = ", common.Bytes2Hex(msg))
e := sm3.New()
e.Write(za)
e.Write(msg)
hashInt := new(big.Int).SetBytes(e.Sum(nil)[:32])
fmt.Print("hash = ", common.Bytes2Hex(hashInt.Bytes()))
//hash = 0x9d6a3506e37db26538706965689aace220d32391812a82f6c28a06ae8e2f2434
//726106A793A45AF8EE1B9B6781B87391E4B49304A5F12F6DFF82C7EDB5F58390
//0x726106a793a45af8ee1b9b6781b87391e4b49304a5f12f6dff82c7edb5f58390
}
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment