实验一密码引擎加密API实现与测试

实验任务

1 下载并查找GMT 0018-2012密码设备应用接口规范原始文档进行学习（5分）

2 实现GMT 0018-2012密码设备应用接口规范的接口函数，至少实现：

1）设备管理中的打开设备，关闭设备，获取设备信息，产生随机数（4分）
2）密钥管理导出 ECC 签名公钥;SDF_ExportSignPublicKey_ECC I.导出 ECC加密公钥∶SDF_ExportEncPublicKey_ECC J. 产生 ECC非对称密钥对并输出∶SDF_GenerateKeyPair_ECC K. （6分）
3）非对称算法（至少支持SM2）：外部密钥 ECC验证∶SDF_ExternalVerify_ECC ，内部密钥 ECC签名;SDF_InternalSign_ECC ，内部密钥 ECC验证∶SDF_InternalVerify_ECC 外部密钥 ECC加密∶SDF_ExternalEncrypt_ECC （8分）
4）对称算法（至少支持SM4）∶SDF_Encrypt 对称解密∶SDF_Dccrypt 计算 MAC∶SDF_CalculateMAC（6分）
5）杂凑算法（至少支持SM3）：· 杂凑运算初始化∶SDF_HashInit· 多包杂凑运算∶SDF_HashUpdate· 杂凑运算结束∶SDF_HashFinal（6分）

密钥管理要求（10分）
基于本标准设计、开发的密码设备在密钥管理方面，应满足以下要求; 1）设备密钥的使用不对应用系统开放; 2）密钥必须用安全的方法产生并存储;
3）在任何时间、任何情况下，除公钥外的密钥均不能以明文形式出现在密码设备外; 4）密码设备内部存储的密钥应具备有效的密钥保护机制，防止解剖、探测和非法读取; 5）密码设备内部存储的密钥应具备权限控制机制，防止非法使用和导出。

设备状态要求（5分）
基于本标准设计、开发的密码设备在设备状态方面，应满足以下要求; 1）密码设备应具有初始和就绪两个状态;
2）未安装设备密钥的密码设备应处干初始状态，已安装设备密钥的密码设备应处于就绪状态; 3）在初始状态下，除可读取设备信息、设备密钥的生成或恢复操作外，不能执行任何操作，生成或恢复设备密钥后，密码设备处于就绪状态;
4）在就绪状态下，除设备密钥的生成或恢复操作外，应能执行任何操作; 5）在就绪状态下进行的密钥操作，设备操作员应经过密码设备的认证。
本标准的目标是为公钥密码基础设施应用体系框架下的服务类密码设备制定统一的应用接口标准，通过该接口调用密码设备，向上层提供基础密码服务。为该类密码设备的开发、使用及检测提供标准依据和指导，有利于提高该类密码设备的产品化、标准化和系列化水平。

一、下载并查找GMT 0018-2012密码设备应用接口规范原始文档进行学习

