sm3算法实现

已于 2023-07-04 18:44:02 修改
阅读量1.3k 收藏 7
点赞数
分类专栏： 国密算法C语言实现 文章标签： 算法 c++ c语言
于 2023-06-12 21:49:36 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/ikantech/article/details/131177616
版权

在实现sm3算法之前，先来回顾一下，sm3算法的执行过程：

SM3执行过程

整个过程分为带入初始IV，中间部分（包括消息填充、消息分组、消息扩展、迭代压缩）、输出结果。把这三部分分别定义为：init、update、done，其中：

  1. init部分： 代表初始化操作，主要是初始化A,B,C,D,E,F,G,H，这8个字寄存器
  2. update部分： 包括消息分组、消息扩展、迭代压缩，以及到了最后一组的时候，进行消息填充。
  3. done部分： 主要是输出结果

1. 算法实现疑问

1.1 为何拆分成三部分

可能会有同学会有疑问，为啥要分成三部分来实现，直接封装成一个函数不好吗？

这个问题，本身是没有问题的，只是角度不同，提出这个问题的同学，我猜测这位同学大部分使用sm3的场景是针对数据量不大，比如就是字节级或KB级的数据，这样直接封装成一个函数是没问题的。但考虑另外一个使用场景，如果我们要对一个GB级或更大的文件，计算其摘要值，怎么办。如果只是封装成一个函数来调用，就意味着，要事先将全部的文件内容读出来，再调用，内存就会爆。

所以就要实现成，读文件一部分内容出来，计算一次，意思就是update部分要可以循环调用。比如每次都读文件的512字节出来，读一次调用一次update，最后等文件全部读完后，调用done来计算最终的摘要值。

而sm3的算法特性正好可以满足计算大文件的要求，它本来就是分组算法，就是来一组计算一组，一组的大小是64字节，计算结果保存在A,B,C,D,E,F,G,H这8个字寄存器中，这样内存就不可能会爆了。

1.2 消息填充实现位置

按规范文档的理解，是在进行消息分组前，就要对消息进行填充，但现在分成了三部分来实现，中间的update部分是循环调用的，来一部分消息，调用一次。而且也算法自身也无法事先知道消息的部大小是多少，所以消息的填充就要放到最后去做。也就是调用done函数时，此时表示消息都读完了，要输出结果了，此时算法已经处理了多少消息是可以用变量来记录的，然后再进行消息填充，再执行迭代压缩，最后输出结果。

2. 算法实现

通过上述解惑，了解到了为何要将sm3的实现拆分成三部分来做。那既然拆分成了三部分，其中update部分还是可以循环调用的，肯定就保存一些中间状态，比如已经压缩了多少消息，当前A,B,C,D,E,F,G,H这8个寄存器的值是多少之类的，我们用一个结构体来当上下文：

typedef struct {
    unsigned int state[8]; // 寄存器中间状态
    unsigned char buf[64]; // 待压缩消息
    uint64_t cur_buf_len; // 当前待压缩消息长度（字节）
    uint64_t compressed_len; // 已压缩消息长度（比特）
} gm_sm3_context;

在sm3.h中定义gm_sm3_context这个结构体，用来记录sm3算法执行过程中的一些状态及中间结果，其中：

  1. state： 用来保存A,B,C,D,E,F,G,H这8个字寄存器的值，每执行完一轮后，暂存在里面。
  2. buf： 用来保存待压缩的消息，因为调用update传过来的消息长度可能不满一组，即不满64字节，此时就不能进行消息扩展、迭代压缩的操作。
  3. cur_buf_len： 用来记录buf中待压缩的消息长度，单位是字节。
  4. compressed_len： 用来记录已压缩的消息长度，单位比特。

这里compressed_len记录的是比特，因为消息填充时，长度需要的是比特单位的长度。

下面以全局视角，先来看看init、update、done这三部分函数的定义：

/**
 * 摘要算法初始化
 * @param ctx 上下文
 */
void gm_sm3_init(gm_sm3_context * ctx);

/**
 * 添加消息
 * @param ctx 上下文
 * @param input 消息
 * @param iLen 消息长度（字节）
 */
void gm_sm3_update(gm_sm3_context * ctx, const unsigned char * input, unsigned int iLen);

/**
 * 计算摘要
 * @param ctx 上下文
 * @param output 输出摘要结果
 */
