SM3算法 C语言 (从OpenSSL库中分离算法:六)

最新推荐文章于 2024-06-21 15:21:37 发布
最新推荐文章于 2024-06-21 15:21:37 发布
阅读量5.2k 收藏 19
点赞数 7
分类专栏： 加解密 文章标签： c语言 c++ 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u010333084/article/details/121360510
版权

SM3算法 C语言 (从OpenSSL库中分离算法:六)

OpenSSL简介：

OpenSSL 是用于传输层安全性 (TLS) 和安全套接字层 (SSL) 协议的一个强大、商业级和功能齐全的工具包，它也是一个通用的密码学库。包含有RSA、SM4、DES、AES等诸多加密算法。

OpenSSL GitHub地址如下：

GitHub - openssl/openssl: TLS/SSL and crypto library

在日常的开发工作中，有时只想用OpenSSL库中的一种算法，此时调用整个OpenSSL库，往往是没必要的；再或者在嵌入式平台使用某一算法，那我们只移植这个算法，没有必要移植整个OpenSSL库。

SM3简介

SM3是我国采用的一种密码散列函数标准，由国家密码管理局于2010年12月17日发布。相关标准为“GM/T 0004-2012 《SM3密码杂凑算法》”。它可以将任意长度的消息压缩成固定长度的摘要,主要用于数字签名和数据完整性保护等

在商用密码体系中，SM3主要用于数字签名及验证、消息认证码生成及验证、随机数生成等，其算法公开。据国家密码管理局表示，其安全性及效率与SHA-256相当。

移植过程

一、下载代码

从OpenSSL的Github仓库下载代码，可以下载master分支，也可以下载最新的release版本。将下载的文件解压，得到代码。

重点关注红框目录：

  • crypto目录内是各种加密算法
  • include目录内是各加密算法对外接口的头文件

在这里插入图片描述

二、准备环境

新建Visual Studio C++ 控制台项目"sm3test"，编译选项是：x86\Debug

在这里插入图片描述
在这里插入图片描述

三、准备文件

  1. 复制OpenSSL源码中：/crypto/sm3文件夹到VS工程代码目录下
  2. 复制OpenSSL源码中：/include/internal/sm3.h文件到VS工程代码目录中sm3文件夹内
  3. 复制OpenSSL源码中：/include/crypto/md32_common.h文件到VS工程代码目录中sm3文件夹内
  4. 复制完成后，VS工程代码目录sm3文件夹内文件如下：

在这里插入图片描述
删除目录内的如下本项目中无用文件：

  • build.info
  • legacy_sm3.c

四、修改代码

修改调用文件

在VS工程中含有main函数的主文件:sm3test.cpp中，增加包含sm3.h头文件

#include "sm3/sm3.h"

在main函数中添加如下代码

SM3_CTX SMC;
    ossl_sm3_init(&SMC);

    const unsigned char Data[1024] = "Hello World";
    unsigned char md[SM3_DIGEST_LENGTH] = { 0 };

    ossl_sm3_update(&SMC, Data, strlen((const char *) Data));
    ossl_sm3_final(md, &SMC);

    for (int i = 0; i < SM3_DIGEST_LENGTH; i++) {
        printf("%02x-", *(md + i));
    }

修改后的sm3test.cpp代码如下：

#include <iostream>
#include "sm3/sm3.h"
int main()
{
    SM3_CTX SMC;
    ossl_sm3_init(&SMC);

    const unsigned char Data[1024] = "Hello World";
    unsigned char md[SM3_DIGEST_LENGTH] = { 0 };

    ossl_sm3_update(&SMC, Data, strlen((const char *) Data));
    ossl_sm3_final(md, &SMC);

    for (int i = 0; i < SM3_DIGEST_LENGTH; i++) {
        printf("%02x-", *(md + i));
    }
}
修改sm3.h

删除条件编译 OPENSSL_SM3_H

删除头文件# include <openssl/opensslconf.h>

删除条件编译 OPENSSL_NO_SM3

添加C++调用时的宏

修改或删除后的文件如下：

# pragma once
#  ifdef  __cplusplus
extern "C" {
#  endif

# define SM3_DIGEST_LENGTH 32
# define SM3_WORD unsigned int

# define SM3_CBLOCK      64
# define SM3_LBLOCK      (SM3_CBLOCK/4)

typedef struct SM3state_st {
	SM3_WORD A, B, C, D, E, F, G, H;
	SM3_WORD Nl, Nh;
	SM3_WORD data[SM3_LBLOCK];
	unsigned int num;
} SM3_CTX;

int ossl_sm3_init(SM3_CTX* c);
int ossl_sm3_update(SM3_CTX* c, const void* data, size_t len);
int ossl_sm3_final(unsigned char* md, SM3_CTX* c);

#  ifdef  __cplusplus
}
#  endif
修改sm3_local.h

