精华内容
下载资源
问答
  • 国密SM3算法标准文本

    2011-02-18 12:28:07
    国家密码管理局制定的国内标准杂凑算法标准文本。
  • SM4 算法 标准

    2017-04-21 11:51:09
    SM4 算法 标准
  • SM3算法C语言源码

    2017-01-09 11:52:55
    国家密码管理局的SM3算法标准的C语言源码,此代码的计算结果经过国家密码管理局商用密码检测中心的测试,代码简洁,易用性强。
  • SM9算法标准

    千次阅读 2020-05-13 11:19:39
    SM9算法标准 2016年行标 《GMT 0044.1-2016 SM9标识密码算法 第一部分:总则》 《GMT 0044.2-2016 SM9标识密码算法 第二部分:数字签名算法》 《GMT 0044.3-2016 SM9标识密码算法 第三部分:密钥交换协议》 ...

    SM9算法标准

    2016年行标

    《GMT 0044.1-2016 SM9标识密码算法 第一部分:总则》

    《GMT 0044.2-2016 SM9标识密码算法 第二部分:数字签名算法》

    《GMT 0044.3-2016 SM9标识密码算法 第三部分:密钥交换协议 》

    《GMT 0044.4-2016 SM9标识密码算法 第四部分:密钥封装机制和公钥加密算法》

    2020年国标

    《GB/T 38635.1-2020 信息安全技术 SM9标识密码算法 第一部分:总则》

    《GB/T 38635.1-2020 信息安全技术 SM9标识密码算法 第二部分:算法》

    展开全文
  • SM2SM3算法的python实现,完全按照国密标准实现,所用参数都按照国密标准来的,可以实现签名及认证功能,以及杂凑功能
  • sm3标准算法

    2018-08-17 15:56:25
    在linux平台上用c++实现哈希算法,并进行相关测试,该方法简单易实施。
  • 国密SM3算法的Java实现,可以与bc很好的结合,实现国密算法扩展。已经用SM3算法标准中的示例数据进行验证,两组示例数据对比测试完全正确。 附带工具类实现方式,费了两天的时候搞出来的,100%对比正确.
  • SM3算法

    2021-06-19 21:10:04
    SM3算法【实验目的】【实验环境】【实验预备知识点】【实验内容】【实验步骤】【实验思考题】 【实验目的】 1、理解Hash函数的计算原理和特点 2、理解SM3算法原理 3、了解SM3值的生成过程 【实验环境】 用户A需要...

    【实验目的】

    1、理解Hash函数的计算原理和特点
    2、理解SM3算法原理
    3、了解SM3值的生成过程

    【实验环境】

    用户A需要生成一段消息的SM3值,准备依据这个散列值对消息进行进一步的处理。
    完成本实验需要使用密码学教学软件,在D:\Release\bin目录下打开Crypto软件。

    【实验预备知识点】

    SM3算法是密码杂凑算法,适用于商用密码应用中的数字签名和验证、消息认证码的生成与验证以及随机数的生成,可满足多种密码应用的安全需求。
    对长度为l(l< 2^64) 比特的消息m,SM3杂凑算法经过填充和迭代压缩,生成杂凑值,杂凑值长度为256比特。具体过程请见SM3标准描述。

    【实验内容】

    SM3算法是国家密码管理局2010年12月颁布的密码杂凑算法,适用于商用密码应用中的数字签名和验证、消息认证码的生成与验证以及随机数的生成。

    SM3算法对于长度小于264位的消息,产生一个256位的消息摘要。

    算法以512位分组来处理输入的信息,每一分组又被划分为132个32位子分组,经过一系列的处理后,算法的输出由八个32位分组组成,将这些32位分组级联后产生一个256位的散列值。

    【实验步骤】

    (1). 输入消息
    (2). 点击生成按钮
    (3). 观察明文填充块,观察生成的散列值
    (4). 点击64步运算按钮,观察SM3运算的各个步骤
    (5). 对输入消息做细微修改
    (6). 重复(2),(3),(4)
    (7). 比较散列值前后的变化情况
    操作说明
    本演示实验以一个分组(512位)的散列计算为例,考虑到填充的信息长度,用户输入的长度不超过55个字节,超过部分系统会自动截断。

    (1)进入SM3演示程序
    点击教学软件中的SM算法的SM3算法。
    (2) 输入待散列的明文
    (3) 生成散列值
    点击生成,系统首先显示填充后的512位子明文分组,然后依据算法产生相应的子明文分组扩充,最后显示生成的SHA1散列值。
    在这里插入图片描述
    图 1生成散列值
    (4)详细计算流程
    点击64步运算按钮,系统显示对明文数据进行运算的80步操作细节。
    在这里插入图片描述
    图 2详细计算流程
    点击步骤,可以依序得到每步的计算结果
    在这里插入图片描述
    图 3得到每步计算结果

    【实验思考题】

    1、 SM3的基本处理块大小如何?
    (1) 算法的本质
    给数据加一个固定长度的指纹,这个固定长度就是256比特。
    (2) 处理过程
    第一步:填充,使填充后的数据的长度是512的整数倍
    先在数据的最尾巴上加一个1;然后把原始数据的长度用64比特表示,放在最后面;再看看现在的数据的长度值离512的整数还差多少个,差多少个就填多少个0在加的这个1和64比特的长度之间。
    (3) 分组
    把填充后的信息按照512比特一个分组进行分组,如果分成了N组,就是b(0),b(1),b(N-1)
    第三步:迭代压缩得到最后的杂凑值(哈希值)
    IV(n)=CF(IV(n-1),b(n-1))
    如果信息分为N组,那么IV(N)就是最后得到的杂凑值。

    2、 SM3与MD5,SHA1的散列值的大小分别是多少?
    (1) SM3算法对于长度小于264位的消息,产生一个256位的消息摘要。算法以512位分组来处理输入的信息,每一分组又被划分为132个32位子分组,经过一系列的处理后,算法的输出由八个32位分组组成,将这些32位分组级联后产生一个256位的散列值。

    (2) MD5(RFC 1321)是 Rivest 于1991年对MD4的改进版本。它对输入仍以512位分组,其输出是4个32位字的级联,与 MD4 相同。MD5比MD4来得复杂,并且速度较之要慢一点,但更安全,在抗分析和抗差分方面表现更好。

    (3) SHA1是由NIST NSA设计为同DSA一起使用的,它对长度小于264的输入,产生长度为160bit的散列值,因此抗穷举(brute-force)性更好。SHA-1 设计时基于和MD4相同原理,并且模仿了该算法。

    展开全文
  • 国密SM3算法实现源代码(JAVA版)

    热门讨论 2012-10-18 01:21:12
    国密SM3杂凑算法的Java实现,基于bouncycastle的中定义的ExtendedDigest接口,依赖于bc...已经用SM3算法标准中的示例数据进行验证,两组示例数据对比测试完全正确。 依赖bouncycastle,自己去下载bouncycastle的jar包。
  • SM3算法C语言实现

    热门讨论 2011-11-03 15:43:54
    按国密标准开发的C语言版(VC6)的SM3算法源代码 参考xyssl源码库实现 计算结果与标准测试数据完全相同 附带有SM3-HMAC算法
  • 最全最清晰的国密算法SM2、SM3SM4算法标准规范。 SM1 为对称加密。其加密强度与AES相当。该算法不公开,调用该算法时,需要通过加密芯片的接口进行调用。 SM2为非对称加密,基于ECC。该算法已公开。由于该算法基于...
  • 提供国密三方API,代码可以运行,提供了SM2,SM3SM4标准算法,欢迎大家下载
  • SM1、SM2 、SM3SM4算法

    千次阅读 2019-03-12 18:55:08
    主要有SM1,SM2,SM3SM4。密钥长度和分组长度均为128位。 (1)SM1为对称加密。其加密强度与AES相当。该算法不公开,调用该算法时,需要通过加密芯片的接口进行调用。 (2)SM2为非对称加密,基于ECC。该算法...

    国密即国家密码局认定的国产密码算法。主要有SM1,SM2,SM3,SM4。密钥长度和分组长度均为128位。

       (1)SM1 为对称加密。其加密强度与AES相当。该算法不公开,调用该算法时,需要通过加密芯片的接口进行调用。

       (2)SM2为非对称加密,基于ECC。该算法已公开。由于该算法基于ECC,故其签名速度与秘钥生成速度都快于RSA。ECC 256位(SM2采用的就是ECC 256位的一种)安全强度比RSA 2048位高,但运算速度快于RSA。

       (3)SM3 消息摘要。可以用MD5作为对比理解。该算法已公开。校验结果为256位。

       (4)SM4 无线局域网标准的分组数据算法。对称加密,密钥长度和分组长度均为128位。

    一、分组密码算法——国际DES、国产SM4

            分组密码就是将明文数据按固定长度进行分组,然后在同一密钥控制下逐组进行加密,从而将各个明文分组变换成一个等长的密文分组的密码。其中二进制明文分组的长度称为该分组密码的分组规模。

            分组密码的实现原则如下:

           (1)必须实现起来比较简单,知道密钥时加密和脱密都十分容易,适合硬件和(或)软件实现.

      (2)加脱密速度和所消耗的资源和成本较低,能满足具体应用范围的需要.

            分组密码的设计基本遵循混淆原则和扩散原则。

            (1)混淆原则就是将密文、明文、密钥三者之间的统计关系和代数关系变得尽可能复杂,使得敌手即使获得了密文和明文,也无法求出密钥的任何信息;即使获得了密文和明文的统计规律,也无法求出明文的任何信息。

      (2)扩散原则就是应将明文的统计规律和结构规律散射到相当长的一段统计中去。也就是说让明文中的每一位影响密文中的尽可能多的位,或者说让密文中的每一位都受到明文中的尽可能多位的影响。

     1. DES算法

    DES算法是在美国NSA(国家安全局)资助下由IBM公司开发的密码算法,其初衷是为政府非机密的敏感信息提供较强的加密保护。它是美国政府担保的第一种加密算法,并在1977年被正式作为美国联邦信息处理标准。DES主要提供非军事性质的联邦政府机构和私营部门使用,并迅速成为名声最大,使用最广的商用密码算法。

      细解DES

      细解3DES

      细解AES

                                                                 DES算法的整体结构图: 

                                                                                                SM4算法

    2.SM4算法的整体结构图:

     

    国际的DES算法和国产的SM4算法的目的都是为了加密保护静态储存和传输信道中的数据,主要特性如下:

      从算法上看,国产SM4算法在计算过程中增加非线性变换,理论上能大大提高其算法的安全性,并且由专业机构进行了密码分析,民间也对21轮SM4进行了差分密码分析,结论均为安全性较高。

    二、公钥密码算法——国际RSA、国产SM2 

    公钥密码学与其他密码学完全不同, 使用这种方法的加密系统,不仅公开加密算法本身,也公开了加密用的密钥

      公钥密码系统与只使用一个密钥的对称传统密码不同,算法是基于数学函数而不是基于替换和置换。公钥密码学是非对称的,它使用两个独立的密钥,即密钥分为公钥和私钥,因此称双密钥体制。双钥体制的公钥可以公开,因此称为公钥算法。

      公钥算法的出现,给密码的发展开辟了新的方向。公钥算法虽然已经历了20多年的发展,但仍具有强劲的发展势头,在鉴别系统和密钥交换等安全技术领域起着关键的作用

      公钥算法的加密与解密由不同的密钥完成,并且从加密密钥得到解密密钥在计算上是不可行的。通常,公钥算法的两个密钥中任何一个都可以作为加密而另一个用作解密,但不是所有的公钥算法都是如此。

     

    RSA算法由Rivest、Shamir、Adleman于1978年首次发表,是迄今为止最容易理解和实现的公钥算法,已经受住了多年深入的攻击,其理论基础是一种特殊的可逆模幂运算,其安全性基于分解大整数的困难性。

      RSA算法既可用于加密,又可用于数字签名,已得到广泛采用,并被许多标准化组织(如ISO、ITU、IETF和SWIFT等)接纳。目前许多国家标准仍采用RSA算法或它的变型。

      1.RSA算法的实现如下:

      (1) 实现者寻找出两个大素数p和q

      (2) 实现者计算出n=pq 和φ(n)=(p-1)(q-1)

      (3) 实现者选择一个随机数e (0<e<></e<>

      (4) 实现者使用辗转相除法计算d=e-1(modφ(n))

      (5) 实现者在目录中公开n和e作为公钥

      密码分析者攻击RSA体制的关键点在于如何分解n。若分解成功使n=pq,则可以算出φ(n)=(p-1)(q-1),然后由公开的e,解出秘密的d。所以说RSA算法的安全性基于分解大整数的困难性。

            细解RSA

          2. SM2算法

      SM2算法由国家密码管理局于2010年12月17日发布,全称为椭圆曲线算法。椭圆曲线并不是椭圆,之所以称为椭圆曲线是因为它们是用三次方程来表示的,并且该方程与计算椭圆周长的方程相似。一般而言,椭圆曲线的三次方程形为:

      y2+axy+by=x3+cx2+dx+e [其中a,b,c,d和e是满足某些条件的实数,因为方程中的指数最高是3,所以我们称之为三次方程,或者说方程的次数为3]

      SM2算法使用的方程为:y2= x3 + ax + b

      SM2算法实现如下:

      (1) 选择Ep(a,b)的元素G,使得G的阶n是一个大素数

      (2) G的阶是指满足nG=O的最小n值

      (3) 秘密选择整数k,计算B=kG,然后公开(p,a,b,G,B),B为公钥,保密k,k为私钥

      加密M:先把消息M变换成为Ep(a,b)中一个点Pm,然后,选择随机数r,计算密文Cm={rG,Pm+rP),如果r使得rG或者rP为O,则要重新选择r。

      解密Cm: (Pm+rP)-k(rG)=Pm+rkG-krG=Pm

      SM2算法的安全性基于一个数学难题”离散对数问题ECDLP”实现,即考虑等式Q=KP,其中Q、P属于Ep(a,b),K<p,则:1) p="" 已知q和p,计算k,是困难的。<="">

      现今对椭圆曲线研究的时间短,经过许多优秀的数学家的努力,至今一直没有找到亚指数级算法。正是由于目前所知求解ECDLP的最好方法是指数级的,这使得我们选用SM2算法作加解密及数字签名时,所要求的密钥长度比RSA要短得多。

      国际的RSA算法和国产的SM2算法主要特性对比如下:

    三、摘要算法——国产SM3

      摘要函数在密码学中具有重要的地位,被广泛应用在数字签名,消息认证,数据完整性检测等领域。摘要函数通常被认为需要满足三个基本特性碰撞稳固性,原根稳固性第二原根稳固性

      2005年,Wang等人给出了MD5算法和SHA-1算法的碰撞攻击方法,现今被广泛应用的MD5算法和SHA-1算法不再是安全的算法。

      SM3密码摘要算法是中国国家密码管理局2010年公布的中国商用密码杂凑算法标准。SM3算法适用于商用密码应用中的数字签名和验证,是在SHA-256基础上改进实现的一种算法。SM3算法采用Merkle-Damgard结构,消息分组长度为512位摘要值长度为256位。

      SM3算法的压缩函数与SHA-256的压缩函数具有相似的结构,但是SM3算法的设计更加复杂,比如压缩函数的每一轮都使用2个消息字。

      现今为止,SM3算法的安全性相对较高

     

     

     

     

     

    展开全文
  • 国密算法SM2_SM3_SM4标准规范.rar

    热门讨论 2015-06-05 16:43:09
    国密算法SM2_SM3_SM4标准规范: SM2椭圆曲线公钥密码算法.pdf SM3密码杂凑算法.pdf SM4分组密码算法.pdf
  • sm2 sm3 sm4国密算法.zip

    2020-02-13 16:39:34
    主要对 sm2_sm3_sm4 国密算法详细介绍。 国密即国家密码局认定的国产密码算法。主要有SM2,SM3SM4。密钥长度和分组长度均为128位。...SM4 无线局域网标准的分组数据算法。对称加密,密钥长度和分组长度均为128位。
  • SM3算法的编程实现

    2021-06-19 21:04:51
    SM3算法的编程实现SM3算法的编程实现【实验目的】【实验环境】【实验预备知识点】【实验步骤】【实验思考题】 SM3算法的编程实现 【实验目的】 1、理解Hash函数的计算原理和特点; 2、理解SM3算法原理; 3、了解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"添加到消息末尾,再加k个“0”,k是满足l+1+k =448 mod 512的最小非负整数。然后再添加一个64bit串,该串是l的二进制表示,填充后的消息m’长度为512的整数倍。填充过后,再经迭代压缩,最后经过散列运算即可得到结果。

    1. 主流程图
      在这里插入图片描述

    图 1主流程图
    在这里插入图片描述

    1. 程序调用层次图

    在这里插入图片描述
    图 2程序调用关系图.

    1. 程序调用关系图
      在这里插入图片描述
      图 3程序调用关系图.
      【实验内容】
      SM3算法是国家密码管理局2010年12月颁布的密码杂凑算法,适用于商用密码应用中的数字签名和验证、消息认证码的生成与验证以及随机数的生成。SM3算法对于长度小于264位的消息,产生一个256位的消息摘要。算法以512位分组来处理输入的信息,每一分组又被划分为132个32位子分组,经过一系列的处理后,算法的输出由八个32位分组组成,将这些32位分组级联后产生一个256位的散列值。

    【实验步骤】

    以下是程序的关键代码:

    //SM3.C
    void sm3_starts( sm3_context *ctx )
    {
        ctx->total[0] = 0;
        ctx->total[1] = 0;
        ctx->state[0] = 0x7380166F;
        ctx->state[1] = 0x4914B2B9;
        ctx->state[2] = 0x172442D7;
        ctx->state[3] = 0xDA8A0600;
        ctx->state[4] = 0xA96F30BC;
        ctx->state[5] = 0x163138AA;
        ctx->state[6] = 0xE38DEE4D;
        ctx->state[7] = 0xB0FB0E4E;
    }
     
    static void sm3_process( sm3_context *ctx, unsigned char data[64] )
    {
        unsigned long SS1, SS2, TT1, TT2, W[68],W1[64];
        unsigned long A, B, C, D, E, F, G, H;
        unsigned long T[64];
        unsigned long Temp1,Temp2,Temp3,Temp4,Temp5;
        int j;
     
     
     
       
        for(j = 0; j < 16; j++)
           T[j] = 0x79CC4519;
        for(j =16; j < 64; j++)
           T[j] = 0x7A879D8A;
     
        GET_ULONG_BE( W[ 0], data,  0 );
        GET_ULONG_BE( W[ 1], data,  4 );
        GET_ULONG_BE( W[ 2], data,  8 );
        GET_ULONG_BE( W[ 3], data, 12 );
        GET_ULONG_BE( W[ 4], data, 16 );
        GET_ULONG_BE( W[ 5], data, 20 );
        GET_ULONG_BE( W[ 6], data, 24 );
        GET_ULONG_BE( W[ 7], data, 28 );
        GET_ULONG_BE( W[ 8], data, 32 );
        GET_ULONG_BE( W[ 9], data, 36 );
        GET_ULONG_BE( W[10], data, 40 );
        GET_ULONG_BE( W[11], data, 44 );
        GET_ULONG_BE( W[12], data, 48 );
        GET_ULONG_BE( W[13], data, 52 );
        GET_ULONG_BE( W[14], data, 56 );
        GET_ULONG_BE( W[15], data, 60 );
     
    #define FF0(x,y,z) ( (x) ^ (y) ^ (z))
    #define FF1(x,y,z) (((x) & (y)) | ( (x) & (z)) | ( (y) & (z)))
    #define GG0(x,y,z) ( (x) ^ (y) ^ (z))
    #define GG1(x,y,z) (((x) & (y)) | ( (~(x)) & (z)) )
    #define  SHL(x,n) (((x) & 0xFFFFFFFF) << n)
    #define ROTL(x,n) (SHL((x),n) | ((x) >> (32 - n)))
     
    #define P0(x) ((x) ^  ROTL((x),9) ^ ROTL((x),17))
    #define P1(x) ((x) ^  ROTL((x),15) ^ ROTL((x),23))
     
        for(j = 16; j < 68; j++ )
        {
           Temp1 = W[j-16] ^ W[j-9];
           Temp2 = ROTL(W[j-3],15);
           Temp3 = Temp1 ^ Temp2;
           Temp4 = P1(Temp3);
           Temp5 =  ROTL(W[j - 13],7 ) ^ W[j-6];
           W[j] = Temp4 ^ Temp5;
        }
        for(j =  0; j < 64; j++)
        {
            W1[j] = W[j] ^ W[j+4];
        }
        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 < 16; j++)
        {
           SS1 = ROTL((ROTL(A,12) + E + ROTL(T[j],j)), 7);
           SS2 = SS1 ^ ROTL(A,12);
           TT1 = FF0(A,B,C) + D + SS2 + W1[j];
           TT2 = GG0(E,F,G) + H + SS1 + W[j];
           D = C;
           C = ROTL(B,9);
           B = A;
           A = TT1;
           H = G;
           G = ROTL(F,19);
           F = E;
           E = P0(TT2);
        }
        for(j =16; j < 64; j++)
        {
           SS1 = ROTL((ROTL(A,12) + E + ROTL(T[j],j)), 7);
           SS2 = SS1 ^ ROTL(A,12);
           TT1 = FF1(A,B,C) + D + SS2 + W1[j];
           TT2 = GG1(E,F,G) + H + SS1 + W[j];
           D = C;
           C = ROTL(B,9);
           B = A;
           A = TT1;
           H = G;
           G = ROTL(F,19);
           F = E;
           E = P0(TT2);
        }
     
        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;
     
    } 
    void sm3_update( sm3_context *ctx, unsigned char *input, int ilen )
    {
        int fill;
        unsigned long left;
     
        if( ilen <= 0 )
            return;
        left = ctx->total[0] & 0x3F;
        fill = 64 - left;
        ctx->total[0] += ilen;
        ctx->total[0] &= 0xFFFFFFFF;
        if( ctx->total[0] < (unsigned long) ilen )
            ctx->total[1]++;
        if( left && ilen >= fill )
        {
            memcpy( (void *) (ctx->buffer + left),
                    (void *) input, fill );
            sm3_process( ctx, ctx->buffer );
            input += fill;
            ilen  -= fill;
            left = 0;
        }
        while( ilen >= 64 )
        {
            sm3_process( ctx, input );
            input += 64;
            ilen  -= 64;
        }
        if( ilen > 0 )
        {
            memcpy( (void *) (ctx->buffer + left),
                    (void *) input, ilen );
        }
    }
     
    static const unsigned char 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
    };
     
    void sm3_finish( sm3_context *ctx, unsigned char output[32] )
    {
        unsigned long last, padn;
        unsigned long high, low;
        unsigned char msglen[8];
     
        high = ( ctx->total[0] >> 29 )
             | ( ctx->total[1] <<  3 );
        low  = ( ctx->total[0] <<  3 );
        PUT_ULONG_BE( high, msglen, 0 );
        PUT_ULONG_BE( low,  msglen, 4 );
        last = ctx->total[0] & 0x3F;
        padn = ( last < 56 ) ? ( 56 - last ) : ( 120 - last );
        sm3_update( ctx, (unsigned char *) sm3_padding, padn );
        sm3_update( ctx, msglen, 8 );
        PUT_ULONG_BE( ctx->state[0], output,  0 );
        PUT_ULONG_BE( ctx->state[1], output,  4 );
        PUT_ULONG_BE( ctx->state[2], output,  8 );
        PUT_ULONG_BE( ctx->state[3], output, 12 );
        PUT_ULONG_BE( ctx->state[4], output, 16 );
        PUT_ULONG_BE( ctx->state[5], output, 20 );
        PUT_ULONG_BE( ctx->state[6], output, 24 );
        PUT_ULONG_BE( ctx->state[7], output, 28 );
    }
    void sm3( unsigned char *input, int ilen,
               unsigned char output[32] )
    {
        sm3_context ctx;
        sm3_starts( &ctx );
        sm3_update( &ctx, input, ilen );
        sm3_finish( &ctx, output );
     
        memset( &ctx, 0, sizeof( sm3_context ) );
    }
    int sm3_file( char *path, unsigned char output[32] )
    {
        FILE *f;
        size_t n;
        sm3_context ctx;
        unsigned char buf[1024];
        if( ( f = fopen( path, "rb" ) ) == NULL )
            return( 1 );
        sm3_starts( &ctx );
        while( ( n = fread( buf, 1, sizeof( buf ), f ) ) > 0 )
            sm3_update( &ctx, buf, (int) n );
        sm3_finish( &ctx, output );
        memset( &ctx, 0, sizeof( sm3_context ) );
        if( ferror( f ) != 0 )
        {
            fclose( f );
            return( 2 );
        }
        fclose( f );
        return( 0 );
    }
    void sm3_hmac_starts( sm3_context *ctx, unsigned char *key, int keylen )
    {
        int i;
        unsigned char sum[32];
     
        if( keylen > 64 )
        {
            sm3( key, keylen, sum );
            keylen = 32;
            key = sum;
        }
        memset( ctx->ipad, 0x36, 64 );
        memset( ctx->opad, 0x5C, 64 );
        for( i = 0; i < keylen; i++ )
        {
            ctx->ipad[i] = (unsigned char)( ctx->ipad[i] ^ key[i] );
            ctx->opad[i] = (unsigned char)( ctx->opad[i] ^ key[i] );
        }
        sm3_starts( ctx);
        sm3_update( ctx, ctx->ipad, 64 );
     
        memset( sum, 0, sizeof( sum ) );
    }
    void sm3_hmac_update( sm3_context *ctx, unsigned char *input, int ilen )
    {
        sm3_update( ctx, input, ilen );
    }
    void sm3_hmac_finish( sm3_context *ctx, unsigned char output[32] )
    {
        int hlen;
        unsigned char tmpbuf[32];
        hlen =  32;
        sm3_finish( ctx, tmpbuf );
        sm3_starts( ctx );
        sm3_update( ctx, ctx->opad, 64 );
        sm3_update( ctx, tmpbuf, hlen );
        sm3_finish( ctx, output );
        memset( tmpbuf, 0, sizeof( tmpbuf ) );
    }
    void sm3_hmac( unsigned char *key, int keylen,
                    unsigned char *input, int ilen,
                    unsigned char output[32] )
    {
        sm3_context ctx;
        sm3_hmac_starts( &ctx, key, keylen);
        sm3_hmac_update( &ctx, input, ilen );
        sm3_hmac_finish( &ctx, output );
        memset( &ctx, 0, sizeof( sm3_context ) );
    }
    

    程序运行结果
    输入明文1234abc,得到相应的消息摘要
    在这里插入图片描述
    图 4程序运行结果.

    【实验思考题】

    1. 请总结SM3与MD5,SHA1的异同。
      (1) 算法结构不同
      在消息填充方面,几个hash算法基本相同,都是先在原始消息的最后加一位“1”,再添加k个“0”,最终要使l+1+k除以512后的余数为448,取其最小的非负整数。然后用一个64位的比特串标识原始消息的长度l。填充后的消息M正好是512位的倍数。(其中)
      SM3算法的压缩函数与SHA-256的压缩函数具有相似的结构,但是SM3算法的设计更加复杂,比如压缩函数的每一轮都使用2个消息字。

    (2) 安全性不同
    摘要函数在密码学中具有重要的地位,被广泛应用在数字签名,消息认证,数据完整性检测等领域。摘要函数通常被认为需要满足三个基本特性:碰撞稳固性,原根稳固性和第二原根稳固性。
    即:
    ●对于任何一个给定的消息,它都很容易就能运算出散列数值。
    ●难以由一个已知的散列数值,去推算出原始的消息。
    ●在不更动散列数值的前提下,修改消息内容是不可行的。
    ●对于两个不同的消息,它不能给与相同的散列数值。

    2005年,Wang等人给出了MD5算法和SHA-1算法的碰撞攻击方法,现今被广泛应用的MD5算法和SHA-1算法不再是安全的算法。
    SM3密码摘要算法是中国国家密码管理局2010年公布的中国商用密码杂凑算法标准。SM3算法适用于商用密码应用中的数字签名和验证,是在SHA-256基础上改进实现的一种算法。SM3算法采用Merkle-Damgard结构,消息分组长度为512位,摘要值长度为256位。现今为止,SM3算法的安全性相对较高。

    (3) 效率不同
    MD5、SHA1、SH2-256与SM3的对比:
    在这里插入图片描述
    2. SM3算法如何保证其安全性?
    SM3算法也是一种哈希算法,是我国自主设计的密码杂凑算法,适用于商用密码应用中的数字签名和验证消息认证码的生成与验证以及随机数的生成,可满足多种密码应用的安全需求。为了保证杂凑算法的安全性,其产生的杂凑值的长度不应太短,例如MD5输出128比特杂凑值,输出长度太短,影响其安全性SHA-1算法的输出长度为160比特,SM3算法的输出长度为256比特,因此SM3算法的安全性要高于MD5算法和SHA-1算法。
    1、算法的本质
    给数据加一个固定长度的指纹,这个固定长度就是256比特。
    2、处理过程
    第一步:填充,使填充后的数据的长度是512的整数倍
    先在数据的最尾巴上加一个1;然后把原始数据的长度用64比特表示,放在最后面;再看看现在的数据的长度值离512的整数还差多少个,差多少个就填多少个0在加的这个1和64比特的长度之间。
    第二步:分组
    把填充后的信息按照512比特一个分组进行分组,如果分成了N组,就是b(0),b(1),b(N-1)
    第三步:迭代压缩得到最后的杂凑值(哈希值)
    IV(n)=CF(IV(n-1),b(n-1))
    如果信息分为N组,那么IV(N)就是最后得到的杂凑值。

    展开全文
  • SM3算法C代码

    2011-11-23 19:05:02
    对国密局标准HASH算法SM3的C代码实现
  • SM4算法原理

    万次阅读 多人点赞 2018-10-11 20:43:48
    前面的文章介绍了SM4算法...这篇文章介绍SM4算法原理,这部分可能会比较枯燥,但数学要求也不是太高。 目录 1.概述 2. 参数产生 3. 轮函数 4. 密钥扩展 5. 加密/解密过程 1.概述 2012年3月,国家密码管理...
  • SM2加密结果有两种数据组织方式,最常见的是C1|C2|C3,另一种C1|C3|C2,具体解释: 国密局推荐的SM2椭圆曲线参数(下图右侧输出的曲线参数); ...第3部分C3是杂凑值,用来效验数据,固定32B。...
  • GmSSL 是支持国密算法标准的OpenSSL分支,增加了对国密SM2/SM3/SM4算法和ECIES、CPK、ZUC算法的支持,实现了这些算法与EVP API和命令行工具的集成。GmSSL由北京大学信息安全实验室开发和维护。
  • 国密 sm2,sm3,sm4 算法纯 JavaScript 实现

    千次阅读 2020-11-06 19:43:42
    国密 sm2,sm3,sm4 算法纯 JavaScript 实现 2014 年国务院办公厅就颁发了《国务院办公厅转发密码局等部门关于金融领域密码应用指导意见》,指出在我国涉及到金融领域信息安全的产品和系统要自主可控,在金融领域使用...
  • 通过 pi_sm3() 调用,整合了gb上的资源,单文件导入,用来做数据库用户密码的HASH加密,还是挺好用的,谢谢。
  • 支持国密算法SM1,SM2,SM3SM4,SM7,SSF33算法 支持SM2 RSA密钥对生成 支持多级目录结构及多应用,各应用相互独立 支持多种文件类型,包括二进制文件、定长记录文件、变长记录文件、循环定长记录文件标准 ...
  • 密码学09(SM3算法)

    2019-12-10 15:46:48
    SM3密码摘要算法是中国国家密码管理局2010年公布的中国商用密码杂凑算法标准SM3算法适用于商用密码应用中的数字签名和验证,接受文本大小要小于264位,并以512位为单位分组,输出长度为256位的摘要 与SHA算法大体...
  • 搜索了一圈,论坛已有SM4,所以我发一个SM3摘要算法 国密即国家密码局认定的 国产密码算法 。主要有SM1,SM2,SM3SM4。密钥长度和分组长度均为128位。 SM3是一种密码散列函数标准,相关标准为“GM/T 0004-2012 ...
  • 按照国密文档通过C语言实现SM2密码算法加密/解密、签名/验签,SM3密码杂凑算法SM4分组密码算法ECB、CBC模式加密/解密。 经过详尽的测试目前未发现问题,并附有国密标准中数据检测结果。若有问题请及时反馈,期待和...
  • 说明如下: 1、BouncyCastle.Crypto:工程需要引用的原始库(不会引用直接百度即可); 2、sm3.cs:SM3算法主体内容。 另:为了提高可读性及便于理解,代码流程的说明与标准内容做了呼应。
  • SM3哈希算法

    2012-10-16 20:22:25
    国家密码管理局发布的SM3哈希算法工程,应用国密网站的标准数据测试完全正确。
  • 按照国密文档通过C语言实现SM2密码算法加密/解密、签名/验签,SM3密码杂凑算法SM4分组密码算法ECB、CBC模式加密/解密。 经过国密标准中数据验证无误。若有问题请及时反馈,期待和大家进行交流学习。 附带国密规范...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 8,295
精华内容 3,318
关键字:

sm3算法标准