sdf 测试-2-openssl

修改之后

#include "sdf.h"
#include <stdio.h>
#include <stdlib.h>
#include <string.h> // For strlen

int main() {
    void *phDeviceHandle = NULL;  // Use a single pointer, not a double pointer
    int ret;

    // Open device
    ret = SDF_OpenDevice(&phDeviceHandle);
    if (ret != SDR_OK) {
        printf("Error opening device!\n");
        return -1;
    } else {
        printf("Device opened successfully!\n");
    }

    // Get device info
    DEVICEINFO testdi;
    ret = SDF_GetDeviceInfo(phDeviceHandle, &testdi);
    if (ret != SDR_OK) {
        printf("Error retrieving device info!\n");
    } else {
        printf("Issuer Name: %s\n", testdi.IssuerName);
        printf("Device Name: %s\n", testdi.DeviceName);
        printf("Device Serial: %s\n", testdi.DeviceSerial);
        printf("Device Version: %d\n", testdi.DeviceVersion);
    }

    // Generate random data
    unsigned char pRandom[10];
    ret = SDF_GenerateRandom(phDeviceHandle, 10, pRandom);
    if (ret != SDR_OK) {
        printf("Error generating random data!\n");
    } else {
        printf("Random Data:\n");
        for (int i = 0; i < 10; i++) {
            printf("%d ", pRandom[i]);
        }
        printf("\n");
    }

    // Hash data
    unsigned char hashResult[32]; // SM3 produces a 32-byte hash
    const char *data = "20211211hyj";
    ret = SDF_Hash(phDeviceHandle, SGD_SM3, (unsigned char*)data, strlen(data), hashResult);
    if (ret != SDR_OK) {
        printf("Error hashing data!\n");
    } else {
        printf("Hash of '%s':\n", data);
        for (int i = 0; i < 32; i++) {
            printf("%02x", hashResult[i]);
        }
        printf("\n");
    }

    // Close device
    ret = SDF_CloseDevice(phDeviceHandle);
    if (ret != SDR_OK) {
        printf("Error closing device!\n");
    } else {
        printf("Device closed successfully!\n");
    }

    return 0;
}

原本的main函数

#include "sdf.h"
#include <stdio.h>
#include <stdlib.h>

int main(){

    void ** pdh;
	pdh = (void **) malloc(20);
	int ret;

    ret = SDF_OpenDevice(pdh);
	if(ret != SDR_OK){
        printf("error!");
	} else {
		printf("device opened!\n");
	}

    DEVICEINFO testdi;
    ret = SDF_GetDeviceInfo(pdh, &testdi);
	if(ret != SDR_OK){
        printf("error!");
	} else {
        printf("Issuer Name: %s\n", testdi.IssuerName);
        printf("Device Name: %s\n", testdi.DeviceName);
        printf("Device Serial: %s\n", testdi.DeviceSerial);
        printf("Device Version: %d\n", testdi.DeviceVersion);
		
	}

    char pRandom[10];

    ret = SDF_GenerateRandom(*pdh,10, pRandom);
	if(ret != SDR_OK){
        printf("error!");
	} else {
        for(int i=0; i<10; i++)
            printf("%d\n", pRandom[i]);
	}


    ret = SDF_CloseDevice(*pdh);
	
	if(ret != SDR_OK){
        printf("error!");
	} else {
		free(pdh);
		printf("device closed!\n");
	}
    const char *data = "20211211hyj";
    SDF_Hash(*pdh,data, strlen(data));
    return 0;
	return 0;
}

./compile.sh
/usr/bin/ld: /tmp/cciOBDmY.o: in function `Hash_SM3':
sdf.c:(.text+0x326): undefined reference to `EVP_MD_CTX_new'
/usr/bin/ld: sdf.c:(.text+0x32f): undefined reference to `EVP_sm3'
/usr/bin/ld: sdf.c:(.text+0x34b): undefined reference to `EVP_DigestInit_ex'
/usr/bin/ld: sdf.c:(.text+0x362): undefined reference to `EVP_DigestUpdate'
/usr/bin/ld: sdf.c:(.text+0x379): undefined reference to `EVP_DigestFinal_ex'
/usr/bin/ld: sdf.c:(.text+0x385): undefined reference to `EVP_MD_CTX_free'
collect2: error: ld returned 1 exit status
./compile.sh: 行 2: bin/20211211sm3: 没有那个文件或目录

src/sdf.c:111:20: error: ‘SGD_SM3’ undeclared (first use in this function)
  111 |     if (uiAlgID == SGD_SM3) {
      |                    ^~~~~~~

改正
// 加密算法标识符

define SGD_SM3 0x0000012 // 或其他适当的值，通常根据实际应用的加密算法ID定义

在openEuler(推荐)或Ubuntu或Windows(不推荐)中完成下面任务,参考网内容 和AI要给出详细过程，否则不得分。
0. 根据gmt0018标准，如何调用接口实现基于SM3求你的学号姓名的SM3值？（5‘）

1. 使用OpenSSL实现SDF接口中的hash运算接口，至少支持SM3算法，把相关函数集成到src中的sdf.c中中（5'）
2. 在test中的main.c调用进行测试，至少测试计算你的学号（数字），你的学号（字符串）的SM3值。（5‘）
3. 提交代码（或代码链接）和运行结果截图

#include <stdio.h>
#include <string.h>
#include <openssl/evp.h>

void calculate_sm3(const char *data, size_t data_len) {
    EVP_MD_CTX *mdctx;
    const EVP_MD *md;
    unsigned char md_value[EVP_MAX_MD_SIZE];
    unsigned int md_len, i;

    // 创建和初始化摘要上下文
    mdctx = EVP_MD_CTX_new();
    md = EVP_sm3();

    // 初始化摘要运算
    EVP_DigestInit_ex(mdctx, md, NULL);

    // 提供数据
    EVP_DigestUpdate(mdctx, data, data_len);

    // 获取最终的摘要
    EVP_DigestFinal_ex(mdctx, md_value, &md_len);

    // 打印摘要
    printf("Digest is: ");
    for (i = 0; i < md_len; i++) {
        printf("%02x", md_value[i]);
    }
    printf("\n");

    // 清理
    EVP_MD_CTX_free(mdctx);
}

int main() {
    const char *data = "20211211hyj";
    calculate_sm3(data, strlen(data));
    return 0;
}

#include <openssl/evp.h> 
// 新增SM3哈希运算函数
static int Hash_SM3(const unsigned char *message, size_t message_len, unsigned char *digest) {
    EVP_MD_CTX *mdctx;
    const EVP_MD *md;
    unsigned int digest_len;

    mdctx = EVP_MD_CTX_new();
    md = EVP_sm3();
    EVP_DigestInit_ex(mdctx, md, NULL);
    EVP_DigestUpdate(mdctx, message, message_len);
    EVP_DigestFinal_ex(mdctx, digest, &digest_len);
    EVP_MD_CTX_free(mdctx);

    return digest_len ? SDR_OK : SDF_ERROR;  // 如果哈希成功，返回SDR_OK
}

// 通过SDF接口调用SM3哈希运算
int SDF_Hash(void *hSessionHandle, unsigned int uiAlgID, unsigned char *pucData, unsigned int uiDataLength, unsigned char *pucHash) {
    if (uiAlgID == SGD_SM3) {
        return Hash_SM3(pucData, uiDataLength, pucHash);
    }
    return SDF_ERROR;
}