void gm_sm3_done(gm_sm3_context * ctx, unsigned char output[32]);

函数定义说明：

  1. gm_sm3_init： 初始化，带入个上下文就行，sm3算法本身不需要传入密钥之类的，所以就没有其它参数需要带入了。
  2. gm_sm3_update： 需要带入上下文，待压缩的消息及消息长度。还没执行到最终状态，中间状态都保存到上下文中，所以也没有中间结果需要输出。
  3. gm_sm3_done： 需要带入上下文以及输出缓存区，因为sm3的结果就是A,B,C,D,E,F,G,H这8个寄存器的值，所以它的长度就是8*4=32字节。这里让用户指定缓冲区，是为了遵循内存谁创建谁管理的原则，不应由算法来分配输出缓冲区内存，要不用户可能会忘记释放或不清楚该不该由用户自己来释放。

2.1 init实现

init部分实现，只需要初始化一下A,B,C,D,E,F,G,H这8个寄存器，以及上下文中其它几个变量即可，实现代码如下：

/**
 * 摘要算法初始化
 * @param ctx 上下文
 */
void gm_sm3_init(gm_sm3_context * ctx) {
    ctx->state[0] = GM_SM3_IV_A;
    ctx->state[1] = GM_SM3_IV_B;
    ctx->state[2] = GM_SM3_IV_C;
    ctx->state[3] = GM_SM3_IV_D;
    ctx->state[4] = GM_SM3_IV_E;
    ctx->state[5] = GM_SM3_IV_F;
    ctx->state[6] = GM_SM3_IV_G;
    ctx->state[7] = GM_SM3_IV_H;
    ctx->cur_buf_len = 0;
    ctx->compressed_len = 0;
}

2.2 update实现

实现代码如下：

/**
 * 添加消息
 * @param ctx 上下文
 * @param input 消息
 * @param iLen 消息长度（字节）
 */
void gm_sm3_update(gm_sm3_context * ctx, const unsigned char * input, unsigned int iLen) {
    while (iLen--) {
        ctx->buf[ctx->cur_buf_len++] = *input++;

        /* 是否满64个字节 */
        if (ctx->cur_buf_len == 64) {
            // 满了，则立即调用压缩函数进行压缩
            gm_sm3_compress(ctx);
            ctx->compressed_len += 512;
            ctx->cur_buf_len = 0;
        }
    }
}

代码解析：

  1. 不满一轮时，将消息暂存到buf缓冲区中。
  2. 当满一轮时，调用gm_sm3_compress函数对消息进行消息扩展以及迭代压缩。同时增加已压缩的消息长度，清空待压缩消息长度。
2.2.1 gm_sm3_compress函数
// 压缩算法
static void gm_sm3_compress(gm_sm3_context * ctx) {
    unsigned int W[68];
    unsigned int W1[64];

    // Bi 扩展为 W
    gm_sm3_BiToW(ctx->buf, W);

    // W 扩展为 W1
    gm_sm3_WToW1(W, W1);

    // 压缩
    gm_sm3_CF(W, W1, ctx);
}

gm_sm3_compress函数需要对消息进行扩展，然后再进行迭代压缩。我们把消息扩展分两部分来实现。

2.2.2 消息扩展为W

先来看第一部分，将消息扩展为W，在讲《sm3算法基本原理》中，消息扩展为W首先需要将消息划分为16个字 W 0 , W 1 , ⋅ ⋅ ⋅ , W 15 W_0 , W_1 , · · · , W_{15} W0​,W1​,⋅⋅⋅,W15​，然后按规范文档中的方法进行扩展。先来实现消息划分：

// 消息扩展，消息Bi -> W
static void gm_sm3_BiToW(const unsigned char * Bi, unsigned int * W) {
    GM_GET_UINT32_BE( W[ 0], Bi,  0 );
    GM_GET_UINT32_BE( W[ 1], Bi,  4 );
    GM_GET_UINT32_BE( W[ 2], Bi,  8 );
    GM_GET_UINT32_BE( W[ 3], Bi, 12 );
    GM_GET_UINT32_BE( W[ 4], Bi, 16 );
    GM_GET_UINT32_BE( W[ 5], Bi, 20 );
    GM_GET_UINT32_BE( W[ 6], Bi, 24 );
    GM_GET_UINT32_BE( W[ 7], Bi, 28 );
    GM_GET_UINT32_BE( W[ 8], Bi, 32 );
    GM_GET_UINT32_BE( W[ 9], Bi, 36 );
    GM_GET_UINT32_BE( W[10], Bi, 40 );
    GM_GET_UINT32_BE( W[11], Bi, 44 );
    GM_GET_UINT32_BE( W[12], Bi, 48 );
    GM_GET_UINT32_BE( W[13], Bi, 52 );
    GM_GET_UINT32_BE( W[14], Bi, 56 );
    GM_GET_UINT32_BE( W[15], Bi, 60 );
}

