【无标题】

于 2024-12-01 21:07:34 发布
阅读量928 收藏 10
点赞数 6
CC 4.0 BY-SA版权
文章标签： 人工智能
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/m0_73622182/article/details/144174982

《密码系统设计》实验

实验三 密码模块实现 基于商⽤密码标准的密码模块的实现 1.理解密码系统固件、接⼝等的设计和开发流程；2．参考《GMT 0018-2023密码设备应⽤接⼝规范》等商⽤密码标准设计实现密码算法进⾏加密/解密、签名/验签、密钥⽣成/导出等的接⼝；3.与其他商⽤密码模块进⾏兼容性测试。
GMT0018
SDF.h
#ifndef __SDF_H
#define __SDF_H

#define ECCref_MAX_BITS 512
#define ECCref_MAX_LEN ((ECCref_MAX_BITS + 7) / 8)
#define SDR_OK 0x0
#define SDR_BASE 0x01000000
#define SGD_SM3 0x00000001
#define SDR_INARGERR (SDR_BASE + 0x0000001D)
#define SDR_STEPERR (SDR_BASE + 0x00000010)
//定义设备信息结构
typedef struct DeviceInfo_st{
unsigned char IssuerName[40]; //设备生产厂商名称
unsigned char DeviceName[16];
unsigned char DeviceSerial[16];
unsigned int DeviceVersion;
unsigned int StandardVersion;
unsigned int AsymAlgAbility[2];
unsigned int SymAlgAbilty;
unsigned int HashAlgAbility;
unsigned int BufferSize;
}DEVICEINFO;
typedef unsigned char BYTE; //—— 定义了BYTE为无符号8位字符类型。
typedef unsigned char CHAR; //—— 定义了CHAR为无符号8位字符类型。
typedef int LONG; //—— 定义了LONG为有符号32位整数类型（注意：原图中描述为typedef int LONG，而非typedef unsigned int LONG）。
typedef unsigned int ULONG; //—— 定义了ULONG为无符号32位整数类型。
typedef unsigned int FLAGS; //—— 定义了FLAGS为无符号32位整数类型，通常用作标志位。
typedef CHAR * LPSTR; //—— 定义了LPSTR为8位字符串指针，字符串按照UTF-8格式存储及交换。
typedef void * HANDLE; //—— 定义了HANDLE为句柄类型，指向任意数据对象的起始地址。
// Error Code

typedef struct ECCrefPublicKey_st
{
ULONG bits; // 公钥的位数
BYTE x[ECCref_MAX_LEN]; // 公钥点的x坐标
BYTE y[ECCref_MAX_LEN]; // 公钥点的y坐标
} ECCrefPublicKey;
#define SDR_OK 0x0 //操作成功

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

/*
功能：打开密码设备。
参数∶
phDeviceHandle[out] 返回设备句柄

返回值∶
0 成功
非0 失败，返回错误代码
*/
int SDF_OpenDevice(void ** phDeviceHandle);

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

/*

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

/*
功能：获取指定长度的随机数
参数：
uiLength[in] 欲获取的随机数长度
pucRandom[ out] 缓冲区指针，用于存放获取的随机数
返回值∶
00（SDR_OK） 成功
非0 失败，返回错误代码
*/
int SDF_GenerateRandom (void * hSessionHandle, unsigned int uiLength, unsigned char * pucRandom);
int SDF_HashInit(
void *hSessionHandle,
unsigned int uiAlgID,
ECCrefPublicKey *pucPublicKey,
unsigned char *pucID,
unsigned int uiIDLength);

int SDF_HashUpdate(
void *hSessionHandle,
unsigned char *pucData,
unsigned int uiDataLength);

int SDF_HashFinal(void *hSessionHandle,
unsigned char *pucHash,
unsigned int *puiHashLength);
int SDF_OpenSession(
void *hDeviceHandle,
void **phSessionHandle);

int SDF_CloseSession(
void *hSessionHandle);
#endif
SDF.c
#include “sdf.h”
#include <string.h>
#include <stdio.h>
#include <time.h>
#include <stdlib.h>
#include <gmssl/mem.h>
#include <gmssl/sm2.h>
#include <gmssl/sm3.h>
#include <gmssl/sm4_cbc_mac.h>
#include <gmssl/rand.h>
#include <gmssl/error.h>
#define SDR_GMSSLERR (SDR_BASE + 0x00000100)

static const uint8_t zeros[ECCref_MAX_LEN - 32] = {0};