基础密码服务包括密钥生成、单一的密码运算、文件管理等服务。
本标准采用C语言描述接口函数，无特别说明时，函数中参数的长度单位均为字节数。
设备管理类函数：
打开设备：SDF_OpenDevice
关闭设备：SDF_CloseDevice
创建会话：SDF_OpenSession
关闭会话：SDF_CloseSession
获取设备信息：SDF_GetDeviceInfo
产生随机数：SDF_GenerateRandom
获取私钥使用权限：SDF_GetPrivateKeyAccessRight
释放私钥使用权限：SDF_ReleasePrivateKeyAccessRight
密钥管理类函数：
导出 RSA 签名公钥:SDF_ExportSignPublicKey_RSA
导出 RSA 加密公钥:SDF_ExportEncPublicKey_RSA
产生RSA非对称密钥对并输出:SDF_GenerateKeyPair_RSA
生成会话密钥并用内部RSA公钥加密输出:SDF_GenerateKeyWithIPK_RSA
生成会话密钥并用外部RSA公钥加密输出:SDF_GenerateKeyWithEPK_RSA - 导人会话密钥并用内部RSA私钥解密:SDF_ImportKeyWithISK_RSA
基于 RSA 算法的数宇倍封转换:SDF_ExchangeDigitEnvelopeBaseOnRSA
导出 ECC 签名公钥：SDF_ExportSignPublicKey_ECC
导出 ECC 加密公钥:SDF_ExportEncPublicKey_ECC
产生ECC非对称密钥对并输出：SDF_GenerateKeyPair_ECC
生成会话密钥并用内部ECC公钥加密输岀:SDF_GenerateKeyWithIPK_ECC - 生成会话密钥并用外部ECC公钥加密输出:SDF_GenerateKeyWithEPK_ECC
导入会话密钥并用内部ECC私钥解密:SDFJmportKeyWithlSKJECC
生成密钥协商参数并输出:SDF_GenerateAgreementDataWithECC
计算会话密钥:SDF_GenerateKey WithECC
产生协商数据并计算会话密钥:SDF—GenerateAgreementDataAndKeyWithECC
基于 ECC算法的数字信封转换:SDF_ExchangeDigitEnvelopeBaseOnECC
生成会话密钥并用密钥加密密钥加密输出: SDF_GenerateKeyWithKEK
导入会话密钥并用密钥加密密钥解密:SDF_ImportKeyWithKEK
销毁会话密钥:SDF_DestroyKey
非对称算法运算类函数
部公钥 RSA 运算:SDF_ExternalPublicKeyOperation_RSA
内部公钥 RSA 运算:SDF_InternalPublicKeyOperation_RSA
内部私钥 RSA 运算:SDF_InternalPrivateKeyOperation_RSA
外部密钥 ECC 验证:SDF_ExternalVerify_ECC
内部密钥 ECC 签名:SDF_InternalSign_ECC
内部密钥 ECC 验证:SDF_InternalVerify_ECC
外部密钥 ECC 加密:SDF_ExternalEncrypt_ECC
对称算法运算类函数
对称加密：SDF_Encrypt
对称解密：SDF_Decrypt
计算MAC:SDF_CalculateMAC
杂凑运算类函数
杂凑运算初始化：SDF_HashInit
多包杂凑运算：SDF_HashUpdate
杂凑运算结束：SDF_HashFinal
安全要求
（1）基于本标准设计、开发的密码设备在密钥管理方面，应满足以下要求：
设备密钥的使用不对应用系统开放；
密钥必须用安全的方法产生并存储；
在任何时间、任何情况下，除公钥外的密钥均不能以明文形式出现在密码设备外；
密码设备内部存储的密钥应具备有效的密钥保护机制，防止解剖、探测和非法读取；
密码设备内部存储的密钥应具备权限控制机制，防止非法使用和导出。
（2）密码服务要求：
使用的密码算法应得到国家密码主管部门的批准；
使用国家密码主管部门认可的密码算法芯片；
本标准所列的所有接口函数均应能被应用系统任意调用。
（3）设备状态要求：
密码设备应具有初始和就绪两个状态；
未安装设备密钥的密码设备应处于初始状态，已安装设备密钥的密码设备应处于就绪状态；
在初始状态下，除可读取设备信息、设备密钥的生成或恢复操作外，不能执行任何操作，生成或恢复设备密钥后，密码设备处于就绪状态;
在就绪状态下，除设备密钥的生成或恢复操作外，应能执行任何操作；
在就绪状态下进行的密钥操作，设备操作员应经过密码设备的认证。
（4）其他要求：
密码设备应有安全机制和措施，保证密钥在生成、安装、导入、存储、备份.恢复及销毁整个生存期间的安全,此安全机制可由设备厂商自行设计实现。

二、实现GMT 0018-2012密码设备应用接口规范的接口函数

1）设备管理中的打开设备，关闭设备，获取设备信息，产生随机数