修改头文件# include "internal/sm3.h"改为#include "sm3.h"

修改头文件# include "crypto/md32_common.h"改为#include "md32_common.h"

修改或删除后的文件如下：


#include <string.h>
#include "sm3.h"

#define DATA_ORDER_IS_BIG_ENDIAN

#define HASH_LONG               SM3_WORD
#define HASH_CTX                SM3_CTX
#define HASH_CBLOCK             SM3_CBLOCK
#define HASH_UPDATE             ossl_sm3_update
#define HASH_TRANSFORM          ossl_sm3_transform
#define HASH_FINAL              ossl_sm3_final
#define HASH_MAKE_STRING(c, s)              \
      do {                                  \
        unsigned long ll;                   \
        ll=(c)->A; (void)HOST_l2c(ll, (s)); \
        ll=(c)->B; (void)HOST_l2c(ll, (s)); \
        ll=(c)->C; (void)HOST_l2c(ll, (s)); \
        ll=(c)->D; (void)HOST_l2c(ll, (s)); \
        ll=(c)->E; (void)HOST_l2c(ll, (s)); \
        ll=(c)->F; (void)HOST_l2c(ll, (s)); \
        ll=(c)->G; (void)HOST_l2c(ll, (s)); \
        ll=(c)->H; (void)HOST_l2c(ll, (s)); \
      } while (0)
#define HASH_BLOCK_DATA_ORDER   ossl_sm3_block_data_order

void ossl_sm3_block_data_order(SM3_CTX *c, const void *p, size_t num);
void ossl_sm3_transform(SM3_CTX *c, const unsigned char *data);

#include "md32_common.h"

#define P0(X) (X ^ ROTATE(X, 9) ^ ROTATE(X, 17))
#define P1(X) (X ^ ROTATE(X, 15) ^ ROTATE(X, 23))

#define FF0(X,Y,Z) (X ^ Y ^ Z)
#define GG0(X,Y,Z) (X ^ Y ^ Z)

#define FF1(X,Y,Z) ((X & Y) | ((X | Y) & Z))
#define GG1(X,Y,Z) ((Z ^ (X & (Y ^ Z))))

#define EXPAND(W0,W7,W13,W3,W10) \
   (P1(W0 ^ W7 ^ ROTATE(W13, 15)) ^ ROTATE(W3, 7) ^ W10)

#define RND(A, B, C, D, E, F, G, H, TJ, Wi, Wj, FF, GG)           \
     do {                                                         \
       const SM3_WORD A12 = ROTATE(A, 12);                        \
       const SM3_WORD A12_SM = A12 + E + TJ;                      \
       const SM3_WORD SS1 = ROTATE(A12_SM, 7);                    \
       const SM3_WORD TT1 = FF(A, B, C) + D + (SS1 ^ A12) + (Wj); \
       const SM3_WORD TT2 = GG(E, F, G) + H + SS1 + Wi;           \
       B = ROTATE(B, 9);                                          \
       D = TT1;                                                   \
       F = ROTATE(F, 19);                                         \
       H = P0(TT2);                                               \
     } while(0)

#define R1(A,B,C,D,E,F,G,H,TJ,Wi,Wj) \
   RND(A,B,C,D,E,F,G,H,TJ,Wi,Wj,FF0,GG0)

#define R2(A,B,C,D,E,F,G,H,TJ,Wi,Wj) \
   RND(A,B,C,D,E,F,G,H,TJ,Wi,Wj,FF1,GG1)

#define SM3_A 0x7380166fUL
#define SM3_B 0x4914b2b9UL
#define SM3_C 0x172442d7UL
#define SM3_D 0xda8a0600UL
#define SM3_E 0xa96f30bcUL
#define SM3_F 0x163138aaUL
#define SM3_G 0xe38dee4dUL
#define SM3_H 0xb0fb0e4eUL
修改sm3.c

删除头文件#include <openssl/e_os2.h>

修改或删除后的文件如下：

#include "sm3_local.h"

int ossl_sm3_init(SM3_CTX *c)
{
    memset(c, 0, sizeof(*c));
    c->A = SM3_A;
    c->B = SM3_B;
    c->C = SM3_C;
    c->D = SM3_D;
    c->E = SM3_E;
    c->F = SM3_F;
    c->G = SM3_G;
    c->H = SM3_H;
    return 1;
}