就是将字节转换为字的操作，参照《sm3算法基本原理》中大小端的解释，再使用《sm3常量及通用函数》中事先实现好的将字节转换为字的宏定义即可。

消息扩展为W，规范原文是：

F O R   j = 16   T O   67 FOR\ j= 16\ TO\ 67 FOR j=16 TO 67
　　 W j ← P 1 ( W j − 16 ⊕ W j − 9 ⊕ ( W j − 3 ⋘ 15 ) ) ⊕ ( W j − 13 ⋘ 7 ) ⊕ W j − 6 W_j \gets P_1 (W_{j−16} \oplus W_{j−9} \oplus (W_{j−3} \lll 15)) \oplus (W_{j−13} \lll 7) ⊕ W_{j−6} Wj​←P1​(Wj−16​⊕Wj−9​⊕(Wj−3​⋘15))⊕(Wj−13​⋘7)⊕Wj−6​
E N D F O R ENDFOR ENDFOR

其中 P 1 P_1 P1​在《sm3常量及通用函数》中已经用宏定义实现完了，可以去回顾一下，那要实现将消息扩展为W就简单了：

// 消息扩展，消息Bi -> W
static void gm_sm3_BiToW(const unsigned char * Bi, unsigned int * W) {
    int i;
    unsigned int tmp;

    GM_GET_UINT32_BE( W[ 0], Bi,  0 );
   // 此处省略W1-W14的字节转换为字...
    GM_GET_UINT32_BE( W[15], Bi, 60 );

    for (i = 16; i <= 67; i++) {
        tmp = W[i - 16]    ^ W[i - 9] ^ GM_SM3_ROTL(W[i - 3], 15);
        W[i] = GM_SM3_P_1(tmp) ^ (GM_SM3_ROTL(W[i - 13], 7)) ^ W[i - 6];
    }
}
2.2.3 W扩展为W1

规范原文：

F O R   j = 0   T O   63 FOR\ j=0\ TO\ 63 FOR j=0 TO 63
　　 W j ′ = W j ⊕ W j + 4 W_j' = W_j \oplus W_{j+4} Wj′​=Wj​⊕Wj+4​
E N D F O R ENDFOR ENDFOR

这个不难，代码实现如下：

// w 扩展算法
static void gm_sm3_WToW1(const unsigned int * W, unsigned int * W1) {
    int i;

    for (i = 0; i <= 63; i++) {
        W1[i] = W[i] ^ W[i + 4];
    }
}
2.2.4 迭代压缩函数

这里我把实现代码贴出来，大家对照着《sm3算法基本原理》来看，理解起来应该没有难度，都是些简单的运算以及讲过的内容了。