#ifndef__SDF_H
#define sDG_ H
typedef struct DeviceInfo_st
{
unsigned char IssuerName [40]; //设备生产厂商名称
unsigned char DeviceName [16];
unsigned char Deviceserial[16];
unsigned int Deviceversion ;
unsigned int standardversion ;
unsigned int As ymAlgAbility[2];
unsigned int symAlgAbility;
unsigned int HashAlgAbility;
unsigned int Buffersize;
}DEVICEINFO;

2）密钥管理导出 ECC 签名公钥;SDF_ExportSignPublicKey_ECC I.导出 ECC加密公钥∶SDF_ExportEncPublicKey_ECC J. 产生 ECC非对称密钥对并输出∶SDF_GenerateKeyPair_ECC K.

// Ecc密钥数据结构定义
#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 ;
// Ecc加密数据结构定义

typedef struct Ecccipher_st
{
unsigned char x[ECCref_MAX_IEN];
unsigned char y[ECCref_MAX_LEN];
unsigned char M[32];
unsigned int L;
unsigned char C[1];
}Eccipher;

// Ecc签名数据结构定义
typedef struct ECcsignature_st
{
unsigned char r[EcCref_MAX_LEN];
unsigned char s[EcCref_MAX_LEN];
}Eccsignature;

3）非对称算法（至少支持SM2）：外部密钥 ECC验证∶SDF_ExternalVerify_ECC ，内部密钥 ECC签名;SDF_InternalSign_ECC ，内部密钥 ECC验证∶SDF_InternalVerify_ECC 外部密钥 ECC加密∶SDF_ExternalEncrypt_ECC

typedef struct SDF_ENVELOPEDKEYBLOB
{
unsigned long ulAsymmAlgID;
unsigned long ulsymmAlgID;
ECCCIPHERBLOB ECccipherBlob;
ECCPUBLICKEYBLOB PubKey;
unsigned char cbEncryptedPriKey [64];
}ENVELOPEDKEYBLOB,*PENVELOPEDKEYBLOB;

#define SDR_OK 0x0 /l操作成功

4）对称算法（至少支持SM4）∶SDF_Encrypt 对称解密∶SDF_Dccrypt 计算 MAC∶SDF_CalculateMAC（6分）

/*此函数不对数据进行填充处理，输入的数据必须是指定算法分组长度的整数倍*/
int SDF_Encrypt (
void *hsessionHandle,
void *hKeyHandle,
unsigned int uiAlglD,
unsigned char *puclv,
unsigned char *pucData,

5）杂凑算法（至少支持SM3）：· 杂凑运算初始化∶SDF_HashInit· 多包杂凑运算∶SDF_HashUpdate· 杂凑运算结束∶SDF_HashFinal

int SDF_HashInit(
void *hsessionHandle,
unsigned int uiAlgID,
EccrefPublicKey *pucPublicKey,
unsigned char *puclD,
unsigned int uilDLength);

三、密钥管理要求

int SDF_ReadFile (
void *hsessionHandle,
unsigned char *pucFileName,
unsigned int uiNameLen, 
unsigned int uioffset,
unsigned int *puiFileLength ,
unsigned char *puCBuffer);

代码：

sdf.h:

#ifndef __SDF_H
#define __SDF_H

//定义设备信息结构
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;

//定义RSA密钥数据结构
#define RSAref_MAX_BITS 2048
#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;

//定义ECC密钥数据结构
#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;

//定义ECC加密数据结构
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[1];
} ECCCipher;
//定义ECC签名数据结构
typedef struct ECCSignature_st
{
    unsigned char r[ECCref_MAX_LEN];
    unsigned char s[ECCref_MAX_LEN];
} ECCSignature;

typedef UINT8;
typedef UINT32;
typedef UINT32 ULONG;
typedef UINT8 BYTE;
//定义ECC公钥数据结构
#define ECC_MAX_XCOORDINATE_BITS_LEN 512
#define ECC_MAX_YCOORDINATE_BITS_LEN 512
typedef struct Struct_ECCPUBLICKEYBLOB{
ULONG BitLen;
BYTE XCoordinate[ECC_MAX_XCOORDINATE_BITS_LEN/8];
BYTE YCoordinate[ECC_MAX_YCOORDINATE_BITS_LEN/8];
}ECCPUBLICKEYBLOB, * PECCPUBLICKEYBLOB;