void ossl_sm3_block_data_order(SM3_CTX *ctx, const void *p, size_t num)
{
    const unsigned char *data = p;
    register unsigned MD32_REG_T A, B, C, D, E, F, G, H;

    unsigned MD32_REG_T W00, W01, W02, W03, W04, W05, W06, W07,
        W08, W09, W10, W11, W12, W13, W14, W15;

    for (; num--;) {

        A = ctx->A;
        B = ctx->B;
        C = ctx->C;
        D = ctx->D;
        E = ctx->E;
        F = ctx->F;
        G = ctx->G;
        H = ctx->H;

        /*
        * We have to load all message bytes immediately since SM3 reads
        * them slightly out of order.
        */
        (void)HOST_c2l(data, W00);
        (void)HOST_c2l(data, W01);
        (void)HOST_c2l(data, W02);
        (void)HOST_c2l(data, W03);
        (void)HOST_c2l(data, W04);
        (void)HOST_c2l(data, W05);
        (void)HOST_c2l(data, W06);
        (void)HOST_c2l(data, W07);
        (void)HOST_c2l(data, W08);
        (void)HOST_c2l(data, W09);
        (void)HOST_c2l(data, W10);
        (void)HOST_c2l(data, W11);
        (void)HOST_c2l(data, W12);
        (void)HOST_c2l(data, W13);
        (void)HOST_c2l(data, W14);
        (void)HOST_c2l(data, W15);

        R1(A, B, C, D, E, F, G, H, 0x79CC4519, W00, W00 ^ W04);
        W00 = EXPAND(W00, W07, W13, W03, W10);
        R1(D, A, B, C, H, E, F, G, 0xF3988A32, W01, W01 ^ W05);
        W01 = EXPAND(W01, W08, W14, W04, W11);
        R1(C, D, A, B, G, H, E, F, 0xE7311465, W02, W02 ^ W06);
        W02 = EXPAND(W02, W09, W15, W05, W12);
        R1(B, C, D, A, F, G, H, E, 0xCE6228CB, W03, W03 ^ W07);
        W03 = EXPAND(W03, W10, W00, W06, W13);
        R1(A, B, C, D, E, F, G, H, 0x9CC45197, W04, W04 ^ W08);
        W04 = EXPAND(W04, W11, W01, W07, W14);
        R1(D, A, B, C, H, E, F, G, 0x3988A32F, W05, W05 ^ W09);
        W05 = EXPAND(W05, W12, W02, W08, W15);
        R1(C, D, A, B, G, H, E, F, 0x7311465E, W06, W06 ^ W10);
        W06 = EXPAND(W06, W13, W03, W09, W00);
        R1(B, C, D, A, F, G, H, E, 0xE6228CBC, W07, W07 ^ W11);
        W07 = EXPAND(W07, W14, W04, W10, W01);
        R1(A, B, C, D, E, F, G, H, 0xCC451979, W08, W08 ^ W12);
        W08 = EXPAND(W08, W15, W05, W11, W02);
        R1(D, A, B, C, H, E, F, G, 0x988A32F3, W09, W09 ^ W13);
        W09 = EXPAND(W09, W00, W06, W12, W03);
        R1(C, D, A, B, G, H, E, F, 0x311465E7, W10, W10 ^ W14);
        W10 = EXPAND(W10, W01, W07, W13, W04);
        R1(B, C, D, A, F, G, H, E, 0x6228CBCE, W11, W11 ^ W15);
        W11 = EXPAND(W11, W02, W08, W14, W05);
        R1(A, B, C, D, E, F, G, H, 0xC451979C, W12, W12 ^ W00);
        W12 = EXPAND(W12, W03, W09, W15, W06);
        R1(D, A, B, C, H, E, F, G, 0x88A32F39, W13, W13 ^ W01);
        W13 = EXPAND(W13, W04, W10, W00, W07);
        R1(C, D, A, B, G, H, E, F, 0x11465E73, W14, W14 ^ W02);
        W14 = EXPAND(W14, W05, W11, W01, W08);
        R1(B, C, D, A, F, G, H, E, 0x228CBCE6, W15, W15 ^ W03);
        W15 = EXPAND(W15, W06, W12, W02, W09);
        R2(A, B, C, D, E, F, G, H, 0x9D8A7A87, W00, W00 ^ W04);
        W00 = EXPAND(W00, W07, W13, W03, W10);
        R2(D, A, B, C, H, E, F, G, 0x3B14F50F, W01, W01 ^ W05);
        W01 = EXPAND(W01, W08, W14, W04, W11);
        R2(C, D, A, B, G, H, E, F, 0x7629EA1E, W02, W02 ^ W06);
        W02 = EXPAND(W02, W09, W15, W05, W12);
        R2(B, C, D, A, F, G, H, E, 0xEC53D43C, W03, W03 ^ W07);
        W03 = EXPAND(W03, W10, W00, W06, W13);
        R2(A, B, C, D, E, F, G, H, 0xD8A7A879, W04, W04 ^ W08);
        W04 = EXPAND(W04, W11, W01, W07, W14);
        R2(D, A, B, C, H, E, F, G, 0xB14F50F3, W05, W05 ^ W09);
        W05 = EXPAND(W05, W12, W02, W08, W15);
        R2(C, D, A, B, G, H, E, F, 0x629EA1E7, W06, W06 ^ W10);
        W06 = EXPAND(W06, W13, W03, W09, W00);
        R2(B, C, D, A, F, G, H, E, 0xC53D43CE, W07, W07 ^ W11);
        W07 = EXPAND(W07, W14, W04, W10, W01);
        R2(A, B, C, D, E, F, G, H, 0x8A7A879D, W08, W08 ^ W12);
        W08 = EXPAND(W08, W15, W05, W11, W02);
        R2(D, A, B, C, H, E, F, G, 0x14F50F3B, W09, W09 ^ W13);
        W09 = EXPAND(W09, W00, W06, W12, W03);
        R2(C, D, A, B, G, H, E, F, 0x29EA1E76, W10, W10 ^ W14);
        W10 = EXPAND(W10, W01, W07, W13, W04);
        R2(B, C, D, A, F, G, H, E, 0x53D43CEC, W11, W11 ^ W15);
        W11 = EXPAND(W11, W02, W08, W14, W05);
        R2(A, B, C, D, E, F, G, H, 0xA7A879D8, W12, W12 ^ W00);
        W12 = EXPAND(W12, W03, W09, W15, W06);
        R2(D, A, B, C, H, E, F, G, 0x4F50F3B1, W13, W13 ^ W01);
        W13 = EXPAND(W13, W04, W10, W00, W07);
        R2(C, D, A, B, G, H, E, F, 0x9EA1E762, W14, W14 ^ W02);
        W14 = EXPAND(W14, W05, W11, W01, W08);
        R2(B, C, D, A, F, G, H, E, 0x3D43CEC5, W15, W15 ^ W03);
        W15 = EXPAND(W15, W06, W12, W02, W09);
        R2(A, B, C, D, E, F, G, H, 0x7A879D8A, W00, W00 ^ W04);
        W00 = EXPAND(W00, W07, W13, W03, W10);
        R2(D, A, B, C, H, E, F, G, 0xF50F3B14, W01, W01 ^ W05);
        W01 = EXPAND(W01, W08, W14, W04, W11);
        R2(C, D, A, B, G, H, E, F, 0xEA1E7629, W02, W02 ^ W06);
        W02 = EXPAND(W02, W09, W15, W05, W12);
        R2(B, C, D, A, F, G, H, E, 0xD43CEC53, W03, W03 ^ W07);
        W03 = EXPAND(W03, W10, W00, W06, W13);
        R2(A, B, C, D, E, F, G, H, 0xA879D8A7, W04, W04 ^ W08);
        W04 = EXPAND(W04, W11, W01, W07, W14);
        R2(D, A, B, C, H, E, F, G, 0x50F3B14F, W05, W05 ^ W09);
        W05 = EXPAND(W05, W12, W02, W08, W15);
        R2(C, D, A, B, G, H, E, F, 0xA1E7629E, W06, W06 ^ W10);
        W06 = EXPAND(W06, W13, W03, W09, W00);
        R2(B, C, D, A, F, G, H, E, 0x43CEC53D, W07, W07 ^ W11);
        W07 = EXPAND(W07, W14, W04, W10, W01);
        R2(A, B, C, D, E, F, G, H, 0x879D8A7A, W08, W08 ^ W12);
        W08 = EXPAND(W08, W15, W05, W11, W02);
        R2(D, A, B, C, H, E, F, G, 0x0F3B14F5, W09, W09 ^ W13);
        W09 = EXPAND(W09, W00, W06, W12, W03);
        R2(C, D, A, B, G, H, E, F, 0x1E7629EA, W10, W10 ^ W14);
        W10 = EXPAND(W10, W01, W07, W13, W04);
        R2(B, C, D, A, F, G, H, E, 0x3CEC53D4, W11, W11 ^ W15);
        W11 = EXPAND(W11, W02, W08, W14, W05);
        R2(A, B, C, D, E, F, G, H, 0x79D8A7A8, W12, W12 ^ W00);
        W12 = EXPAND(W12, W03, W09, W15, W06);
        R2(D, A, B, C, H, E, F, G, 0xF3B14F50, W13, W13 ^ W01);
        W13 = EXPAND(W13, W04, W10, W00, W07);
        R2(C, D, A, B, G, H, E, F, 0xE7629EA1, W14, W14 ^ W02);
        W14 = EXPAND(W14, W05, W11, W01, W08);
        R2(B, C, D, A, F, G, H, E, 0xCEC53D43, W15, W15 ^ W03);
        W15 = EXPAND(W15, W06, W12, W02, W09);
        R2(A, B, C, D, E, F, G, H, 0x9D8A7A87, W00, W00 ^ W04);
        W00 = EXPAND(W00, W07, W13, W03, W10);
        R2(D, A, B, C, H, E, F, G, 0x3B14F50F, W01, W01 ^ W05);
        W01 = EXPAND(W01, W08, W14, W04, W11);
        R2(C, D, A, B, G, H, E, F, 0x7629EA1E, W02, W02 ^ W06);
        W02 = EXPAND(W02, W09, W15, W05, W12);
        R2(B, C, D, A, F, G, H, E, 0xEC53D43C, W03, W03 ^ W07);
        W03 = EXPAND(W03, W10, W00, W06, W13);
        R2(A, B, C, D, E, F, G, H, 0xD8A7A879, W04, W04 ^ W08);
        R2(D, A, B, C, H, E, F, G, 0xB14F50F3, W05, W05 ^ W09);
        R2(C, D, A, B, G, H, E, F, 0x629EA1E7, W06, W06 ^ W10);
        R2(B, C, D, A, F, G, H, E, 0xC53D43CE, W07, W07 ^ W11);
        R2(A, B, C, D, E, F, G, H, 0x8A7A879D, W08, W08 ^ W12);
        R2(D, A, B, C, H, E, F, G, 0x14F50F3B, W09, W09 ^ W13);
        R2(C, D, A, B, G, H, E, F, 0x29EA1E76, W10, W10 ^ W14);
        R2(B, C, D, A, F, G, H, E, 0x53D43CEC, W11, W11 ^ W15);
        R2(A, B, C, D, E, F, G, H, 0xA7A879D8, W12, W12 ^ W00);
        R2(D, A, B, C, H, E, F, G, 0x4F50F3B1, W13, W13 ^ W01);
        R2(C, D, A, B, G, H, E, F, 0x9EA1E762, W14, W14 ^ W02);
        R2(B, C, D, A, F, G, H, E, 0x3D43CEC5, W15, W15 ^ W03);

        ctx->A ^= A;
        ctx->B ^= B;
        ctx->C ^= C;
        ctx->D ^= D;
        ctx->E ^= E;
        ctx->F ^= F;
        ctx->G ^= G;
        ctx->H ^= H;
    }
}
修改md32_common.h