#define SOFTSDF_MAX_KEY_SIZE 64

struct SOFTSDF_KEY {
uint8_t key[SOFTSDF_MAX_KEY_SIZE];
size_t key_size;
struct SOFTSDF_KEY *next;
};

typedef struct SOFTSDF_KEY SOFTSDF_KEY;

struct SOFTSDF_CONTAINER {
unsigned int key_index;
SM2_KEY sign_key;
SM2_KEY enc_key;
struct SOFTSDF_CONTAINER *next;
};
typedef struct SOFTSDF_CONTAINER SOFTSDF_CONTAINER;

struct SOFTSDF_SESSION {
SOFTSDF_CONTAINER *container_list;
SOFTSDF_KEY *key_list;
SM3_CTX sm3_ctx;
struct SOFTSDF_SESSION *next;
};
typedef struct SOFTSDF_SESSION SOFTSDF_SESSION;

struct SOFTSDF_DEVICE {
SOFTSDF_SESSION *session_list;
};
typedef struct SOFTSDF_DEVICE SOFTSDF_DEVICE;

SOFTSDF_DEVICE *deviceHandle = NULL;

#define FILENAME_MAX_LEN 256

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

int SDF_OpenDevice(
void **phDeviceHandle)
{
if (phDeviceHandle == NULL) {
error_print();
return SDR_INARGERR;
}

if (deviceHandle != NULL) {
    error_print();
    return SDR_OPENDEVICE;
}

deviceHandle = (SOFTSDF_DEVICE *)malloc(sizeof(SOFTSDF_DEVICE));
if (deviceHandle == NULL) {
    error_print();
    return SDR_OPENDEVICE;
}
memset(deviceHandle, 0, sizeof(SOFTSDF_DEVICE));

*phDeviceHandle = deviceHandle;
return SDR_OK;

}

int SDF_CloseDevice(
void *hDeviceHandle)
{
if (hDeviceHandle != deviceHandle) {
error_print();
return SDR_INARGERR;
}

if (deviceHandle != NULL) {
    while (deviceHandle->session_list) {
        if (SDF_CloseSession(deviceHandle->session_list) != SDR_OK) {
            error_print();
        }
    }
}

memset(deviceHandle, 0, sizeof(SOFTSDF_DEVICE));
free(deviceHandle);
deviceHandle = NULL;

return SDR_OK;

}

int SDF_OpenSession(
void *hDeviceHandle,
void **phSessionHandle)
{
SOFTSDF_SESSION *session;
if (hDeviceHandle == NULL || hDeviceHandle != deviceHandle) {
error_print();
return SDR_INARGERR;
}
if (phSessionHandle == NULL) {
error_print();
return SDR_INARGERR;
}
if (!(session = (SOFTSDF_SESSION *)malloc(sizeof(*session)))) {
error_print();
return SDR_GMSSLERR;
}
memset(session, 0, sizeof(*session));
// append session to session_list
if (deviceHandle->session_list == NULL) {
deviceHandle->session_list = session;
} else {
SOFTSDF_SESSION *current = deviceHandle->session_list;
while (current->next != NULL) {
current = current->next;
}
current->next = session;
}
*phSessionHandle = session;
return SDR_OK;
}

int SDF_CloseSession(
void *hSessionHandle)
{
SOFTSDF_SESSION *current_session;
SOFTSDF_SESSION *prev_session;
SOFTSDF_CONTAINER *current_container;
SOFTSDF_CONTAINER *next_container;
SOFTSDF_KEY *current_key;
SOFTSDF_KEY *next_key;
if (deviceHandle == NULL) {
error_print();
return SDR_INARGERR;
}
if (hSessionHandle == NULL) {
error_print();
return SDR_INARGERR;
}
// find hSessionHandle in session_list
current_session = deviceHandle->session_list;
prev_session = NULL;
while (current_session != NULL && current_session != hSessionHandle) {
prev_session = current_session;
current_session = current_session->next;
}
if (current_session == NULL) {
error_print();
return SDR_INARGERR;
}
// free container_list
current_container = current_session->container_list;
while (current_container != NULL) {
next_container = current_container->next;
memset(current_container, 0, sizeof(*current_container));
free(current_container);
current_container = next_container;
}
// free key_list
current_key = current_session->key_list;
while (current_key != NULL) {
next_key = current_key->next;
memset(current_key, 0, sizeof(*current_key));
free(current_key);
current_key = next_key;
}
// delete current_session from session_list
if (prev_session == NULL) {
deviceHandle->session_list = current_session->next;
} else {
prev_session->next = current_session->next;
}
memset(current_session, 0, sizeof(*current_session));
free(current_session);
return SDR_OK;
}