//定义ECC密文数据结构
typedef struct Struct_ECCCIPHERBLOB{
BYTE XCoordinate[ECC_MAX_XCOORDINATE_BITS_LEN/8];
BYTE YCoordinate[ECC_MAX_XCOORDINATE_BITS_LEN/8];
BYTE HASH[32];
ULONG CipherLen;
BYTE Cipher[1];
}ECCCIPHERBLOB, * PECCCIPHERBLOB;

//定义ECC加密密钥对保护结构
typedef struct SDF_ENVELOPEDKEYBLOB
{
    unsigned long ulAsymmAlgID;
    unsigned long ulSymmAlgID;
    ECCCIPHERBLOB ECCCipherBlob;
    ECCPUBLICKEYBLOB PubKey;
    unsigned char cbEncryptedPriKey[64];
} ENVELOPEDKEYBLOB, * PENVELOPEDKEYBLOB;

//Error Code
#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	//输出参数错误
//SDR_BASE + 0x0000001F至SDR_BASE + 0x00FFFFFF	预留

//*********************************
//设备管理
//*********************************

/*
功能：打开密码设备
参数：phDeviceHandle[out] 返回设备句柄
返回值：0 成功
        非0 失败,返回错误代码
*/
int SDF_OpenDevice(void ** phDeviceHandle);

/*
功能：关闭密码设备，并释放相关资源
参数：hDeviceHandle[in] 已打开的设备句柄
返回值：0 成功
        非0 失败,返回错误代码
*/
int SDF_CloseDevice(void * hDeviceHandle);

/*
功能：获取设备信息
参数：hSessionHandle[in] 与设备建立的会话句柄
      pstDeviceInfo[out] 设备能力描述信息，内容及格式见设备信息定义
返回值：0 成功
        非0 失败,返回错误代码
*/
int SDF_GetDeviceInfo(void * hSessionHandle,DEVICEINFO * pstDeviceInfo);

/*
功能：获取指定长度的随机数
参数：hSessionHandle[in] 与设备建立的会话句柄
      uiLength[in]       欲获取的随机数长度
      pucRandom[out]     缓冲区指针，用于存放获取的随机数
返回值：0 成功
        非0 失败,返回错误代码
*/
int SDF_GenerateRandom (void * hSessionHandle, unsigned int uiLength,unsigned char * pucRandom);

/*
功能：导出密码设备内部存储的指定索引位置的签名公钥
参数：hSessionHandle[in] 与设备建立的会话句柄
      uiKeyIndex[in]     密码设备存储的ECC密钥对索引值
      pucPublicKey[out]  ECC公钥结构
返回值：0 成功
        非0 失败,返回错误代码
*/
int SDF_ExportSignPublicKey_ECC(void * hSessionHandle,unsigned int uiKeyIndex,ECCrefPublicKey * pucPublicKey);

/*
功能：导出密码设备内部存储的指定索引位置的加密公钥
参数：hSessionHandle[in] 与设备建立的会话句柄
      uiKeyIndex[in]     密码设备存储的ECC密钥对索引值
      pucPublicKey[out]  ECC公钥结构
返回值：0 成功
        非0 失败,返回错误代码
*/
int SDF_ExportEncPublicKey_ECC(void * hSessionHandle,unsigned int uiKeyIndex,ECCrefPublicKey * pucPublicKey);

