精华内容
下载资源
问答
  • sm4 - zJanly - 博客园
    2020-12-20 02:38:41

    2012年3月,国家密码管理局正式公布了包含SM4分组密码算法在内的《祖冲之序列密码算法》等6项密码行业标准。与DES和AES算法类似,SM4算法是一种分组密码算法。其分组长度为128bit,密钥长度也为128bit。加密算法与密钥扩展算法均采用32轮非线性迭代结构,以字(32位)为单位进行加密运算,每一次迭代运算均为一轮变换函数F。SM4算法加/解密算法的结构相同,只是使用轮密钥相反,其中解密轮密钥是加密轮密钥的逆序。SM4算法的整体结构如图所示:

    SM4算法结构图:

    2. 参数产生

    字节由8位2进制数表示,字由32位2进制数表示;

    S盒为固定的8bit输入和输出置换;

    加密密钥长度为128bit,表示为MK=(MK0,MK1,MK2,MK3),其中MKi (i=0,1,2,3)为字。轮密钥表示为rki(i=0,1,2.....,31)为字。FK=(FK0,FK1,FK2,FK3)为系统参数,CK=(CK0,CK1,.....,CK31)为固定参数,都为字。

    3. 轮函数

    整体的加密函数为:

    其中T为一个合成置换,由非线性变换和线性变换复合而成。

    非线性变换由4个平行的S盒构成,S盒的数据均采用16进制。

    线性变换公式如下,其中B为非线性变换得到的字

    4. 密钥扩展

    已知加密密钥MK=(MK0,MK1,MK2,MK3),系统参数FK=(FK0,FK1,FK2,FK3),固定参数CK=(CK0,CK1,.....,CK31).

    rki为轮密钥,轮密钥由加密密钥生成。

    首先,

    然后对i=0,1,2,...,31:

    改变换与加密中的T变换基本相同,只是将其中的线性变换改为:,由于系统参数个固定参数是已知的,轮密钥即可求得。

    5. 加密/解密过程祖冲之序列密码

    加密最后一轮变换时,输出为:

    最后输出是加密的反序,解密时只是将轮密钥的使用顺序进行逆向进行。

    ————————————————

    版权声明:本文为CSDN博主「10点43」的原创文章,遵循 CC 4.0 BY-SA 版权协议,转载请附上原文出处链接及本声明。

    原文链接:https://blog.csdn.net/cg129054036/java/article/details/83016958

    更多相关内容
  • 本文将探讨一种不通过查表,只是通过逻辑运算的S盒实现方法。

    AES 和 SM4 S 盒复合域实现方法

    导语

    本文介绍AES和SM4 S盒的复合域实现方法,该方法由D.Canright在《A Very Compact Rijndael S-box》一文中提出,是分组密码bitslice实现、受限资源算法硬件实现和一些掩码方案的基础。

    1、背景

    是的,你没看错。本文要讲一下如何实现 AES 和 SM4 的 S 盒实现。你可能好奇,S 盒实现有什么好讲的,c 语言一个unsigned int Sbox[256] = {...}verilog  一个always case xxx:解决问题。没错,查表实现是S盒最基本的实现方法。高端一点的查表,可以将 S 盒的实现结合线性变换(AES 的 MixColumn,SM4 的 L)形成8→32的大表 T-Table 进行加速,例如openssl的查表实现。

    其实,我们本文将探讨一种不通过查表,只是通过逻辑运算的 S 盒实现方法。

    AES 和 SM4 的 S 盒都是由 GF(28) 有限域上的运算进行生成的。我们可以直接基于其实现方法,对 S 盒进行计算实现。在 AES 和 SM4 的 S 盒生成公式中,均设计在 GF(28) 的求逆运算,该运算比较耗时。有限域中求逆运算可以转化幂运算,例如 AES 的 S 盒可以表达为:
    S(x)=63+05x254+09x253+F9x251+25x247+01x223+B5x191+8Fx127.
    该运算定义在GF(28)上,直接实现同样较为复杂。

    还有一种方法,是使用布尔函数对 S 盒进行表达,利用布尔函数进行实现。该方法其实可以看作GF(2)上的表达。On Deviations of the AES S-box when Represented as Vector Valued Boolean Function对 AES 的 S 盒进行了分析,得到其布尔函数表达式,例如,其中第0比特可表示为:

    布尔函数非常复杂,直接利用布尔函数表达式也不是一个好的思路。

    D.Canright在A Very Compact Rijndael S-box一文中,提出一种实现思路:基于复合域进行实现。文章提出该方法实现在资源有限情况下的该类 S 盒的实现方式,后该方法被用于构造掩码实现(抵抗DPA攻击)和bitslice实现上。本文将对这个方法进行介绍。

    2、原理

    AES 和 SM4 的 S 盒生成都是基于GF(28)进行构造的,利用逆运算和仿射变换(affine)。仿射变换本身就能表示成逻辑运算,我们重点关注求逆运算。AES 和 SM4 的表达都是基于多项式基,以 AES 的有限域为例,假设A为多项式x8+x4+x3+x+1的根,即A8+A4+A3+A+1=0。那么任何一个元素x可以表示为x=x7A7+x6A6+x5A5+x4A4+x3A3+x2A2+x1A+x0。这种做法是将GF(28)直接看作GF(2)的8次扩域。我们也可以不这么看,将GF(28)看成GF(24)的2次扩域,GF(24)可以进一步看作GF(22)的2次扩域,再进一步GF(22)可以看作GF(2)的2次扩域。而GF(28)的求逆运算,可以通过数学表达式,转换为GF(24)的求逆和一些乘、加操作。这些操作可以进一步向下转化。下面我们详细说明一下。

    K=GF(qn)为GF(q)的n次扩域,β 为多项式的根,那么多项式基为{1,β,β2,…,βn−1},任何一个元素x,可以表示为x=xn−1βn−1+…+x1β+x0,这也是AES 和 SM4 所采用的基表示方式。此外,除了多项式基以外,域的表达方式还可以使用正规基进行表达,正规基为{β,βq,βq2,…,βqn−1},正规基使用了多项式的全部根。

    GF(28),可以看作GF(24)的2次扩域,也就是在GF(24)上寻找一个不可约二次多项式,r(y)=y2+τy+υ,其中,τ 和 υ 为 GF(24) 的元素。设 Y 为 r(y) 的根,则 GF(28) 元素的多项式基为 Y,1,正规基为Y,Y16。Canright在文章中讨论了多项式基和正规基两种方式,我们这里只看正规基。对于GF(28)的元素 g=γ1Y16+γ0Y,求逆 d=δ1Y16+δ0Y,γi 和 δi 都是GF(24)的元素, gd=1,待定系数求解,可得出

    {
      δ1=[γ1γ0τ2+(γ21+γ20)υ]−1γ0δ0=[γ1γ0τ2+(γ21+γ20)υ]−1γ1

    文内有详细推导方法,不再赘述。观察系数,其达到的效果就是,GF(28)的求逆运算,转化成为GF(24)的乘法、平方和求逆,特别的,可以选择不可约多项式为r(y)=y2+y+υ,也就是 τ 取1来降低求解复杂度,这样,对g=γ1Y16+γ0Y的求逆可简化为如下图:

    同样,GF(24)可以看作GF(22)的二次扩域,也就是在GF(22)寻找一个不可约二次多项式,s(z)=z2+Tz+N,设Z 为该多项式的根,取正规基{Z4,Z}。和GF(28)计算方法相同,可计算GF(24)元素υ=Γ1Z4+Γ0Z 的逆为δ=ΔZ4+ΔZ,其中,

    也可以取T=1降低复杂度,那么在GF(24)求逆运算如下图所示:

    在GF(28)求逆时,也涉及到了GF(24)的乘法。GF(24)的乘法υδ=(Γ1Z4+Γ0Z)(Δ1Z4+Δ0Z)可按照如下公式计算:

    如下图:

    进一步,GF(22)可以看作GF(2)的二次扩域,在GF(2)上的不可约多项式只有t(ω)=ω2+ω+1,取正规基W2,W,则Γ=g1W2+g0W,逆为Δ=d1W2+d0W,其中,

    GF(22)的乘法,ΓΔ=(g1W2+g0W)(d1W2+d0W),计算如下:

    如下图:

    将GF(28)进行转化,我们还有一些操作未介绍,包括 υγ2、NΓ2 和 NΓ。这些值可通过选择不同的 υ 和 N 进行简化。文章详细讨论了选取的方法。我们直接给结论:

    • 对于GF(22),不可约多项式为t(ω)=ω2+ω+1,正规基{W2,W}

    • 对于GF(24)/GF(22),不可约多项式为s(z)=z2+z+N,N=W2,正规基Z4,Z,N(g1W2+g2W)2=W2(g1W2+g2W)=g1W2+(g1+g0)W

    • 对于GF(28)/GF(24),不可约多项式为r(y)=y2+y+υ,υ=N2Z,如此,υ(AZ4+BZ)2=(A+B)2Z4+N2B2

    复合域下,实际上是以


    表示GF(28)的一个元素。
    而 S 盒的输入是以多项式基表示进行输入的。要利用复合域进行运算,需要将输入表示进行转换。以线性空间的角度看,这复合域表示相当于是给GF(28)找了一组新基。两组基有如下关系:

    找到w2z4y16等在多项式基下的表示,形成矩阵X:

    计算X−1,乘以多项式基下的表示即可得到复合域基下的表示。S盒计算完成后,再进行反变换即可。

    3、AES S盒实现方法

    AES的S盒是定义在GF(28)(不可约多项式x8+x4+x3+x+1),其表达式为S(x)=Ax−1+c,具体如下:

    4、求矩阵X和逆

    求 X 和 X−1,我们需要计算 w,z 和 y,计算 w2z4y16等一系列系数值。Canright在文章中给出了 GF(28) 生成元 B 的 对数表,方便计算。这里我们直接通过搜索进行计算。

    from pyfinite import ffield
    
    gen = 0b100011011
    F = ffield.FField(8, gen, useLUT=0) # 这里一定要写useLUT=0,不然会出问题。。。
    
    def field_pow2(x, F): #计算在F域上的平方
        return F.Multiply(x, x)
    
    def field_pow3(x, F): #计算在F域上的三次方
        return F.Multiply(x, field_pow2(x, F))
    
    def field_pow4(x, F): #计算在F域上的四次方
        return field_pow2(field_pow2(x, F), F)
    

    首先,搜索GF(22)的正规基{W2,W},我们求出其在GF(28)下多项式基的表示。

    1. for i in range(256):
          if field_pow2(i, F)^i^1 == 0: # 搜索 w^2+w+1 = 0的根
              print(hex(i))
      

    我们可得到,W=0xbd,W2=0xbc(一定要注意,这是GF(28)的多项式基表示)

    2. 然后,搜索GF(24)/GF(22)的正规基Z4,Z,我们求出其在GF(28)下多项式基的表示。s(z)=z2+z+N,N=W2=0xbc

    for i in range(256):
        if field_pow2(i, F)^i^0xbc == 0: # 搜索 z^2+z+0xbc = 0的根
            print(hex(i))
    

    于是我们又得到,Z=0x5c,Z4=0x5d

    3. 最后,搜索GF(28)/GF(24)的正规基{Y16,Y},我们求出其在GF(28)下多项式基的表示。r(y)=y2+y+υ,υ=N2Z

    u = F.Multiply(field_pow2(0xbc, F), 0x5c)
    for i in range(256):
        if field_pow2(i, F)^i^0xec == 0: # 搜索 z^2+z+0xbc = 0的根
            print(hex(i))
    

    于是我们又得到,Y=0xff,Y16=0xfe

    w = 0xbd
    w_2 = 0xbc
    z = 0x5c
    z_4 = 0x5d
    y = 0xff
    y_16 = 0xfe
    w_2_z_4_y_16 = F.Multiply(F.Multiply(w_2, z_4), y_16)
    w_z_4_y_16 = F.Multiply(F.Multiply(w, z_4), y_16)
    w_2_z_y_16 = F.Multiply(F.Multiply(w_2, z), y_16)
    w_z_y_16 = F.Multiply(F.Multiply(w, z), y_16)
    w_2_z_4_y = F.Multiply(F.Multiply(w_2, z_4), y)
    w_z_4_y = F.Multiply(F.Multiply(w, z_4), y)
    w_2_z_y = F.Multiply(F.Multiply(w_2, z), y)
    w_z_y = F.Multiply(F.Multiply(w, z), y)
    print('w_2_z_4_y_16\t', hex(w_2_z_4_y_16))
    print('w_z_4_y_16\t', hex(w_z_4_y_16))
    print('w_2_z_y_16\t', hex(w_2_z_y_16))
    print('w_z_y_16\t', hex(w_z_y_16))
    print('w_2_z_4_y\t', hex(w_2_z_4_y))
    print('w_z_4_y\t\t', hex(w_z_4_y))
    print('w_2_z_y\t\t', hex(w_2_z_y))
    print('w_z_y\t\t', hex(w_z_y))
    
    1. 得到多项式基在复合域基下表示如下:

    求X−1,可得到复合域基下多项式基的表示:

    from pyfinite import genericmatrix
    
    XOR = lambda x,y: x^y
    AND = lambda x,y: x&y
    DIV = lambda x,y: x
    m = genericmatrix.GenericMatrix(size=(8, 8),zeroElement=0,identityElement=1,add=XOR,mul=AND,sub=XOR,div=DIV)
    
    m.SetRow(0, [0, 0, 0, 1, 0, 0, 1, 0])
    m.SetRow(1, [1, 1, 1, 0, 1, 0, 1, 1])
    m.SetRow(2, [1, 1, 1, 0, 1, 1, 0, 1])
    m.SetRow(3, [0, 1, 0, 0, 0, 0, 1, 0])
    m.SetRow(4, [0, 1, 1, 1, 1, 1, 1, 0])
    m.SetRow(5, [1, 0, 1, 1, 0, 0, 1, 0])
    m.SetRow(6, [0, 0, 1, 0, 0, 0, 1, 0])
    m.SetRow(7, [0, 0, 0, 0, 0, 1, 0, 0])
    print(m)
    
    print(m.Inverse())
    

    5、具体函数实现

    基础函数定义

    g2b = [0b10011000, 0b11110011, 0b11110010, 0b01001000, 0b00001001, 0b10000001, 0b10101001, 0b11111111]
    b2g = [0b01100100, 0b01111000, 0b01101110, 0b10001100, 0b01101000, 0b00101001, 0b11011110, 0b01100000]
    
    def G4_mul(x, y):
        '''
        GF(2^2)的乘法运算,正规基{W^2, W}
        '''
        a = (x & 0x02)>>1
        b = x & 0x01
        c = (y & 0x02)>>1
        d = y & 0x01
        e = (a ^ b) & (c ^ d)
        return (((a & c) ^ e) << 1)|((b & d) ^ e)
    
    def G4_mul_N(x):
        '''
        GF(2^2)的乘N操作,N = W^2
        '''
        a = (x & 0x02)>>1
        b = x & 0x01
        p = b
        q = a ^ b
        return (p<<1)|q
    
    def G4_mul_N2(x):
        '''
        GF(2^2)的乘N^2操作,N = W^2
        '''
        a = (x & 0x02)>>1
        b = x & 0x01
        return ((a ^ b)<<1)|a
    
    def G4_inv(x):
        '''
        GF(2^2)的求逆操作,该操作和GF(2^2)的平方操作等价
        '''
        a = (x & 0x02)>>1
        b = x & 0x01
        return (b<<1)|a
    
    def G16_mul(x, y):
        '''
        GF(2^4)的乘法操作,正规基{Z^4, Z}
        '''
        a = (x & 0xc)>>2
        b = x & 0x03
        c = (y & 0xc)>>2
        d = y & 0x03
        e = G4_mul(a ^ b, c ^ d)
        e = G4_mul_N(e)
        p = G4_mul(a, c) ^ e
        q = G4_mul(b, d) ^ e
        return (p<<2) | q
    
    def G16_sq_mul_u(x):
        '''
        GF(2^4)的平方后乘u操作, u = N^2Z, N = W^2
        '''
        a = (x & 0xc)>>2
        b = x & 0x03
        p = G4_inv(a ^ b) # G4平方和求逆等价
        q = G4_mul_N2(G4_inv(b))
        return (p<<2)|q
    
    def G16_inv(x):
        '''
        GF(2^4)的求逆操作
        '''
        a = (x & 0xc)>>2
        b = x & 0x03
        c = G4_mul_N(G4_inv(a ^ b))
        d = G4_mul(a, b)
        e = G4_inv(c ^ d)
        p = G4_mul(e, b)
        q = G4_mul(e, a)
        return (p<<2)|q
    
    def G256_inv(x):
        '''
        GF(2^8)的求逆操作
        '''
        a = (x & 0xF0)>>4
        b = x & 0x0F
        c = G16_sq_mul_u(a ^ b)
        d = G16_mul(a, b)
        e = G16_inv(c ^ d)
        p = G16_mul(e, b)
        q = G16_mul(e, a)
        return (p<<4)|q
    
    def G256_new_basis(x, b):
        '''
        x在新基b下的表示
        '''
        y = 0
        for i in range(8):
            if x & (1<<(7-i)):
                y ^= b[i]
        return y
    

    计算S盒输出值

    A = [0b10001111, 0b11000111, 0b11100011, 0b11110001, 0b11111000, 0b01111100, 0b00111110, 0b00011111] #仿射变换矩阵乘
    
    def AES_SBOX(x):
        t = G256_new_basis(x, g2b)
        t = G256_inv(t)
        t = G256_new_basis(t, b2g)
        t = G256_new_basis(t, A) #仿射变换乘
        return t ^ 0x63
    
    sbox = []
    for i in range(256):
        sbox.append(AES_SBOX(i))  # 生成sbox
    
    for i,s in enumerate(sbox):
        print(f'%02x'%s,', ', end='')
        if (i+1)%16==0:
            print()
    

    6、SM4 S盒实现方法

    SM4 的 S 盒和 AES 不同, 定义在GF(28)采用的不可约多项式为x8+x7+x6+x5+x4+x2+1,生成方式为S(x)=A(Ax+c)−1+c,其中:

    7、求矩阵X和逆

    不可约多项式不同,X 矩阵也不相同。下面我们为 SM4 求 X 和 X−1,我们需要计算 w,z 和 y,计算 w2z4y16等一系列系数值

    from pyfinite import ffield
    
    gen = 0b111110101
    F = ffield.FField(8, gen, useLUT=0) # 这里一定要写useLUT=0,不然会出问题。。。
    
    1. 首先,搜索GF(22)的正规基{W2,W},我们求出其在GF(28)下多项式基的表示。

    for i in range(256):
        if field_pow2(i, F)^i^1 == 0: # 搜索 w^2+w+1 = 0的根
            print(hex(i))
    

    我们得到,W=0x5d,W2=0x5c(一定要注意,这是GF(28)的多项式基表示)

    1. 然后,搜索GF(24)/GF(22)的正规基Z4,Z,我们求出其在GF(28)下多项式基的表示。s(z)=z2+z+N,N=W2=0x5c

    for i in range(256):
        if field_pow2(i, F)^i^0x5c == 0: # 搜索 z^2+z+0x5c = 0的根
            print(hex(i))
    

    于是我们又得到,Z=0x0c,Z4=0x0d

    1. 最后,搜索GF(28)/GF(24)的正规基Y16,Y,我们求出其在GF(28)下多项式基的表示。r(y)=y2+y+υ,υ=N2Z

    u = F.Multiply(field_pow2(0x5c, F), 0x0c)
    for i in range(256):
        if field_pow2(i, F)^i^0x76 == 0: # 搜索 z^2+z+0x76 = 0的根
            print(hex(i))
    

    于是我们又得到,Y=0xef,Y16=0xee

    w = 0x5d
    w_2 = 0x5c
    z = 0x0c
    z_4 = 0x0d
    y = 0xef
    y_16 = 0xee
    w_2_z_4_y_16 = F.Multiply(F.Multiply(w_2, z_4), y_16)
    w_z_4_y_16 = F.Multiply(F.Multiply(w, z_4), y_16)
    w_2_z_y_16 = F.Multiply(F.Multiply(w_2, z), y_16)
    w_z_y_16 = F.Multiply(F.Multiply(w, z), y_16)
    w_2_z_4_y = F.Multiply(F.Multiply(w_2, z_4), y)
    w_z_4_y = F.Multiply(F.Multiply(w, z_4), y)
    w_2_z_y = F.Multiply(F.Multiply(w_2, z), y)
    w_z_y = F.Multiply(F.Multiply(w, z), y)
    
    print('w_2_z_4_y_16\t', hex(w_2_z_4_y_16))
    print('w_z_4_y_16\t', hex(w_z_4_y_16))
    print('w_2_z_y_16\t', hex(w_2_z_y_16))
    print('w_z_y_16\t', hex(w_z_y_16))
    print('w_2_z_4_y\t', hex(w_2_z_4_y))
    print('w_z_4_y\t\t', hex(w_z_4_y))
    print('w_2_z_y\t\t', hex(w_2_z_y))
    print('w_z_y\t\t', hex(w_z_y))
    
    1. 得到多项式基在复合域基下表示如下:

    求X−1,可得到复合域基下多项式基的表示:

    from pyfinite import genericmatrix
    
    XOR = lambda x,y: x^y
    AND = lambda x,y: x&y
    DIV = lambda x,y: x
    m = genericmatrix.GenericMatrix(size=(8, 8),zeroElement=0,identityElement=1,add=XOR,mul=AND,sub=XOR,div=DIV)
    
    m.SetRow(0, [1, 1, 0, 1, 1, 1, 0, 1])
    m.SetRow(1, [1, 1, 1, 0, 1, 1, 0, 1])
    m.SetRow(2, [1, 1, 0, 1, 0, 0, 1, 0])
    m.SetRow(3, [1, 0, 1, 0, 1, 0, 0, 1])
    m.SetRow(4, [0, 1, 0, 0, 0, 0, 1, 0])
    m.SetRow(5, [1, 1, 1, 0, 0, 1, 1, 1])
    m.SetRow(6, [0, 0, 0, 1, 1, 1, 1, 0])
    m.SetRow(7, [0, 0, 0, 0, 0, 1, 0, 0])
    print(m)
    print(m.Inverse())
    

    8、具体函数实现

    基础函数定义

    SM4 和 AES 采用的复合域结构相同,其基础函数也相同。仅定义X矩阵即可。

    g2b = [0b00100001, 0b11010011, 0b10000001, 0b01001010, 0b10001010, 0b10111001, 0b10110000, 0b11111111]
    b2g = [0xf4, 0xec, 0x54, 0xa2, 0xd2, 0xc7, 0x2e, 0xd4]
    

    计算S盒输出值

    A = [0b11100101, 0b11110010, 0b01111001, 0b10111100, 0b01011110, 0b00101111, 0b10010111, 0b11001011]
    def SM4_SBOX(x):
        t = G256_new_basis(x, A)
        t ^= 0xd3
        t = G256_new_basis(t, g2b)
        t = G256_inv(t)
        t = G256_new_basis(t, b2g)
        t = G256_new_basis(t, A) #仿射变换乘
        return t ^ 0xd3
    
    sbox = []
    for i in range(256):
        sbox.append(SM4_SBOX(i))  # 生成sbox
    
    for i,s in enumerate(sbox):
        print(f'%02x'%s,', ', end='')
        if (i+1)%16==0:
            print()
    

    9、推广结论

    通过 AES 和 SM4 的 S 盒复合域实现,我们不难发现,在复合域上,AES 和 SM4 的求逆运算过程相同,而除此之外,其他操作都是线性的仿射变换。那么我们能不能通过 AES 的 S 盒计算 SM4 的 S 盒输出呢?也就是,

    Ssm4(x)=L(Saes(Mx+C1))+C2,下面我们尝试进行推导。

    假设复合域求逆运算为f,则


    由此得出:
    Ssm4(x)=Asm4Xsm4f(X−1sm4(Asm4x+0xd3))+0xd3⇒Ssm4(x)=Asm4Xsm4X−1aesA−1aes(Saes(Xaes(X−1sm4(Asm4x+0xd3)))+0x63)+0xd3
    由此可得出,

    M=XaesX−1sm4Asm4C1=XaesX−1sm40xd3L=Asm4Xsm4X−1aesA−1aesC2=Asm4Xsm4X−1aesA−1aes0x63+0xd3

    XOR = lambda x,y: x^y
    AND = lambda x,y: x&y
    DIV = lambda x,y: x
    X_aes = genericmatrix.GenericMatrix(size=(8, 8),zeroElement=0,identityElement=1,add=XOR,mul=AND,sub=XOR,div=DIV)
    X_sm4 = genericmatrix.GenericMatrix(size=(8, 8),zeroElement=0,identityElement=1,add=XOR,mul=AND,sub=XOR,div=DIV)
    A_aes = genericmatrix.GenericMatrix(size=(8, 8),zeroElement=0,identityElement=1,add=XOR,mul=AND,sub=XOR,div=DIV)
    A_sm4 = genericmatrix.GenericMatrix(size=(8, 8),zeroElement=0,identityElement=1,add=XOR,mul=AND,sub=XOR,div=DIV)
    c_aes = genericmatrix.GenericMatrix(size=(8, 1),zeroElement=0,identityElement=1,add=XOR,mul=AND,sub=XOR,div=DIV)
    c_sm4 = genericmatrix.GenericMatrix(size=(8, 1),zeroElement=0,identityElement=1,add=XOR,mul=AND,sub=XOR,div=DIV)
    
    X_aes.SetRow(0, [0, 0, 0, 1, 0, 0, 1, 0])
    X_aes.SetRow(1, [1, 1, 1, 0, 1, 0, 1, 1])
    X_aes.SetRow(2, [1, 1, 1, 0, 1, 1, 0, 1])
    X_aes.SetRow(3, [0, 1, 0, 0, 0, 0, 1, 0])
    X_aes.SetRow(4, [0, 1, 1, 1, 1, 1, 1, 0])
    X_aes.SetRow(5, [1, 0, 1, 1, 0, 0, 1, 0])
    X_aes.SetRow(6, [0, 0, 1, 0, 0, 0, 1, 0])
    X_aes.SetRow(7, [0, 0, 0, 0, 0, 1, 0, 0])
    print(X_aes)
    
    X_aes_inv = X_aes.Inverse()
    X_aes_inv
    
    X_sm4.SetRow(0, [1, 1, 0, 1, 1, 1, 0, 1])
    X_sm4.SetRow(1, [1, 1, 1, 0, 1, 1, 0, 1])
    X_sm4.SetRow(2, [1, 1, 0, 1, 0, 0, 1, 0])
    X_sm4.SetRow(3, [1, 0, 1, 0, 1, 0, 0, 1])
    X_sm4.SetRow(4, [0, 1, 0, 0, 0, 0, 1, 0])
    X_sm4.SetRow(5, [1, 1, 1, 0, 0, 1, 1, 1])
    X_sm4.SetRow(6, [0, 0, 0, 1, 1, 1, 1, 0])
    X_sm4.SetRow(7, [0, 0, 0, 0, 0, 1, 0, 0])
    print(X_sm4)
    
    X_sm4_inv = X_sm4.Inverse()
    X_sm4_inv
    
    A_aes.SetRow(0, [1, 1, 1, 1, 1, 0, 0, 0])
    A_aes.SetRow(1, [0, 1, 1, 1, 1, 1, 0, 0])
    A_aes.SetRow(2, [0, 0, 1, 1, 1, 1, 1, 0])
    A_aes.SetRow(3, [0, 0, 0, 1, 1, 1, 1, 1])
    A_aes.SetRow(4, [1, 0, 0, 0, 1, 1, 1, 1])
    A_aes.SetRow(5, [1, 1, 0, 0, 0, 1, 1, 1])
    A_aes.SetRow(6, [1, 1, 1, 0, 0, 0, 1, 1])
    A_aes.SetRow(7, [1, 1, 1, 1, 0, 0, 0, 1])
    print(A_aes)
    
    A_aes_inv = A_aes.Inverse()
    
    A_sm4.SetRow(0, [1, 1, 0, 1, 0, 0, 1, 1])
    A_sm4.SetRow(1, [1, 1, 1, 0, 1, 0, 0, 1])
    A_sm4.SetRow(2, [1, 1, 1, 1, 0, 1, 0, 0])
    A_sm4.SetRow(3, [0, 1, 1, 1, 1, 0, 1, 0])
    A_sm4.SetRow(4, [0, 0, 1, 1, 1, 1, 0, 1])
    A_sm4.SetRow(5, [1, 0, 0, 1, 1, 1, 1, 0])
    A_sm4.SetRow(6, [0, 1, 0, 0, 1, 1, 1, 1])
    A_sm4.SetRow(7, [1, 0, 1, 0, 0, 1, 1, 1])
    print(A_sm4)
    
    A_sm4_inv = A_sm4.Inverse()
    
    M = X_aes*X_sm4_inv*A_sm4
    print(M)
    
    A = [0, 1, 1, 0, 0, 0, 1, 1]
    for i in range(8):
        c_aes.SetRow(i, [A[i]])
    print(c_aes)
    
    A = [1, 1, 0, 1, 0, 0, 1, 1]
    for i in range(8):
        c_sm4.SetRow(i, [A[i]])
    print(c_sm4)
    
    C1 = X_aes*(X_sm4_inv*c_sm4)
    print(C1)
    
    L = A_sm4*X_sm4*X_aes_inv*A_aes_inv
    print(L)
    

    因此,

    可以进行程序验证如下:

    L = [0b10100101, 0b11001101, 0b11100000, 0b10100100, 0b10010100, 0b01100100, 0b10010000, 0b00001111]
    M = [0b10101011, 0b01101100, 0b00110111, 0b10011000, 0b00111010, 0b11011111, 0b11001001, 0b01110101]
    c1 = 0x69
    c2 = 0x61
    
    SBOX_AES = [0x63 , 0x7c , 0x77 , 0x7b , 0xf2 , 0x6b , 0x6f , 0xc5 , 0x30 , 0x01 , 0x67 , 0x2b , 0xfe , 0xd7 , 0xab , 0x76 ,
    0xca , 0x82 , 0xc9 , 0x7d , 0xfa , 0x59 , 0x47 , 0xf0 , 0xad , 0xd4 , 0xa2 , 0xaf , 0x9c , 0xa4 , 0x72 , 0xc0 ,
    0xb7 , 0xfd , 0x93 , 0x26 , 0x36 , 0x3f , 0xf7 , 0xcc , 0x34 , 0xa5 , 0xe5 , 0xf1 , 0x71 , 0xd8 , 0x31 , 0x15 ,
    0x04 , 0xc7 , 0x23 , 0xc3 , 0x18 , 0x96 , 0x05 , 0x9a , 0x07 , 0x12 , 0x80 , 0xe2 , 0xeb , 0x27 , 0xb2 , 0x75 ,
    0x09 , 0x83 , 0x2c , 0x1a , 0x1b , 0x6e , 0x5a , 0xa0 , 0x52 , 0x3b , 0xd6 , 0xb3 , 0x29 , 0xe3 , 0x2f , 0x84 ,
    0x53 , 0xd1 , 0x00 , 0xed , 0x20 , 0xfc , 0xb1 , 0x5b , 0x6a , 0xcb , 0xbe , 0x39 , 0x4a , 0x4c , 0x58 , 0xcf ,
    0xd0 , 0xef , 0xaa , 0xfb , 0x43 , 0x4d , 0x33 , 0x85 , 0x45 , 0xf9 , 0x02 , 0x7f , 0x50 , 0x3c , 0x9f , 0xa8 ,
    0x51 , 0xa3 , 0x40 , 0x8f , 0x92 , 0x9d , 0x38 , 0xf5 , 0xbc , 0xb6 , 0xda , 0x21 , 0x10 , 0xff , 0xf3 , 0xd2 ,
    0xcd , 0x0c , 0x13 , 0xec , 0x5f , 0x97 , 0x44 , 0x17 , 0xc4 , 0xa7 , 0x7e , 0x3d , 0x64 , 0x5d , 0x19 , 0x73 ,
    0x60 , 0x81 , 0x4f , 0xdc , 0x22 , 0x2a , 0x90 , 0x88 , 0x46 , 0xee , 0xb8 , 0x14 , 0xde , 0x5e , 0x0b , 0xdb ,
    0xe0 , 0x32 , 0x3a , 0x0a , 0x49 , 0x06 , 0x24 , 0x5c , 0xc2 , 0xd3 , 0xac , 0x62 , 0x91 , 0x95 , 0xe4 , 0x79 ,
    0xe7 , 0xc8 , 0x37 , 0x6d , 0x8d , 0xd5 , 0x4e , 0xa9 , 0x6c , 0x56 , 0xf4 , 0xea , 0x65 , 0x7a , 0xae , 0x08 ,
    0xba , 0x78 , 0x25 , 0x2e , 0x1c , 0xa6 , 0xb4 , 0xc6 , 0xe8 , 0xdd , 0x74 , 0x1f , 0x4b , 0xbd , 0x8b , 0x8a ,
    0x70 , 0x3e , 0xb5 , 0x66 , 0x48 , 0x03 , 0xf6 , 0x0e , 0x61 , 0x35 , 0x57 , 0xb9 , 0x86 , 0xc1 , 0x1d , 0x9e ,
    0xe1 , 0xf8 , 0x98 , 0x11 , 0x69 , 0xd9 , 0x8e , 0x94 , 0x9b , 0x1e , 0x87 , 0xe9 , 0xce , 0x55 , 0x28 , 0xdf ,
    0x8c , 0xa1 , 0x89 , 0x0d , 0xbf , 0xe6 , 0x42 , 0x68 , 0x41 , 0x99 , 0x2d , 0x0f , 0xb0 , 0x54 , 0xbb , 0x16]
    
    def SM4_SBOX_CALC_WITH_AES(x):
        t = G256_new_basis(x, M)
        t ^= c1
        t = SBOX_AES[t]
        t = G256_new_basis(t, L)
        t ^= c2
        return t
    
    sbox = []
    for i in range(256):
        sbox.append(SM4_SBOX_CALC_WITH_AES(i))  # 生成sbox
    
    for i,s in enumerate(sbox):
        print(f'%02x'%s,', ', end='')
        if (i+1)%16==0:
            print()
    

    10、总结

    对 AES 和 SM4 来说,我们都可以把仿射变换和基变换操作的矩阵乘结合起来,简化对应的计算过程,从而减少运算。利用这一思想,我们可以对 AES 和 SM4 的 bit直接进行逻辑运算,避免查表操作。在硬件实现时,可利用该方法构造资源非常受限情况下的S盒实现。在软件上,该方法在抵抗cache攻击方面有效果,同时,我们可以使用bitslice并行技术进行加速。

    此外,SM4 的 S 盒可由 AES 表示得出,这一点在 CPU 有 AES 的指令集时,可将 SM4 的 S 盒运算转化为 AES 的 S 盒运算进行加速。

    (点击阅读原文显示文中公式)

     ** 休息时刻,轻松一下 ** 

    纽创信安提供基于Python、Java、C开发的多种算法软件库,并提供通过GM/T 0028-2014《密码模块安全技术要求》认证的国产密码算法软件引擎SM2/SM3/SM4,为客户量身订制基于上述软件引擎的系统级安全解决方案,并构建基于PUF硬件信任根的增强安全解决方案,有效的保护客户的信息系统安全。联系我们 sales@osr-tech.com。

    万物互联 安全赋能

    关于纽创信安OSR

    深圳市纽创信安科技开发有限公司(Open Security Research Inc.,OSR),成立于2014年,总部在深圳,在北京设有研发中心。是一家专注于安全攻防技术的国家高新技术企业,为客户提供高安全IP和攻击测试服务。

    纽创信安以领先的硬件安全攻防技术和创新的硬件安全方法学,致力于把金融级别的安全攻击与防御技术自动化、智能化、产品化、可视化,形成开放的方法学,为万物智联的各垂直行业做安全赋能,并致力于成为新时代安全技术的领跑者。

    OSR产品和服务涵盖硬件安全检测设备、安全算法加速、硬件安全解决方案和安全咨询服务,典型客户与合作伙伴包括国家电网、南方电网、泰尔实验室、汇顶、泰凌微电子、得一微电子、云天励飞、C-Sky、Synopsys等。

    展开全文
  • 国密SM4算法

    千次阅读 2021-02-11 09:54:10
    与DES和AES算法相似,国密SM4算法是一种分组加密算法。SM4分组密码算法是一种迭代分组密码算法,由加解密算法和密钥扩展算法组成。SM4是一种Feistel结构的分组密码算法,其分组长度和密钥长度均为128bits。加密算法...

    与DES和AES算法相似,国密SM4算法是一种分组加密算法。SM4分组密码算法是一种迭代分组密码算法,由加解密算法和密钥扩展算法组成。

    SM4是一种Feistel结构的分组密码算法,其分组长度和密钥长度均为128bits。加密算法和密钥扩展算法迭代轮数均为32轮。SM4加解密过程的算法相同但是轮密钥的使用顺序相反。

    SM4密码算法使用模2加和循环移位作为基本运算。

    密钥扩展算法:SM4算法使用128位的加密密钥,并采用32轮迭代加密结构,每一轮加密使用一个32位的轮密钥,总共使用32个轮密钥。因此需要使用密钥扩展算法,从加密密钥中产生32个轮密钥。

    SM4加解密流程

    SM4算法的加密大致流程如下:

    27dd0391caaeaf217ea253704494913b.png

    密钥:加密密钥的长度为128比特,表示为MK = (MK0, MK1, MK2, MK3),其中MKi为32位,轮密钥表示为(rk0, rk1, ……, rk31),其中rki为32位。

    轮函数F:假设输入为(X0, X1, X2, X3),Xi为32位,则轮函数F为:F=(X0, X1, X2, X3, rk) = X0 ⊕ T(X1 ⊕ X2 ⊕ X3 ⊕ rk)

    合成置换:T函数是一个可逆变换,由一个非线性变换r和线性变换L复合而成的,即T( )=L(r( ))

    非线性变换有四个并行的S盒构成的,设输入为A=(a0, a1, a2, a3),输出为B=(b0, b1, b2, b3),其中ai和bi为8位。每个S盒的输入都是一个8位的字节,将这8位的前四位对应的16进制数作为行编号,后四位对应的16进制数作为列编号,然后用相应位置中的字节代替输入的字节。下图为S盒置换表:

    81c3730ee4d1fb0bdaaa5a6539e854be.png

    65f48d28ae2d4d71c6a2a7ea97595230.png

    线性变换L:线形变换的输入就是S盒的输出,即C=L(B)=B ⊕ (B<<<2) ⊕ (B<<<10) ⊕ (B<<<18) ⊕ (B<<<24),线性变换的输入和输出都是32位的。

    经过了32轮的迭代运算后,最后再进行一次反序变换即可得到加密的密文,即密文C=(Y0, Y1, Y2, Y3)=R(X32. X33, X34, X35)=(X35, X34, X33, X32)。

    SM4算法的解密流程和加密流程一致,只不过轮密钥的使用顺序变成了(rk31, rk30, ……, rk0)

    密钥扩展算法

    密钥参量:轮密钥由加密密钥生成。FK=(FK0, FK1, FK2, FK3)为系统参数,以及固定参数CK=(CK0, CK1, ……,  CK31),其中FKi和CKi均为32位并用于密钥扩展算法。

    系统参数FK的具体取值如下:

    FK0=(A3B1BAC6), FK1=(56AA3350), FK2=(677D9197), FK3=(B27022DC)

    固定参数CK的具体取值如下:

    e1271375f82bb873a69a7d3309b1127d.png

    密钥扩展方法:设(K0, K1, K2, K3)=(MK0⊕FK0, MK1⊕FK1, MK2⊕FK2, MK3⊕FK3)

    则rki=Ki+4=Ki⊕T‘(Ki+1⊕Ki+2⊕Ki+3⊕CKi)

    其中T’()是将原来的T()中的线形变换L()替换成L'(B)=B⊕(B<<<13)⊕(B<<<23)

    展开全文
  • SM1对称密码SM1 算法是分组密码算法,分组长度为128位,密钥长度都为 128 比特,算法安全保密强度及相关软硬件实现性能与 AES 相当,算法不公开,仅以IP核的形式存在于芯片中。采用该算法已经研制了系列芯片、智能IC...

    SM1对称密码

    SM1 算法是分组密码算法,分组长度为128位,密钥长度都为 128 比特,算法安全保密强度及相关软硬件实现性能与 AES 相当,算法不公开,仅以IP核的形式存在于芯片中。

    采用该算法已经研制了系列芯片、智能IC卡、智能密码钥匙、加密卡、加密机等安全产品,广泛应用于电子政务、电子商务及国民经济的各个应用领域(包括国家政务通、警务通等重要领域)。

    SM2椭圆曲线公钥密码算法

    SM2算法就是ECC椭圆曲线密码机制,但在签名、密钥交换方面不同于ECDSA、ECDH等国际标准,而是采取了更为安全的机制。另外,SM2推荐了一条256位的曲线作为标准曲线。

    SM2标准包括总则,数字签名算法,密钥交换协议,公钥加密算法四个部分,并在每个部分的附录详细说明了实现的相关细节及示例。

    SM2算法主要考虑素域Fp和F2m上的椭圆曲线,分别介绍了这两类域的表示,运算,以及域上的椭圆曲线的点的表示,运算和多倍点计算算法。然后介绍了编程语言中的数据转换,包括整数和字节串,字节串和比特串,域元素和比特串,域元素和整数,点和字节串之间的数据转换规则。详细说明了有限域上椭圆曲线的参数生成以及验证,椭圆曲线的参数包括有限域的选取、椭圆曲线方程参数、椭圆曲线群基点的选取等,并给出了选取的标准以便于验证。最后给椭圆曲线上密钥对的生成以及公钥的验证,用户的密钥对为(s,sP),其中s为用户的私钥,sP为用户的公钥,由于离散对数问题从sP难以得到s,并针对素域和二元扩域给出了密钥对生成细节和验证方式。总则中的知识也适用于SM9算法。

    在总则的基础上给出了数字签名算法(包括数字签名生成算法和验证算法),密钥交换协议以及公钥加密算法(包括加密算法和解密算法),并在每个部分给出了算法描述,算法流程和相关示例。

    数字签名算法、密钥交换协议以及公钥加密算法都使用了国家密管理局批准的SM3密码杂凑算法和随机数发生器。数字签名算法、密钥交换协议以及公钥加密算法根据总则来选取有限域和椭圆曲线,并生成密钥对。

    SM2算法在很多方面都优于RSA算法。

    SM3杂凑算法

    SM3密码杂凑(哈希、散列)算法给出了杂凑函数算法的计算方法和计算步骤,并给出了运算示例。此算法适用于商用密码应用中的数字签名和验证,消息认证码的生成与验证以及随机数的生成,可满足多种密码应用的安全需求。在SM2,SM9标准中使用。

    此算法对输入长度小于2的64次方的比特消息,经过填充和迭代压缩,生成长度为256比特的杂凑值,其中使用了异或,模,模加,移位,与,或,非运算,由填充,迭代过程,消息扩展和压缩函数所构成。具体算法及运算示例见SM3标准。

    SM4对称算法

    此算法是一个分组算法,用于无线局域网产品。该算法的分组长度为128比特,密钥长度为128比特。加密算法与密钥扩展算法都采用32轮非线性迭代结构。解密算法与加密算法的结构相同,只是轮密钥的使用顺序相反,解密轮密钥是加密轮密钥的逆序。

    此算法采用非线性迭代结构,每次迭代由一个轮函数给出,其中轮函数由一个非线性变换和线性变换复合而成,非线性变换由S盒所给出。其中rki为轮密钥,合成置换T组成轮函数。轮密钥的产生与上图流程类似,由加密密钥作为输入生成,轮函数中的线性变换不同,还有些参数的区别。SM4算法的具体描述和示例见SM4标准。

    SM7对称密码

    SM7算法,是一种分组密码算法,分组长度为128比特,密钥长度为128比特。SM7适用于非接触式IC卡,应用包括身份识别类应用(门禁卡、工作证、参赛证),票务类应用(大型赛事门票、展会门票),支付与通卡类应用(积分消费卡、校园一卡通、企业一卡通等)。

    SM9标识密码算法

    为了降低公开密钥系统中密钥和证书管理的复杂性,以色列科学家、RSA算法发明人之一Adi Shamir在1984年提出了标识密码(Identity-Based Cryptography)的理念。标识密码将用户的标识(如邮件地址、手机号码、QQ号码等)作为公钥,省略了交换数字证书和公钥过程,使得安全系统变得易于部署和管理,非常适合端对端离线安全通讯、云端数据加密、基于属性加密、基于策略加密的各种场合。2008年标识密码算法正式获得国家密码管理局颁发的商密算法型号:SM9(商密九号算法),为我国标识密码技术的应用奠定了坚实的基础。

    SM9算法不需要申请数字证书,适用于互联网应用的各种新兴应用的安全保障。如基于云技术的密码服务、电子邮件安全、智能终端保护、物联网安全、云存储安全等等。这些安全应用可采用手机号码或邮件地址作为公钥,实现数据加密、身份认证、通话加密、通道加密等安全应用,并具有使用方便,易于部署的特点,从而开启了普及密码算法的大门。

    ZUC祖冲之算法

    祖冲之序列密码算法是中国自主研究的流密码算法,是运用于移动通信4G网络中的国际标准密码算法,该算法包括祖冲之算法(ZUC)、加密算法(128-EEA3)和完整性算法(128-EIA3)三个部分。目前已有对ZUC算法的优化实现,有专门针对128-EEA3和128-EIA3的硬件实现与优化。

    展开全文
  • 该平台以提升性能和资源效率为目标对SM4算法进行了映射。在直接映射方案的基础上,使用合并操作和任务并行的思路提出了3种改进方案。实验结果表明,改进方案不同程度地发挥了阵列运算资源优势,吞吐率和资源使用效率...
  • sms4S盒构造c实现

    千次阅读 热门讨论 2018-05-01 14:24:15
    sms4S盒构造c实现sms4算法中的s盒的构造是由三个函数复合而成的,公式为S(x)=L(I(L(x))),其中L(x)是仿射变换,而I(x)是逆变换。仿射变换较为简单,而在模2的伽罗瓦域上求多项式的逆则比较复杂。基本的假设是:...
  • SM4国密算法Java版

    2020-12-20 02:39:33
    根据 国密SM4 文档 编写的一个Java 加密解密样例package javasm4;/**** @author Jeen*/public class JavaSM4 {public static int[] key = new int[4];//密钥public static int[] temp = new int[4];//中间量 存储...
  • 基于功耗感知隐藏技术的SM4算法S盒的实现
  • [密码学]:SM4

    2022-04-21 20:29:11
    SM4在最后一轮非线性迭代之后加上了一个反序变换,因此SM4中只要解密密钥是加密密钥的逆序,它的解密算法与加密算法就可以保持一致。SM4的主体运算是非平衡Feistel网络。整体逻辑结构如图1所示,经过32轮变换把明文...
  • 中国商用密码算法SM4

    千次阅读 2020-11-25 14:58:07
    中国商用密码算法SM4 2006年我国国家密码管理局公布了无线局域网产品使用的SM4密码算法。... SM4密码算法设计简洁,算法结构有特点,安全高效。...SM4以字节(8比特)和字(32比特)位单位进行数据处理。它是对
  • 针对SM4算法的安全实现面临DPA攻击严重威胁的问题,提出了一种新的SM4算法门限S盒实现方案。该方案基于门限实现技术,通过构造秘密共享函数代替仿射变换,将S盒输入和输出均分成2组进行处理。S盒输入经过秘密共享...
  • 密码学03.5(SM4算法)

    2019-12-06 16:41:44
    SM4算法基本概念SM4算法基本变换规则轮函数F加密密钥扩展运算 基本概念 ...输入为32位,一共使用四个S盒,每个S盒处理8位,起混淆作用,设输入为A(a0~a3)输出为B则有: B = τ(A) = S_box(a0), S_box(a...
  • SM4算法是我国自主研制的密钥长度为128 bit的分组密码算法,在分析DES算法和SM4算法原理的基础上归纳了这两种算法的共同特点,采用可重构技术将两者融合,DES算法和SM4算法共用一个S盒,通过对S盒的配置可满足DES...
  • SM4.0 (原名SMS4.0)是 中华人民共和国政府 采用的一种 分组密码 标准,SM4主要用于 数据加密 ,其算法公开,分组长度与密钥长度均为128bit, 加密算法 与密钥扩展算法都采用32轮非线性迭代结构, S盒 为固定的8...
  • SM4 简介

    千次阅读 2020-08-27 15:16:34
    SM4S盒是一种以字节为单位的非线性代替变换,它的密码学作用是可以起到混淆的作用。S盒的本质是8位的非线性置换,输入和输出都是8位的字节。设输入字节为a,输出字节为b, 则S盒的运算可表示为: b=S_Box(a) (2-10)...
  • 测试s盒的雪崩效果,测试程序中为des的几个s盒和aes,sm4S盒
  • DELPHI_sm4.rar

    2019-12-30 08:43:26
    在商用密码体系中,SM4主要用于数据加密,其算法公开,分组长度与密钥长度均为128bit,加密算法与密钥扩展算法都采用32轮非线性迭代结构,S盒为固定的8比特输入8比特输出。 SM4.0中的指令长度被提升到大于64K(即64...
  • SM4算法

    2021-09-04 18:42:20
    文章目录前言一、SM4是什么?...在商用密码体系中,SM4主要用于数据加密,其算法公开,分组长度与密钥长度均为128bit,加密算法与密钥扩展算法都采用32轮非线性迭代结构,S盒为固定的8比特输入8比特输出。
  • 在本文中,我们基于复合字段S盒和查找表(LUT)S盒实现了SM4分组密码算法。 我们还探讨了SM4对抗机器学习攻击的性能,包括常规分类器,例如SVM和卷积神经网络(CNN)。 与传统的基于LUT的实现相比,基于复合文件S-...
  • re加密算法:RSA|SM4|RC4|MD5|Tea|AES

    千次阅读 2020-02-07 15:06:49
    将128位分成以32位为单位 SM4分步讲解 S盒处理 先进行S盒处理,s盒为特定数据 [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-ZTF1NKzb-1581058927553)(re加密算法.assets/1.png)] 由于S...
  • SM4算法过程

    千次阅读 多人点赞 2021-05-14 16:15:02
    SM4算法过程 一、SM4算法介绍 ​ 2012年3月,国家密码管理局正式公布了包含SM4分组密码算法在内的《祖冲之序列密码算法》等6项密码行业标准。与DES和AES算法类似,SM4算法是...​ SM4有很高的灵活性,所采用的S盒可以
  • SM4加密算法原理以及C语言实现

    千次阅读 2019-10-21 16:40:58
    SM4是一种轮询的数据加密算法,本文介绍了SM4算法的基本原理以及C语言实现,并通过程序算法实现了任意长度数据的加密与解密处理,实测可用,可供大家参考,谢谢!
  • 其中包括非线性变换S盒,以及由移位异或构成的线性变换。除了256字节的S盒之外,还定义了另外两组参数FK以及CK(具体数据参考密码局网站)。基本过程是首先把16字节密钥按照4字节一组分成4组,然后根据密钥扩展算法...
  • SM4加密算法(JAVA语言实现)

    万次阅读 多人点赞 2018-10-16 19:39:37
    1、SM4算法简介 中国国家密码管理局于2006年1月6日发布第7号公告,将我国无线局域网产品的加密算法确定为SM4算法(原SMS4)。这是国内官方公布的第一个商用密码算法。 SM4分组密码算法是一个迭代分钟密码算法,由...
  • SM4国密加密

    2022-03-15 15:20:21
    C#中使用SM4国密加密
  • sm4算法加密解密

    万次阅读 多人点赞 2020-05-08 09:58:52
    一、基本知识 ...它将明文分成多个等长的模块(block),使用确定的算法和对称密钥对每组分别加密解密。 对称加密、加密算法主要可以分为两种,一个是非对称加密算法,另一个就是对称加密算法。...二、sm...
  • AES128加密-S盒和逆S盒构造推导及代码实现

    万次阅读 多人点赞 2018-07-26 15:53:48
    AES128加密-S盒和逆S盒构造推导及代码实现 1.1 S盒产生概述 文档引用了《密码编码学与网络安全–原理和实践》里边的推导过程,如有不妥,请与我联系修改。 文档《FIPS 197》高级加密标准AES,里边有个S盒构造,...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 2,047
精华内容 818
关键字:

sm4 的s盒