int SDF_GetDeviceInfo( void * hSessionHandle, DEVICEINFO * pstDeviceInfo) {
SOFTSDF_SESSION *session;
if (deviceHandle == NULL) {
error_print();
return SDR_STEPERR;
}
if (hSessionHandle == NULL) {
error_print();
return SDR_INARGERR;
}
session = deviceHandle->session_list;
while (session != NULL && session != hSessionHandle) {
session = session->next;
}
if (pstDeviceInfo == NULL) {
error_print();
return SDR_INARGERR;
}
memset(pstDeviceInfo, 0, sizeof(*pstDeviceInfo));
strncpy((char *)pstDeviceInfo->IssuerName, “RocSDF”,
sizeof(pstDeviceInfo->IssuerName));
strncpy((char *)pstDeviceInfo->DeviceName, “SDFBESTI181x”,
sizeof(pstDeviceInfo->DeviceName));
strncpy((char *)pstDeviceInfo->DeviceSerial, “2021040001”,
sizeof(pstDeviceInfo->DeviceSerial));
pstDeviceInfo->DeviceVersion=1;
return SDR_OK;
}

static int myRandom(){
srand((unsigned)time(NULL));
return rand();
}

int SDF_GenerateRandom (void * hSessionHandle, unsigned int uiLength, unsigned char * pucRandom){
for(int i=0; i<uiLength; i++){
sleep(2);
*(pucRandom+i) = myRandom();
// pucRandom[i] = i;
}
return SDR_OK;
}

int SDF_HashInit(
void *hSessionHandle,
unsigned int uiAlgID,
ECCrefPublicKey *pucPublicKey,
unsigned char *pucID,
unsigned int uiIDLength)
{
SOFTSDF_SESSION *session;
if (deviceHandle == NULL) {
error_print();
return SDR_STEPERR;
}
if (hSessionHandle == NULL) {
error_print();
return SDR_INARGERR;
}
session = deviceHandle->session_list;
while (session != NULL && session != hSessionHandle) {
session = session->next;
}
if (session == NULL) {
error_print();
return SDR_INARGERR;
}
if (uiAlgID != SGD_SM3) {
error_print();
return SDR_INARGERR;
}
// FIXME: check step or return SDR_STEPERR;
sm3_init(&session->sm3_ctx);
if (pucPublicKey != NULL) {
SM2_POINT point;
SM2_Z256_POINT public_key;
uint8_t z[32];
if (pucID == NULL || uiIDLength <= 0) {
error_print();
return SDR_INARGERR;
}
memset(&point, 0, sizeof(point));
memcpy(point.x, pucPublicKey->x + ECCref_MAX_LEN - 32, 32);
memcpy(point.y, pucPublicKey->y + ECCref_MAX_LEN - 32, 32);
if (sm2_z256_point_from_bytes(&public_key, (uint8_t *)&point) != 1) {
error_print();
return SDR_INARGERR;
}
if (sm2_compute_z(z, &public_key, (const char *)pucID, uiIDLength) != 1) {
error_print();
return SDR_GMSSLERR;
}
sm3_update(&session->sm3_ctx, z, sizeof(z));
}
return SDR_OK;
}

int SDF_HashUpdate(
void *hSessionHandle,
unsigned char *pucData,
unsigned int uiDataLength)
{
SOFTSDF_SESSION *session;
if (deviceHandle == NULL) {
error_print();
return SDR_STEPERR;
}
if (hSessionHandle == NULL) {
error_print();
return SDR_INARGERR;
}
session = deviceHandle->session_list;
while (session != NULL && session != hSessionHandle) {
session = session->next;
}
if (session == NULL) {
error_print();
return SDR_INARGERR;
}
if (pucData == NULL || uiDataLength <= 0) {
error_print();
return SDR_INARGERR;
}
sm3_update(&session->sm3_ctx, pucData, uiDataLength);
return SDR_OK;
}