// 压缩算法
static void gm_sm3_CF(const unsigned int *W, const unsigned int *W1, gm_sm3_context *ctx) {
    unsigned int SS1;
    unsigned int SS2;
    unsigned int TT1;
    unsigned int TT2;
    unsigned int A, B, C, D, E, F, G, H;
    unsigned int Tj;
    int j;

    // ABCDEFGH = V (i)
    A = ctx->state[0];
    B = ctx->state[1];
    C = ctx->state[2];
    D = ctx->state[3];
    E = ctx->state[4];
    F = ctx->state[5];
    G = ctx->state[6];
    H = ctx->state[7];

    for (j = 0; j < 64; j++) {
        if (j < 16) {
            // if 0 <= j <= 15 Tj = 0x79cc4519
            Tj = GM_SM3_T_0;
        } else {
            // if j > 15 Tj = 0x7a879d8a
            Tj = GM_SM3_T_1;
        }
        // SS1 = ((A <<< 12) + E + (Tj <<< j)) <<< 7
        SS1 = GM_SM3_ROTL((GM_SM3_ROTL(A, 12) + E + GM_SM3_ROTL(Tj, j)), 7);
        // SS2 = SS1 ^ (A <<< 12)
        SS2 = SS1 ^ GM_SM3_ROTL(A, 12);

        // TT1 = FFj(A, B, C) + D + SS2 + Wj1
        // TT2 = GGj(E, F, G) + H + SS1 + Wj
        if (j < 16) {
            TT1 = GM_SM3_FF_0(A, B, C) + D + SS2 + W1[j];
            TT2 = GM_SM3_GG_0(E, F, G) + H + SS1 + W[j];
        } else {
            TT1 = GM_SM3_FF_1(A, B, C) + D + SS2 + W1[j];
            TT2 = GM_SM3_GG_1(E, F, G) + H + SS1 + W[j];
        }

        // D = C
        D = C;
        // C = B <<< 9
        C = GM_SM3_ROTL(B, 9);
        // B = A
        B = A;
        // A = TT1
        A = TT1;
        // H = G
        H = G;
        // G = F <<< 19
        G = GM_SM3_ROTL(F, 19);
        // F = E
        F = E;
        // E = P0(TT2)
        E = GM_SM3_P_0(TT2);
    }

    // V(i+1) = ABCDEFGH ^ V(i)
    ctx->state[0] ^= A;
    ctx->state[1] ^= B;
    ctx->state[2] ^= C;
    ctx->state[3] ^= D;
    ctx->state[4] ^= E;
    ctx->state[5] ^= F;
    ctx->state[6] ^= G;
    ctx->state[7] ^= H;
}

2.3 done实现

先贴代码，再进行代码解析：

static const unsigned char gm_sm3_padding[64] = {
        0x80, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
};

/**
 * 计算摘要
 * @param ctx 上下文
 * @param output 输出摘要结果
 */
void gm_sm3_done(gm_sm3_context * ctx, unsigned char output[32]) {
    uint32_t padn;
    unsigned char msglen[8];
    uint64_t total_len, high, low;

    // 消息的总长度(比特) = 剩余未压缩数据的长度(字节) * 8
    total_len = ctx->compressed_len + (ctx->cur_buf_len << 3);
    high = (total_len >> 32) & 0x0FFFFFFFF;
    low = total_len & 0x0FFFFFFFF;

    GM_PUT_UINT32_BE(high, msglen, 0);
    GM_PUT_UINT32_BE(low,  msglen, 4);

    // 计算填充长度，因为事先要添加一比特，故应计算cur_buf_len + 1是否超过56
    padn = ((ctx->cur_buf_len + 1) <= 56) ? (56 - ctx->cur_buf_len) : (120 - ctx->cur_buf_len);

    // 添加填充
    gm_sm3_update(ctx, (unsigned char *) gm_sm3_padding, padn);
    gm_sm3_update(ctx, msglen, 8);

    // output
    GM_PUT_UINT32_BE(ctx->state[0], output,  0);
    GM_PUT_UINT32_BE(ctx->state[1], output,  4);
    GM_PUT_UINT32_BE(ctx->state[2], output,  8);
    GM_PUT_UINT32_BE(ctx->state[3], output, 12);
    GM_PUT_UINT32_BE(ctx->state[4], output, 16);
    GM_PUT_UINT32_BE(ctx->state[5], output, 20);
    GM_PUT_UINT32_BE(ctx->state[6], output, 24);
    GM_PUT_UINT32_BE(ctx->state[7], output, 28);
}

代码解析：

  1. done函数的职能，通过前面的讲述，我们是把消息填充放在这一步了，在进行消息填充之前，先要计算好消息的部比特长度，注意不是字节长度。

    unsigned char msglen[8];
uint64_t total_len, high, low;

// 消息的总长度(比特) = 剩余未压缩数据的长度(字节) * 8
total_len = ctx->compressed_len + (ctx->cur_buf_len << 3);
high = (total_len >> 32) & 0x0FFFFFFFF;
low = total_len & 0x0FFFFFFFF;

// 规范中是大端存储
GM_PUT_UINT32_BE(high, msglen, 0);
GM_PUT_UINT32_BE(low,  msglen, 4);

    这部分操作，就是计算消息的总长度，然后将8字节的拆成两个4字节整型，然后转换为字节的形式，方便添加到消息的尾部。

  2. 计算填充内容的长度，以及填充

    uint32_t padn;