/*
功能：请求密码设备产生指定类型和模长的ECC密钥对
参数：hSessionHandle[in] 与设备建立的会话句柄
      uiAlgID[in]        指定算法标识
      uiKeyBits[in]      指定密钥长度
      pucPublicKey[out]  ECC公钥结构
      pucPrivateKey[out] ECC私钥结构
返回值：0 成功
        非0 失败,返回错误代码
*/
int SDF_GenerateKeyPair_ECC( void * hSessionHandle,unsigned int uiAlgID,unsigned int uiKeyBits, ECCrefPublicKey * pucPublicKey,ECCrefPrivateKey * pucPrivateKey);

/*
功能：使用外部ECC公钥对ECC签名值进行验证运算
参数：hSessionHandle[in] 与设备建立的会话句柄
      uiAlgID[in]        算法标识，指定使用的ECC算法
      pucPublicKey[in]   外部ECC公钥结构
      pucData[in]        缓冲区指针，用于存放外部输入的数据
      uiDataLength[in]   输入的数据长度
      pucSignature[in]   缓冲区指针,用于存放输入的签名值数据
返回值：0 成功
        非0 失败,返回错误代码
备注：输入数据为待签数据的杂凑值。当使用SM2算法时，该输入数据为待签数据经过SM2签名预处理的结果,预处理过程见GM/T 0009。
*/
int SDF_ExternalVerify_ECC(void * hSessionHandle,unsigned int uiAlgID,ECCrefPublicKey * pucPublicKey, unsigned char * pucDataInput, unsigned int uiInputLength, ECCSignature * pucSignature);

/*
功能：使用内部ECC私钥对数据进行签名运算
参数：hSessionHandle[in] 与设备建立的会话句柄
      uiISKIndex[in]     密码设备内部存储的ECC签名私钥的索引值
      pucData[in]        缓冲区指针，用于存放外部输入的数据
      uiDataLength[in]   输入的数据长度
      pucSignature[out]  缓冲区指针,用于存放输入的签名值数据
返回值：0 成功
        非0 失败,返回错误代码
备注：输入数据为待签数据的杂凑值。当使用SM2算法时，该输入数据为待签数据经过SM2签名预处理的结果,预处理过程见GM/T 0009。
*/
int SDFInternalSign_ECC(void * hSessionHandle, unsigned int uiISKIndex, unsigned char * pucData,unsigned int uiDataLength, ECCSignature * pucSignature);

/*
功能：使用内部ECC公钥对ECC签名值进行验证运算
参数：hSessionHandle[in] 与设备建立的会话句柄
      uiISKIndex[in]    密码设备内部存储的ECC签名私钥的索引值
      pucData[in]        缓冲区指针，用于存放外部输入的数据
      uiDataLength[in]   输入的数据长度
      pucSignature[out]  缓冲区指针,用于存放输入的签名值数据
返回值：0 成功
        非0 失败,返回错误代码
备注：输入数据为待签数据的杂凑值。当使用SM2算法时，该输入数据为待签数据经过SM2签名预处理的结果,预处理过程见GM/T 0009。
*/
int SDF_InternalVerify_ECC(void * hSessionHandle,unsigned int uiISKIndex,unsigned char * pucData,unsigned int uiDataLength, ECCSignature * pucSignature);

/*
功能：使用外部ECC公钥对数据进行加密运算
参数：hSessionHandle[in] 与设备建立的会话句柄
      uiAlgID[in]        算法标识，指定使用的ECC算法
      pucPublicKey[in]   外部ECC公钥结构
      pucData[in]        缓冲区指针，用于存放外部输入的数据
      uiDataLength[in]   输入的数据长度
      pucEncData[out]    缓冲区指针，用于存放输出的数据密文
返回值：0 成功
        非0 失败,返回错误代码
*/
int SDF_ExternalEncrypt_ECC(void * hSessionHandle, unsigned int uiAlgID,ECCrefPublicKey * pucPublicKey, unsigned char * pucData, unsigned int uiDataLength, ECCCipher * pucEncData);