int SDF_HashFinal(void *hSessionHandle,
unsigned char *pucHash,
unsigned int *puiHashLength)
{
SOFTSDF_SESSION *session;
if (deviceHandle == NULL) {
error_print();
return SDR_STEPERR;
}
if (hSessionHandle == NULL) {
error_print();
return SDR_INARGERR;
}
session = deviceHandle->session_list;
while (session != NULL && session != hSessionHandle) {
session = session->next;
}
if (session == NULL) {
error_print();
return SDR_INARGERR;
}
if (pucHash == NULL || puiHashLength == NULL) {
error_print();
return SDR_INARGERR;
}
sm3_finish(&session->sm3_ctx, pucHash);
*puiHashLength = SM3_DIGEST_SIZE;
return SDR_OK;
}
hash.c
#include<stdio.h>
#include <string.h>
#include"sdf.h"
#include<pthread.h>
#include<sys/time.h>
#include<sys/types.h>
#include <gmssl/sm3.h>
#include <stdlib.h>
#define ROOTKEY “\x01\x02\x03\x04\x05\x06\x07\x08\x09\x0A\x0B\x0C\x0D\x0E\x0F\x10”
#define DEVSN “hs_0000000000001”
#define MAX (4000)

int SM3(unsigned char* data, unsigned char* hash, unsigned int* hash_len){
HANDLE phDeviceHandle;
HANDLE phSessionHandle;
int rv = SDF_OpenDevice(&phDeviceHandle);
if(rv != SDR_OK)
{
printf(“open devces fail\n”);
return 1;
}
printf(“open device success!\n”);
rv = SDF_OpenSession(phDeviceHandle, &phSessionHandle);
if(rv != SDR_OK)
{
SDF_CloseDevice(phDeviceHandle);
printf(“open session fail\n”);
return 1;
}
printf(“open session success!\n”);
rv = SDF_HashInit(phSessionHandle,SGD_SM3,NULL,NULL,0);
if(SDR_OK != rv)
{
return rv;
}
rv = SDF_HashUpdate(phSessionHandle,data, strlen(data));
if(SDR_OK != rv)
{
return rv;
}
rv = SDF_HashFinal(phSessionHandle,hash,hash_len);
if(SDR_OK != rv)
{
printf(“3 %d \n”, rv);
return rv;
}
if(rv != SDR_OK)
{
printf(“SGD_SM3Hash fail\n”);
SDF_CloseSession(phSessionHandle);
SDF_CloseDevice(phDeviceHandle);
return 1;
}
printf(“SGD_SM3Hash success\n”);
SDF_CloseSession(phSessionHandle);
SDF_CloseDevice(phDeviceHandle);
return 0;
}
//#define MAX (1536)

int main(int argc, char *argv[])
{
unsigned char * text = “Hello”;
unsigned char hash[256];
unsigned int len = 32;
int rv = 0;
rv = SM3(text, hash, &len);
if(rv != 0){
printf(“Error SM3”);
}
for(int i = 0; i < len; i++){
printf(“%02x”, hash[i]);
}
printf(“\n”);
printf(“Use GmSSL to Check Hash:\n”);
unsigned char sm3hash[256];
SM3_CTX ctx;
sm3_init(&ctx); // Initialize the hash context
sm3_update(&ctx, text, strlen(text)); // Hash the data
sm3_finish(&ctx, sm3hash); // Finalize the hash
printf(“SM3 hash: “);
for (int i = 0; i < SM3_DIGEST_SIZE; i++) {
printf(”%02x”, sm3hash[i]);
}
printf(“\n”);
int result = strcmp(hash, sm3hash);
if (result == 0){
printf(“Check ok\n”);
}else{
printf(“Check error\n”);
}
return 0;
}
运行结果
$ ./hash
open device success!
open session success!
pOutRand:
42bd80f3 35a028d2 c7a1fadc 130a7b99
SDF_GenerateRandom success!
SN:hs_00000000000014209�
CosVer: 4.2.09
open device success!
open session success!
SGD_SM3Hash success
dc74f051ad5bc19ba721bf0023e10de03bae29bbe013c43988bae55828bcebbc
Use GmSSL to Check Hash:
SM3 hash: dc74f051ad5bc19ba721bf0023e10de03bae29bbe013c43988bae55828bcebbc
Check ok
git log
commit 1e685d383458f950ae588d92794e227a87653c86 (HEAD -> master)
Author: zhanhe lzj@outlook.com
Date: Tue Nov 26 22:18:02 2024 +0800
test

commit 14fbf0b15c9d014088a96052766633e3858e4645
Author: zhanhe lzj@outlook.com
Date: Tue Nov 26 22:17:20 2024 +0800
sdf