删除头文件# include <openssl/crypto.h>

删除代码中全部的OPENSSL_cleanse();

*解释：经查阅openssl代码中的OPENSSL_cleanse函数声明，此函数作用等同与标准C中的memset(p,0,size)功能，是将参数一内存清0，本文件中调用该函数的地方，其参数1均为栈空间，函数结束后将自动回收，因此没必要手动清0，因此该函数可以不调用，若不放心，可以用memset函数替代。

修改或删除后的文件如下：

#if !defined(DATA_ORDER_IS_BIG_ENDIAN) && !defined(DATA_ORDER_IS_LITTLE_ENDIAN)
# error "DATA_ORDER must be defined!"
#endif

#ifndef HASH_CBLOCK
# error "HASH_CBLOCK must be defined!"
#endif
#ifndef HASH_LONG
# error "HASH_LONG must be defined!"
#endif
#ifndef HASH_CTX
# error "HASH_CTX must be defined!"
#endif

#ifndef HASH_UPDATE
# error "HASH_UPDATE must be defined!"
#endif
#ifndef HASH_TRANSFORM
# error "HASH_TRANSFORM must be defined!"
#endif
#ifndef HASH_FINAL
# error "HASH_FINAL must be defined!"
#endif

#ifndef HASH_BLOCK_DATA_ORDER
# error "HASH_BLOCK_DATA_ORDER must be defined!"
#endif

