sm3算法实现

已于 2023-07-04 18:44:02 修改
阅读量1.4k 收藏 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/C++ SM3算法详解及源码
希望我的博客，能帮上你解决学习中工作中所遇到的问题
05-09 2658
SM3算法是中国国家密码管理局（National Cryptographic Authority）于2010年发布的一种哈希函数算法。它是一种基于Merkle-Damgård结构的密码杂凑算法，适用于数字签名、认证协议、密钥交换协议等安全协议中的消息完整性检测。SM3算法的输入和输出都是256位长的比特串。它将输入分为512位的消息块，并通过迭代进行处理。主要包括预处理、压缩函数和迭代执行三个步骤。
SM3算法的编程实现
qq_43717119的博客
06-19 4819
SM3算法的编程实现SM3算法的编程实现【实验目的】【实验环境】【实验预备知识点】【实验步骤】【实验思考题】 SM3算法的编程实现 【实验目的】 1、理解Hash函数的计算原理和特点； 2、理解SM3算法原理； 3、了解SM3值的生成过程。 【实验环境】 windows虚拟机 在目录C:\Program Files\Microsoft Visual Studio\MyProjects\SM3 下打开SM3.dsw，在VC6.0环境下编译代码。 【实验预备知识点】 设消息m的长度为l bit，首先将bit"1
详解SM3算法加密流程（SM3加密算法一）
weixin_50810761的博客
06-09 1625
本文详细介绍了中国的SM3算法，采用消息填充、扩展和迭代压缩过程，输出256位加密数据，适用于电子支付、身份认证和数字签名等。还讨论了算法的实现细节，如迭代运算、常量函数和布尔函数的计算，以及在FPGA上实现时的简化策略。
SM3算法实现
chunyu117的博客
07-14 747
国密sm3的C++实现
sm3算法实现java_[转]国密SM3杂凑算法与实现
weixin_36360511的博客
02-24 2135
国密办已于去年公布国产商密算法SM3，http://www.oscca.gov.cn/News/201012/News_1199.htm，这给其应用和开发带来了方便，也见网上有许多实现的例子，出于一个项目开发需要，也试试其实现。实现思路：完全从头来写不太适合如今开发时代，尤其是开源代码的大量使用。密码算法实现比较有名的就是：openssl，其体系庞大，使用也方便。但从学习与研究上来看，还是需要实现...
SM3杂凑算法与实现
放放的博客
07-15 926
本文阐述了SM3算法的背景和原理，然后详细介绍了算法的具体实现过程，包括消息填充、迭代压缩等关键步骤。通过Python编程实现了SM3算法，并提供了详细的代码示例以及结果截图。此外，文本还对SM3算法的安全性进行了分析，指出其高抗碰撞性、优于MD5和SHA-1算法的特点，并讨论了潜在的安全风险。
SM3算法python实现
weixin_44932880的博客
07-01 2908
""" SM3是中华人民共和国政府采用的一种密码散列函数标准，适用于商用密码应用中的数字签名和验证、消息认证码的生成与验证以及随机数的生成， 可满足多种密码应用的安全需求 对长度为l(l < 2 ^ 64) 比特的消息m，SM3杂凑算法经过填充和迭代压缩，生成杂凑值，杂凑值长度 为256比特。 s2m2b(s) 字符串s 转化为二进制字符串m & 数据m填充,分组b[i] cf(v,b) CF函数实现 zy(n,k) #循环左移k%32位,共32比特 cut_text(text,
实习日志29 SM3算法源码深入
qq_61649579的博客
02-23 1639
我的理解：当使用SM3进行哈希时，它将输入的任意长度数据转换为一个固定长度（256位）的摘要。总的来说，SM3哈希算法是一种用于生成数据指纹的安全且高效的算法，主要用于数据完整性验证、数字签名等场景。SM3密码杂凑算法是中国国家密码管理局2010年公布的中国商用密码杂凑算法标准。具体算法标准原始文本参见参考文献[1]。该算法于2012年发布为密码行业标准(GM/T 0004-2012)，2016年发布为国家密码杂凑算法标准(GB/T 32905-2016)。
SM3算法的C++实现（代码）
nicai_hualuo的博客
11-26 7902
文章目录一、SM3算法原理二、SM3算法的C++代码实现三、SM3算法的实现结果（给了文档里两个示例的运行结果）1.当输入数据值“abc”时候的实验结果：2.当输入数据值为“abcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcd”时候的实验结果：总结 一、SM3算法原理 SM3密码杂凑算法文档 文档中对于SM3密码杂凑算法描述得十分清楚。整个算法主要涉及了两个主要的函数：填充函数、迭代压缩函数。 迭代压缩函数包括两部分的内容：消.
SM3密码算法c语言实现
03-17
在提供的压缩包"sm3修改"中，可能包含的是对原始SM3算法实现的修改或者优化版本，可能涉及以下几个方面： 1. **错误修复**：可能对原版代码中的错误进行了修正，以确保算法的正确性。 2. **性能优化**：可能通过...
国密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++实现哈希算法，并进行相关测试，该方法简单易实施。
代码随想录算法训练营第22天-leetcode-二叉树08：669. 修剪二叉搜索树；108.将有序数组转换为二叉搜索树；538.把二叉搜索树转换为累加树
最新发布
weixin_65180740的博客
07-24 838
你可能需要改变树的根节点，所以结果应当返回修剪好的二叉搜索树的新的根节点。给出二叉 搜索 树的根节点，该树的节点值各不相同，请你将其转换为累加树（Greater Sum Tree），使每个节点 node 的新值等于原树中大于或等于 node.val 的值之和。题目要求，实际上是每个节点加上中序排列后面的那个节点，故而可以反向中序排序，即RNL，用prior记录前一个节点的值，加上前一个节点的值即可。左右子树也必须是二叉搜索树。后序遍历每个节点，对于在范围外的节点，考虑保留其左子树/右子树（只可能保留一个）
cf场+线性dp
xxx_jsu的博客
07-23 298
令a[1]=x[1]+1后我们可以让a[i+1]=a[i]+x[i]，但是这样的话数可能会比较小，所以我们可以累加a[i]，因为是mod所以只要不大于x[i+1]可以一直加下去。2.n>b-a>0这种情况我们还需要考虑到使用到的a，在此之前我们按照等差数列出售了(b-a)个，那么剩下n-(b-a)个我们则需要按照a来出售。采用双指针，一个指向a的头部，一个指向b的头部，两者开始进行匹配，若相同则b往下走一位，否则就终止。题目的第一问其实就是让我们求最长不上升子序列，第二问就是求有多少段最长不上升序列。
算法-KMP字符串匹配
xx_xb的博客
07-23 236
next[i] 就是使子串 s[0…i] 有最长相等前后缀的前缀的最后一位的下标。总体来说解next数组和模板串匹配的过程很相似，触类旁通。
【算法】字典序最小的 01 字符串
2301_79728896的博客
07-24 226
每次只能交换相邻的两个字符,从前向后遍历字符,如果遇到10组合的要交换,同时k–,注意交换后的情况是前面有可能会出现10组合,因此k>0时要回退,直到(用while)前面没有10组合或k==0为止。小红有一个 01 字符串，她可以进行最多 k 次提作，每次操作可以交换相邻的两个字符，问可以得到的字典序最小的字符串是什么。第一行包含两个整数，n（1 < n < 10^5）和 k（1 < k < 10^9），表示字符串的长度和可以进行的操作次数。输出一个长度为 n 的字符串，表示字典序最小的字符串。
用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、付费专栏及课程。

余额充值