commit a76cfd0338ac6e38769677966c632cd03051746c
Author: zhanhe lzj@outlook.com
Date: Tue Nov 26 21:06:25 2024 +0800
sm3
提交要求：
提交实践过程Markdown和转化的PDF文件
代码，文档托管到gitee或github等，推荐 gitclone
记录实验过程中遇到的问题，解决过程，反思等内容，完成实验报告相关内容

m0_73622182
关注
[密码学实战]在Linux中实现SDF密码设备接口（二十五）
曼岛_的博客
04-24 752
通过本文的实战指导，开发者可以快速搭建符合国密标准的SDF开发测试环境。SoftSDF作为连接上层应用与底层密码服务的桥梁，为金融安全、物联网等场景提供了便捷的密码服务集成方案。结合HSM硬件实现混合安全架构开发基于SDF接口的SSL/TLS中间件构建国密证书签发系统技术交流：欢迎在评论区留言讨论部署过程中遇到的问题，共同探讨密码技术实践！附录GmSSL官方文档。
SM3算法预处理和非预处理的调用（0018规范接口）
lingdukafeibj的博客
03-01 2053
目前测试密码机按照国标规定的杂凑运算多步运算： rv= SDF_HashInit(hSessionHandle,SGD_SM3,&ECC_PubKey,ID,sizeof (ID)); rv=SDF_HashUpdate(hSessionHandle,plain,sizeof (plain)); rv = SDF_HashFinal(hSessionHandle,hashResult,&hashResultLength); 1、非预处理模式此时可以将HashInit的后面...
算法介绍-SM3及摘要算法（签名算法）国际SHA-256
折翼的青鸟
09-19 3726
摘要函数在密码学中具有重要的地位,被广泛应用在数字签名,消息认证,数据完整性检测等领域。碰撞稳固性,原根稳固性和第二原根稳固性。SM3算法适用于商用密码应用中的数字签名和验证，是在SHA-256基础上改进实现的一种算法。SM3算法采用Merkle-Damgard结构，消息分组长度为512位，摘要值长度为256位。SM3算法的压缩函数与SHA-256的压缩函数具有相似的结构,但是SM3算法的设计更加复杂,比如压缩函数的每一轮都使用2个消息字。现今为止，SM3算法的安全性相对较高。
终于解决了！！！ 基于GmSSL的SM2签名算法及思路分享
点滴路程
07-12 2672
问题最终得以解决了，似乎看起来也并不困难。其中的酸楚，估计也就只有经历过的人才了解。找到可以验证正确性的方式。本文中就是SM2 在线验签工具确定方向可行后，花心思去研究。比如，我在通过gmssl命令行进行SM2签名、验签通过后，就认为该开源库应该是满足要求的。对于不了解的内容，遇到困难不要轻言放弃，转换思路，投机取巧。希望我的经验能够帮助你。若我的内容对您有所帮助，还请关注我的公众号。不定期分享干活,剖析案例，也可以一起讨论分享。踩完您工作中的所有坑并分享给您，让你的工作无bug，人生尽是坦途。
SM3加密算法详解（2021-12-8）
热门推荐
qq_40662424的博客
12-01 6万+
原文作者链接：https://zhuanlan.zhihu.com/p/129692191 国密局官方文档：http://www.sca.gov.cn/sca/xwdt/2010-12/17/content_1002389.shtml 整个算法的执行过程可以概括成四个步骤：消息填充、消息扩展、迭代压缩、输出结果。 文章目录SM3概述消息填充消息扩展迭代压缩输出结果 SM3概述 SM3密码杂凑算法是中国国家密码管理局2010年公布的中国商用密码杂凑算法标准。具体算法标准原始文本参见参考文献[1]。该算法于.
国密算法SM2、SM3的使用
weixin_48568302的博客
05-31 2万+
一、SM2、SM3介绍： 1. SM2是非对称加密算法 它是基于椭圆曲线密码的公钥密码算法标准，其秘钥长度256bit，包含数字签名、密钥交换和公钥加密，用于替换RSA/DH/ECDSA/ECDH等国际算法。可以满足电子认证服务系统等应用需求，由国家密码管理局于2010年12月17号发布。 2.SM3是一种密码杂凑算法 用于替代MD5/SHA-1/SHA-2等国际算法，适用于数字签名和验证、消息认证码的生成与验证以及随机数的生成，可以满足电子认证服务系统等应用需求，于...
c#实现无标题栏窗口的拖动
09-05
本篇文章将详细讲解如何在C#中实现这种无标题栏窗口的拖动以及其他基本操作。 首先，为了实现无标题栏窗口的拖动，我们需要处理窗体的鼠标事件。窗体的`FormBorderStyle`属性应设置为`None`，这会去除窗体的边框和...
Qt无标题窗口
05-21
在本文中，我们将深入探讨如何使用Qt框架创建一个无标题窗口，这在界面设计和自定义标题栏美化中非常有用。我们将关注`framelesswidget.cpp`、`main.cpp`、`framelesswidget.h`等核心文件，理解它们在实现无标题窗口...
C#创建无标题栏窗体
03-16
摘要:C#源码,菜单窗体,无标题栏窗体　C#创建无标题栏窗体源码，实际上是动态显示或隐藏窗体的标题栏，当隐藏的时候就类似窗体没有了标题栏，当显示标题栏的时候，鼠标按住标题栏即可拖动窗体，以前记得网友需要此...
Delphi实现拖动按钮移动无标题栏窗口
05-11
摘要:Delphi源码,界面编程,窗体拖动,无标题栏 无标题栏的窗体的拖动功能实现，Delphi添加一个可拖动窗体的按钮，通过对此按钮的控制可移动窗体，实现按住标题栏移动窗口的功能，无标题栏也就不能显示最大化、最小化...
GMT0018-2012密码设备应用接口规范
05-18
GMT0018-2012密码设备应用接口规范
SM3动态链接库
12-23
SM3算法源码及动态链接库文件。动态链接库文件中含DLL、LIB、H文件
VC去掉'无标题'字样的方法.zip
11-21
在使用Visual C++进行编程时，我们经常会在创建新的窗口或者对话框时默认看到标题栏显示为“无标题”。这可能会对用户界面的美观性和专业性造成一定的影响。本资料包提供了一种方法来帮助开发者去掉这个“无标题”...
SM2算法的加密签名消息语法规范（四）如何构造envelopedData
lt4959的专栏
01-13 3714
前面的文章中已经介绍了国密规范中的数字信封数据envelopedData类型。接下来讲一下怎么构造出这种类型的数据~~\（￣︶￣）/ 1、构造流程 根据RFC规范，在结合GM/T 0010规范的要求，构造数字信封数据的过程如下: a. 产生一个对应于特定加密算法的内容加密密钥(即会话密钥或对称密钥); b. 将内容加密密钥用每个接收者的公钥加密。（算法为：sm2-3 公钥加密算法 OID：1.2.156.10197.1.301.3） c. 对于每一个接收者，把加了密...
调试代码快速定位到出错位置
阿乐的博客
01-19 481
#define ERROR_MSG(format, ...) \ fprintf(stderr, "Fi:%s Func:%s Line:%d " format, __FILE__, __FUNCTION__,__LINE__, ##__VA_ARGS__) #define DEBUG_MSG(format, ...) \ fprintf(stdout, format, ##__VA_ARGS__) 用法: rv = SKF_DigestInit(data->hDev, S
sm3常量及通用函数
创忆的专栏
06-12 678
在实现sm3算法之前，根据上述章节《sm3算法基本原理》以及sm3的规范文档，可以事先定义好一些常量及通用函数备用。先在Clion中创建sm3.h和sm3.c这两个文件。
国密哈希hash算法SM3原理分析
m0_37799284的博客
08-12 2459
无限制512bit32bit4128bit。
速下载 | 密评密改实施、移动新场景等25项密码新标准全文来了
最新发布
Chaincomp的博客
08-16 1138
本文件适用于密码设备、密码系统的研制和使用过程中对标识进行规范化的使用，也适用于其他相关标准、协议的编制中对标识的使用。本文件适用于公钥密码应用技术体系下密码应用服务产品的开发，密码应用支撑平台的研制及检测，也可用于指导直接使用密码设备和密码服务的应用系统的集成和开发。本文件规定了SSH的安全交互密码协议，规定了交互通道的加密传输协议、鉴别协议与连接协议，规定了密码算法在协议中的使用方法。本文件规定了公钥密码体制下的智能密码钥匙应用接口标准、密码相关应用接口的函数、数据类型、参数的定义和设备的安全要求。
Qt自定义无标题窗口实现与界面美化技巧
以上就是从给定文件信息中提取的相关知识点，对于想要创建和使用Qt无标题窗口的开发者来说，这些知识点不仅能够帮助他们理解无标题窗口的实现原理和方法，还能够指导他们如何管理Qt项目文件以及如何使用版本控制系统...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值