/*
功能：使用指定的密钥句柄和IV对数据进行对称加密运算
参数：hSessionHandle[in]    与设备建立的会话句柄
      hKeyHandle[in]        指定的密钥句柄
      uiAlgID[in]           算法标识,指定对称加密算法
      pucIV[in|out]         缓冲区指针，用于存放输入和返回的IV数据
      pucData[in]           缓冲区指针，用于存放输入的数据明文
      uiDataLength[in]      输入的数据明文长度
      pucEncData[out]       缓冲区指针，用于存放输出的数据密文
      puiEncDataLength[out] 输出的数据密文长度
返回值：0 成功
        非0 失败,返回错误代码
备注：此函数不对数据进行填充处理,输入的数据必须是指定算法分组长度的整数倍
*/
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);

/*
功能：使用指定的密钥句柄和IV对数据进行对称解密运算
参数：hSessionHandle[in]    与设备建立的会话句柄
      hKeyHandle[in]        指定的密钥句柄
      uiAlgID[in]           算法标识,指定对称加密算法
      pucIV[in|out]         缓冲区指针，用于存放输入和返回的IV数据
      pucEncData[in]        缓冲区指针，用于存放输入的数据明文
      uiEncDataLength[in]   输入的数据明文长度
      pucData[out]          缓冲区指针，用于存放输出的数据密文
      puiDataLength[out]    输出的数据密文长度
返回值：0 成功
        非0 失败,返回错误代码
备注：此函数不对数据进行填充处理,输入的数据必须是指定算法分组长度的整数倍
*/
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);

/*
功能：使用指定的密钥句柄和IV对数据进行MAC运算
参数：hSessionHandle[in]    与设备建立的会话句柄
      hKeyHandle[in]        指定的密钥句柄
      uiAlgID[in]           算法标识,指定对称加密算法
      pucIV[in|out]         缓冲区指针，用于存放输入和返回的IV数据
      pucData[in]           缓冲区指针，用于存放输出的数据明文
      uiDataLength[in]      输入的数据明文长度
      pucMAC[out]           缓冲区指针，用于存放输出的MAC值
      puiMACLength[out]     输出的MAC值长度
返回值：0 成功
        非0 失败,返回错误代码
备注：此函数不对数据进行分包处理，多包数据MAC运算由IV控制最后的MAC值
*/
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);

/*
功能：三步式数据杂凑运算第一步,杂凑运算初始化
参数：hSessionHandle[in] 与设备建立的会话句柄
      uiAlgID[in]        指定杂凑算法标识
      pucPublicKey[in]   签名者公钥。当uiAlgID为SGD_SM3时有效。
      pucID[in]          签名者的ID值,当uiAlgID为SGD_SM3时有效。
      uiIDLength[in]     签名者ID的长度,当uiAlgID为SGD.SM3时有效。
返回值：0 成功
        非0 失败,返回错误代码
备注：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);

/*
功能：三步式数据杂凑运算第二步，对输入的明文进行杂凑运算
参数：hSessionHandle[in] 与设备建立的会话句柄
      pucData[in]        缓冲区指针，用于存放输入的数据明文
      uiDataLength[in]   输入的数据明文长度
返回值：0 成功
        非0 失败,返回错误代码
*/
int SDF_HashUpdate(void * hSessionHandle,unsigned char * pucData,unsigned int uiDataLength);

/*
功能：三步式数据杂凑运算第三步，杂凑运算结束返回杂凑数据并清除中间数据
参数：hSessionHandle[in] 与设备建立的会话句柄
      pucHash[out]       缓冲区指针，用于存放输出的杂凑数据
      puiHashLength[out] 返回的杂凑数据长度
返回值：0 成功
        非0 失败,返回错误代码
*/
int SDF_HashFinal (void * hSessionHandle,unsigned char * pucHash,unsigned int * puiHashLength);

#endif

sdf.c:

#include "sdf.h"