#define ROTATE(a,n)     (((a)<<(n))|(((a)&0xffffffff)>>(32-(n))))

#if defined(DATA_ORDER_IS_BIG_ENDIAN)

# define HOST_c2l(c,l)  (l =(((unsigned long)(*((c)++)))<<24),          \
                         l|=(((unsigned long)(*((c)++)))<<16),          \
                         l|=(((unsigned long)(*((c)++)))<< 8),          \
                         l|=(((unsigned long)(*((c)++)))    )           )
# define HOST_l2c(l,c)  (*((c)++)=(unsigned char)(((l)>>24)&0xff),      \
                         *((c)++)=(unsigned char)(((l)>>16)&0xff),      \
                         *((c)++)=(unsigned char)(((l)>> 8)&0xff),      \
                         *((c)++)=(unsigned char)(((l)    )&0xff),      \
                         l)

#elif defined(DATA_ORDER_IS_LITTLE_ENDIAN)

# define HOST_c2l(c,l)  (l =(((unsigned long)(*((c)++)))    ),          \
                         l|=(((unsigned long)(*((c)++)))<< 8),          \
                         l|=(((unsigned long)(*((c)++)))<<16),          \
                         l|=(((unsigned long)(*((c)++)))<<24)           )
# define HOST_l2c(l,c)  (*((c)++)=(unsigned char)(((l)    )&0xff),      \
                         *((c)++)=(unsigned char)(((l)>> 8)&0xff),      \
                         *((c)++)=(unsigned char)(((l)>>16)&0xff),      \
                         *((c)++)=(unsigned char)(((l)>>24)&0xff),      \
                         l)