// 计算填充长度，因为规范中固定事先要添加一比特，故应计算cur_buf_len + 1是否超过56
padn = ((ctx->cur_buf_len + 1) <= 56) ? (56 - ctx->cur_buf_len) : (120 - ctx->cur_buf_len);

// 添加填充
gm_sm3_update(ctx, (unsigned char *) gm_sm3_padding, padn);

    这里拿56作为分界点，其实是简化了，一组消息的大小是64字节，那么填充的长度=64 - 消息总长度8 - 未压缩的消息长度ctx->cur_buf_len,简化一下就是填充的长度=56 - ctx->cur_buf_len。如果56<未压缩的长度+1<=64,那么填充的长度=128 - 消息总长度8 - 未压缩的消息长度ctx->cur_buf_len，简化一下就是填充的长度=120 - ctx->cur_buf_len。

  3. 最后的输出就是将字转换为字节。

创忆
关注
  • 0
    点赞
  • 踩
  • 7
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C++实现哈希算法（附完整源码）
希望我的博客，能帮上你解决学习中工作中所遇到的问题
05-24 207
C++实现哈希算法（附完整源码）
SM3密码算法c语言实现
03-17
在提供的压缩包"sm3修改"中，可能包含的是对原始SM3算法实现的修改或者优化版本，可能涉及以下几个方面： 1. **错误修复**：可能对原版代码中的错误进行了修正，以确保算法的正确性。 2. **性能优化**：可能通过...
SM3算法实现
chunyu117的博客
07-14 725
国密sm3的C++实现
国密sm2 sm3 sm4 c++
sun007700的专栏
08-08 2277
国密
SM3国密算法简介及应用案例
NeedForSpeed
05-08 1965
为了加强数据加密的自主性与安全性，中国国家密码管理局（SCA）发布了一系列的国家密码标准算法，其中 SM3 是一种重要的国密（国家密码）算法，用于消息摘要与数字签名。SM3 作为中国自主研发的消息摘要算法，具有强大的安全性和实用性，已成为国内加密领域的主要标准算法。SM3 是由中国国家密码管理局发布的消息摘要算法，首次发布于 2010 年，并于 2016 年发布了正式的国家标准 GB/T 32905-2016。在国内区块链项目中，SM3 常用于区块数据的哈希计算和链上数据的完整性验证。
超级好用的C++实用库之国密sm3算法
最新发布
hope_wisdom的技术博客
05-20 1193
国密SM3是一种由中国国家密码管理局制定的密码散列函数标准，全称为“商用密码SM3杂凑算法”。它用于提供数据完整性校验和安全性认证，类似于国际上的SHA-256等散列函数，但具有中国自主知识产权。SM3算法在多种安全应用场景中扮演关键角色，比如：电子签名、消息认证码生成、数据校验以及密码协议的安全基础等。SM3算法的设计目标是达到至少128位的安全强度，能够抵抗已知的各种攻击方法，包括碰撞攻击、原像攻击等。其输出是一个256位的哈希值，即32个字节。
SM3算法的C++实现（代码）
nicai_hualuo的博客
11-26 7786
文章目录一、SM3算法原理二、SM3算法的C++代码实现三、SM3算法的实现结果（给了文档里两个示例的运行结果）1.当输入数据值“abc”时候的实验结果：2.当输入数据值为“abcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcd”时候的实验结果：总结 一、SM3算法原理 SM3密码杂凑算法文档 文档中对于SM3密码杂凑算法描述得十分清楚。整个算法主要涉及了两个主要的函数：填充函数、迭代压缩函数。 迭代压缩函数包括两部分的内容：消.
国密哈希hash算法SM3原理分析
m0_37799284的博客
08-12 1791
无限制512bit32bit4128bit。
SM3密码杂凑算法原理
热门推荐
10点43的博客
10-15 3万+
目录 1.概述 2、算法描述 2.1 概述 2.2 填充 2.3 迭代压缩 2.3 消息扩展 2.4 压缩函数 2.5 杂凑值 1.概述 SM3是我国采用的一种密码散列函数标准，由国家密码管理局于2010年12月17日发布。相关标准为“GM/T 0004-2012 《SM3密码杂凑算法》”。 在商用密码体系中，SM3主要用于数字签名及验证、消息认证码生成及验证、随机数生成等，...
JavaScript学习 -- SM3算法基本原理
weixin_41489908的博客
07-29 2259
SM3算法是一种由国家密码管理局发布的哈希算法，被广泛用于数字签名和消息认证等应用中。在JavaScript中，我们可以使用第三方库来计算数据的SM3哈希值。本篇文章将介绍SM3算法的基本原理和相关技术，并提供一些实例来演示如何在JavaScript中使用SM3算法。
源码方式向openssl中添加新算法完整详细步骤（示例：摘要算法SM3）【非engine方式】
luckymelina的专栏
08-29 1万+
openssl简介 openssl是一个功能丰富且自包含的开源安全工具箱。它提供的主要功能有：SSL协议实现(包括SSLv2、SSLv3和TLSv1)、大量软算法(对称/非对称/摘要)、大数运算、非对称算法密钥生成、ASN.1编解码库、证书请求(PKCS10)编解码、数字证书编解码、CRL编解码、OCSP协议、数字证书验证、PKCS7标准实现和PKCS12个人数字证书格式实现等功能。 open
国密SM3算法实现
10-19
不用修改可以直接用的C代码 经过验证的SM3国密算法
国密SM3算法实现源代码（只适合JAVA）
01-11
国密SM3算法的Java实现，可以与bc很好的结合，实现国密算法扩展。已经用SM3算法标准中的示例数据进行验证，两组示例数据对比测试完全正确。 附带工具类实现方式,费了两天的时候搞出来的,100%对比正确.
SM3_cpp.zip_SM3_cpp.3com_sm3实现_sm3算法实现_zulue7x
09-21
SM3杂凑算法c++实现, 测试字符串abc
sm3标准算法
08-17
在linux平台上用c++实现哈希算法，并进行相关测试，该方法简单易实施。
HASH和HMAC（4）：SHA-224和SHA-256算法原理
j64993的博客
10-06 1329
SHA-224 SHA-256
openssl+sm3开发实例C++
N阶二进制的博客
10-25 1252
SM3 是中国国家密码管理局（State Cryptography Administration，SCA）发布的一种密码散列函数，属于SHA-3 候选算法，也是我国的商用密码算法标准之一。SM3 是一种密码学安全性较高的密码散列函数，广泛应用于数字签名、消息认证码（MAC）等安全领域。
[python]国密SM3算法的实现
weixin_43936250的博客
04-15 8608
#-------以下函数也可用于其它算法中--------- def rotation_left(x, num): # 循环左移 num %= 32 left = (x << num) % (2 ** 32) right = (x >> (32 - num)) % (2 ** 32) result = left ^ right ...
react+vue 前端国密算法sm2、sm3 、sm4的js ts实现
柠檬草的博客
12-07 3088
SM3 算法：是一种对称加密算法，用于消息摘要和数字签名等场景。它的密钥长度为 256 位，安全性较高。SM2 算法：是一种公钥加密算法，它的密钥长度为 256 位，安全性较高。将字符串转为16进制方法，我这里是自己封装了一个，还有很多方法可以实现转16进制，大家可以自己百度学习。data是签名加密数据，例如：账号+密码+时间戳（需要跟后端开发协商）PUBLIC_KEY是后端给你的公钥，长度为130位，，这里的strToHex方法就是将密码转为16进制。pwd是是第二个参数，我们这里要求的是传密码，
用verilog实现sm3算法
03-28
很抱歉，作为AI语言模型，我无法提供完整的Verilog代码实现。但是，我可以向您提供一些有用的资源和提示： - 首先，您需要了解SM3算法的原理和流程。SM3是一种哈希函数，用于将任意长度的消息压缩成256位的摘要。您可以查阅相关的文献和标准，例如《中国商用密码算法SM3》。 - 接下来，您需要在Verilog中实现SM3的各个模块，例如消息扩展模块、压缩函数模块等。这需要您对Verilog语言和数字电路设计有一定的了解。您可以参考其他人的实现或者相关的教程和书籍。 - 最后，您需要编写测试代码，对您的实现进行测试。您可以使用一些标准的测试向量或者自己生成一些测试消息进行测试。确保您的实现能够正确地计算出摘要。 希望这些提示能对您有所帮助。祝您成功实现SM3算法！

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值