int SDF_OpenDevice(void ** phDeviceHandle)
{
    return SDR_OK;
}
int SDF_CloseDevice(void * hDeviceHandle)
{
    return SDR_OK;
}
int SDF_GetDeviceInfo(void * hSessionHandle,DEVICEINFO * pstDeviceInfo)
{
    return SDR_OK;
}
int SDF_GenerateRandom (void * hSessionHandle, unsigned int uiLength,unsigned char * pucRandom)
{
    return SDR_OK;
}
int SDF_ExportSignPublicKey_ECC(void * hSessionHandle,unsigned int uiKeyIndex,ECCrefPublicKey * pucPublicKey)
{
    return SDR_OK;
}
int SDF_ExportEncPublicKey_ECC(void * hSessionHandle,unsigned int uiKeyIndex,ECCrefPublicKey * pucPublicKey)
{
    return SDR_OK;
}
int SDF_GenerateKeyPair_ECC( void * hSessionHandle,unsigned int uiAlgID,unsigned int uiKeyBits, ECCrefPublicKey * pucPublicKey,ECCrefPrivateKey * pucPrivateKey)
{
    return SDR_OK;
}
int SDF_ExternalVerify_ECC(void * hSessionHandle,unsigned int uiAlgID,ECCrefPublicKey * pucPublicKey, unsigned char * pucDataInput, unsigned int uiInputLength, ECCSignature * pucSignature)
{
    return SDR_OK;
}
int SDFInternalSign_ECC(void * hSessionHandle, unsigned int uiISKIndex, unsigned char * pucData,unsigned int uiDataLength, ECCSignature * pucSignature)
{
    return SDR_OK;
}
int SDF_InternalVerify_ECC(void * hSessionHandle,unsigned int uiISKIndex,unsigned char * pucData,unsigned int uiDataLength, ECCSignature * pucSignature)
{
    return SDR_OK;
}
int SDF_ExternalEncrypt_ECC(void * hSessionHandle, unsigned int uiAlgID,ECCrefPublicKey * pucPublicKey, unsigned char * pucData, unsigned int uiDataLength, ECCCipher * pucEncData)
{
    return SDR_OK;
}
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)
{
    return SDR_OK;
}
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)
{
    return SDR_OK;
}
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)
{
    return SDR_OK;
}
int SDF_HashInit(void * hSession Handle, unsigned int uiAlgID,ECCrefPublicKey * pucPublicKey,unsigned char * pucID, unsigned int uiIDLength)
{
    return SDR_OK;
}
int SDF_HashUpdate(void * hSessionHandle,unsigned char * pucData,unsigned int uiDataLength)
{
    return SDR_OK;
}
int SDF_HashFinal (void * hSessionHandle,unsigned char * pucHash,unsigned int * puiHashLength)
{
    return SDR_OK;
}

main.c:

#include "sdf.h"
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
int main()
{
    void **pdh;
    pdh=(void **)malloc(20);
    int ret;
    ret = SDF_OpenDevice(pdh);
    if(ret != SDR_OK)
    {
        printf("OpenDevice Failed!");
    }
    else
    {
        printf("OpenDevice Successed!");
    }
    DEVICEINFO a;
    ret = SDF_GetDeviceInfo(*pdh,&a);
    if(ret != SDR_OK)
    {
        printf("GetDeviceInfo Failed!");
    }
    else
    {
        printf("GetDeviceInfo Successed!");
    }
    printf("DeviceName:%s\n",a.DeviceName);
    printf("DeviceVersion:%d\n",a.DeviceVersion);
    ret = SDF_CloseDevice(*pdh);
    if(ret != SDR_OK)
    {
        printf("CloseDevice Failed!");
    }
    else
    {
        printf("CloseDevice Successed!");
    }
}

实现截图

相关阅读:
宏观经济指标
 Poloniex API 文档
 雪球释老毛推荐的投资者书单
 数字货币开源项目——貔貅
 数字货币量化分析报告_20170905_P
数字货币量化分析报告_2017-09-05
数字货币量化分析报告_2017-09-04
ICO成本价
 Python3使用Print输出带颜色字体
 Ta-lib函数功能列表
原文地址：https://www.cnblogs.com/1301cn/p/16200900.html