#endif

/*
 * Time for some action :-)
 */

int HASH_UPDATE(HASH_CTX *c, const void *data_, size_t len)
{
    const unsigned char *data = data_;
    unsigned char *p;
    HASH_LONG l;
    size_t n;

    if (len == 0)
        return 1;

    l = (c->Nl + (((HASH_LONG) len) << 3)) & 0xffffffffUL;
    if (l < c->Nl)              /* overflow */
        c->Nh++;
    c->Nh += (HASH_LONG) (len >> 29); /* might cause compiler warning on
                                       * 16-bit */
    c->Nl = l;

    n = c->num;
    if (n != 0) {
        p = (unsigned char *)c->data;

        if (len >= HASH_CBLOCK || len + n >= HASH_CBLOCK) {
            memcpy(p + n, data, HASH_CBLOCK - n);
            HASH_BLOCK_DATA_ORDER(c, p, 1);
            n = HASH_CBLOCK - n;
            data += n;
            len -= n;
            c->num = 0;
            /*
             * We use memset rather than OPENSSL_cleanse() here deliberately.
             * Using OPENSSL_cleanse() here could be a performance issue. It
             * will get properly cleansed on finalisation so this isn't a
             * security problem.
             */
            memset(p, 0, HASH_CBLOCK); /* keep it zeroed */
        } else {
            memcpy(p + n, data, len);
            c->num += (unsigned int)len;
            return 1;
        }
    }

    n = len / HASH_CBLOCK;
    if (n > 0) {
        HASH_BLOCK_DATA_ORDER(c, data, n);
        n *= HASH_CBLOCK;
        data += n;
        len -= n;
    }

    if (len != 0) {
        p = (unsigned char *)c->data;
        c->num = (unsigned int)len;
        memcpy(p, data, len);
    }
    return 1;
}

void HASH_TRANSFORM(HASH_CTX *c, const unsigned char *data)
{
    HASH_BLOCK_DATA_ORDER(c, data, 1);
}

int HASH_FINAL(unsigned char *md, HASH_CTX *c)
{
    unsigned char *p = (unsigned char *)c->data;
    size_t n = c->num;

    p[n] = 0x80;                /* there is always room for one */
    n++;

    if (n > (HASH_CBLOCK - 8)) {
        memset(p + n, 0, HASH_CBLOCK - n);
        n = 0;
        HASH_BLOCK_DATA_ORDER(c, p, 1);
    }
    memset(p + n, 0, HASH_CBLOCK - 8 - n);

    p += HASH_CBLOCK - 8;
#if   defined(DATA_ORDER_IS_BIG_ENDIAN)
    (void)HOST_l2c(c->Nh, p);
    (void)HOST_l2c(c->Nl, p);
#elif defined(DATA_ORDER_IS_LITTLE_ENDIAN)
    (void)HOST_l2c(c->Nl, p);
    (void)HOST_l2c(c->Nh, p);
#endif
    p -= HASH_CBLOCK;
    HASH_BLOCK_DATA_ORDER(c, p, 1);
    c->num = 0;

#ifndef HASH_MAKE_STRING
# error "HASH_MAKE_STRING must be defined!"
#else
    HASH_MAKE_STRING(c, md);
#endif

    return 1;
}

#ifndef MD32_REG_T
# if defined(__alpha) || defined(__sparcv9) || defined(__mips)
#  define MD32_REG_T long
/*
 * This comment was originally written for MD5, which is why it
 * discusses A-D. But it basically applies to all 32-bit digests,
 * which is why it was moved to common header file.
 *
 * In case you wonder why A-D are declared as long and not
 * as MD5_LONG. Doing so results in slight performance
 * boost on LP64 architectures. The catch is we don't
 * really care if 32 MSBs of a 64-bit register get polluted
 * with eventual overflows as we *save* only 32 LSBs in
 * *either* case. Now declaring 'em long excuses the compiler
 * from keeping 32 MSBs zeroed resulting in 13% performance
 * improvement under SPARC Solaris7/64 and 5% under AlphaLinux.
 * Well, to be honest it should say that this *prevents*
 * performance degradation.
 */
# else
/*
 * Above is not absolute and there are LP64 compilers that
 * generate better code if MD32_REG_T is defined int. The above
 * pre-processor condition reflects the circumstances under which
 * the conclusion was made and is subject to further extension.
 */
#  define MD32_REG_T int
# endif
#endif

五、编译运行

将sm3.h,sm3.c,sm3_local.h,md32_common.h文件，配置添加到VS工程中。

编译运行，输出sm3结果如下：

77-01-58-16-14-3e-e6-27-f4-fa-41-0b-6d-ad-2b-db-9f-cb-df-1e-06-1a-45-2a-68-6b-87-11-a4-84-c5-d7

上述算法，适用于计算字符串、缓冲区的SM3值。至于小文件、大文件的SM3如何计算，可以参考本人的另外两篇关于MD5的博客，与SM3非常相似。

小文件MD5计算

大文件MD5计算

欢迎大家关注、留言讨论、可分享源码

逆光倾城
关注
  • 7
    点赞
  • 踩
  • 19
    收藏
    觉得还不错? 一键收藏
  • 6
    评论
专栏目录
一个sm3的C++算法
06-29 1122
#define SM3_H#ifndef DWORD typedef unsigned long DWORD; #endif #ifndef BYTE typedef unsigned char BYTE; #endif#ifdef __cplusplus extern "C" { #endifvoid SM3_Init(); void SM3_Update(BYTE *message, DWORD length); void SM3_Final_dword(DWORD *out_hash); void S
C/C++ SM3算法详解及源码
希望我的博客，能帮上你解决学习中工作中所遇到的问题
05-09 2718
SM3算法是中国国家密码管理局（National Cryptographic Authority）于2010年发布的一种哈希函数算法。它是一种基于Merkle-Damgård结构的密码杂凑算法，适用于数字签名、认证协议、密钥交换协议等安全协议中的消息完整性检测。SM3算法的输入和输出都是256位长的比特串。它将输入分为512位的消息块，并通过迭代进行处理。主要包括预处理、压缩函数和迭代执行三个步骤。
SM3算法的C++实现（代码）
nicai_hualuo的博客
11-26 7967
文章目录一、SM3算法原理二、SM3算法的C++代码实现三、SM3算法的实现结果（给了文档里两个示例的运行结果）1.当输入数据值“abc”时候的实验结果：2.当输入数据值为“abcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcd”时候的实验结果：总结 一、SM3算法原理 SM3密码杂凑算法文档 文档中对于SM3密码杂凑算法描述得十分清楚。整个算法主要涉及了两个主要的函数：填充函数、迭代压缩函数。 迭代压缩函数包括两部分的内容：消.
SM3在线计算工具
最新发布
迷失蒲公英
06-21 941
SM3是中华人民共和国政府采用的一种密码散列函数标准，由国家密码管理局于2010年12月17日发布。相关标准为“GM/T 0004-2012 《SM3密码杂凑算法》”。在商用密码体系中，SM3主要用于数字签名及验证、消息认证码生成及验证、随机数生成等，其算法公开。据国家密码管理局表示，其安全性及效率与SHA-256相当。为了方便代码调试和验证，我们有时候需要直接使用在线工具来进行校验。
杂凑算法SM3的C++实现
04-28
杂凑算法SM3的C++实现,并验证正确。
SM2_SM3_SM4_C语言实现.zip_SM2 C语言_SM2算法 C语言_openssl_sm2_sm4
07-13
SM2_SM3_SM4_C语言实现,利用C语言实现国密算法，基于OpenSSL
sm2加密，解密，签名，验签,sm3哈希,基于openssl的C语言实现
06-16
在C语言中，可以使用OpenSSL的`SM3_CTX`结构体和`SM3_Init`, `SM3_Update`, `SM3_Final`等函数来实现SM3哈希计算。 4. 基于OpenSSL的C语言实现： 在C语言环境下，我们需要先引入OpenSSL库，然后初始化必要的上下文...
C语言实现sm2算法 sm2.zip
11-25
C语言实现sm2算法，基于openssl实现的，内有完整的工程，可以编译，使用VS2010及以上版本打开即可，同时支持64位编译
国密算法--Openssl 实现国密算法（加密和解密）
03-28
国密算法--Openssl 实现国密算法（加密和解密），内涵对称算法，非对称算法加解密流程，图文直观，并附有C语言代码
国标加密算法SM3 C++实现
08-12
对SM3加密算法进行了实现，有利于了解算法过程具体实现的技巧
SM3的C语言实现
07-01
SM3是国家密码管理局编制的商用算法，用于密码应用中的数字签名和验证、消息认证码的生成与验证以及随机数的生成，可满足多种密码应用的安全需求
SM3算法C语言实现
11-03
按国密标准开发的C语言版（VC6）的SM3算法源代码 参考xyssl源码库实现 计算结果与标准测试数据完全相同 附带有SM3-HMAC算法
国密SM3 C实现
08-13
纯C实现SM3国密算法 SM2数字签名许生成HASH值 一般用SM3杂凑算法实现
SM3算法C语言源码
01-09
国家密码管理局的SM3算法标准的C语言源码，此代码的计算结果经过国家密码管理局商用密码检测中心的测试，代码简洁，易用性强。
AES/SM3/CBC C++
weixin_43896279的博客
07-06 1440
密码学的一个大作业 （迷迷糊糊听了一学期，结果老师要做大作业，wc搞了两个月，都怪自己太菜） 这是题目要求 sm3和aes的cbc模式的算法我就简单说说 sm3就是填充然后进行迭代和信息扩展，压缩。。。。就是图中 AES主要就是那4个过程s盒置换，行位移，列混合，轮密钥加了 其中要进行多轮， 加密每1轮包括S盒字节替换、行移位、列混合、轮 密钥加，最后1轮少一个列混合； 解密没1轮包括逆 行移位...
OpenSSL 用SM3算法进行hash
路人丙的奋斗史
05-30 3134
OpenSSL 用SM3算法进行hash 如果需要使用 SM3 Hash 操作，则需要使用1.1.1以上版本的OpenSSL。 主要是用到了 Openssl EVP （high-level cryptographic functions），它提供了丰富的密码学中的函数。 具体实现: #include <openssl/evp.h> #include <openssl/aes.h> bool openssl_sm3_hash(const vector<string>&am
openssl+sm3开发实例C++
N阶二进制的博客
10-25 1337
SM3 是中国国家密码管理局（State Cryptography Administration，SCA）发布的一种密码散列函数，属于SHA-3 候选算法，也是我国的商用密码算法标准之一。SM3 是一种密码学安全性较高的密码散列函数，广泛应用于数字签名、消息认证码（MAC）等安全领域。
基于C实现HMAC-MD5和HMAC-SM3
hdmsfhfg1的博客
12-01 5823
最近手头有个项目涉及到HMAC消息认证算法，要求基于国密算法SM3和C实现，即HMAC-SM3; 网上查资料：HMAC-MD5/HMAC-SHA等一大堆java/python的可用接口，却很少看到基于C语言实现的，若是再加上SM3的算法，更是少之又少;
c++用一级运算比较大小_以SM3算法为例，构建一个软硬协作算法加速器：设计面向SM3优化的运算结构...
weixin_39844267的博客
10-21 334
本文书接上文，来讨论如何具体地针对 SM3 算法的特点，优化计算架构，如通过 CSA 加法器来优化加法关键路径等方法，提升系统频率，提高系统吞吐性能。SM3 中的运算在分析关键关键路径之前，首先分析 SM3 算法中涉及的运算。SM3 运算量集中在消息压缩模块中。从下图中的运算列表可以发现，主要的运算包括：循环移位(<<< 表示循环移位)，异或以及加法。所有运算中，循环移位运算开销...
sm2加密算法 c语言
07-28
SM2是中国自主研发的一种非对称加密算法，是基于椭圆曲线密码体制的一种实现。下面我用300字回答有关SM2加密算法的C语言实现。 SM2加密算法的C语言实现需要引入相关的数学库，以支持椭圆曲线运算。首先，我们需要定义椭圆曲线参数，包括椭圆曲线参数a、b和基点G的坐标。接着，我们需要定义用户的公钥和私钥。 C语言的大整数运算需要使用特定的库，如OpenSSL库。我们需要使用库中提供的函数来处理大整数的加减乘除、求余等操作。而且，我们还需要实现椭圆曲线上的点加、点倍乘等操作，以及哈希函数、随机数生成、消息签名等功能。 在C语言中，SM2加密算法的过程大致如下： 1. 生成用户的公钥和私钥。 2. 根据用户的私钥和待加密的明文，生成消息摘要。 3. 利用消息摘要和用户的私钥，进行数字签名操作。数字签名产生的结果包括签名值r和s。 4. 将明文和签名值r、s一起传输给接收方。 5. 接收方根据用户的公钥、明文和签名值r、s，验证数字签名的有效性。 6. 如果数字签名有效，则利用用户的公钥对明文进行加密，得到密文。 7. 解密需要接收方的私钥，利用私钥对密文进行解密，得到原始的明文。 总结来说，SM2加密算法的C语言实现需要使用数学库和大整数运算库，具体实现要涉及椭圆曲线参数的定义、点运算、哈希函数的调用等。同时，还需要考虑到安全性和性能的平衡，确保算法的可靠性和效率。
评论 6
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值