块密码

块密码/分组密码

在密码学中,分组加密(英语:Block cipher),又称分块加密或块密码,是一种对称密钥算法。它将明文分成多个等长的模块(block),使用确定的算法和对称密钥对每组分别加密解密。分组加密是极其重要的加密协议组成,其中典型的如AES和3DES作为美国政府核定的标准加密算法,应用领域从电子邮件加密到银行交易转帐,非常广泛。

分组加密包含两个成对的算法:加密算法 $E$ 和解密算法 $D$,两者互为反函数。每个算法有两个输入:长度为 $n$ 位的组,和长度为 $k$ 位的密钥;两组输入均生成 $n$ 位输出。将两个算法看作函数,$K$ 表示长度为 $k$ 的密钥(密钥长度),$P$ 表示长度为 $n$ 的分组,$P$ 也被表示为明文,$C$ 表示密文,则满足:

$E_K(P) = C \; ; \quad E_K^{-1}(C)=P$

$E_K(P) := E(K,P): \{0,1\}^k \times \{0,1\}^n \rightarrow \{0,1\}^n,$

对于任意密钥 $K$,$E_K(P)$ 是输入的组的一个置换函数,且可逆地落在 $\{0,1\}^n$ 区间。$E$ 的反函数(解密算法)定义为:

$E_K^{-1}(C) := D_K(C) = D(K,C): \{0,1\}^k \times \{0,1\}^n \rightarrow \{0,1\}^n,$

例如,一个分组加密算法使用一段 128 位的分组作为明文,相应输出 128 位的密文;而其转换则受加密算法中第二个输入的控制,也就是密钥 $k$。解密算法类似,使用 128 位的密文和对应的密钥,得到原 128 位的明文。

每一个密钥实际上是选择了 $n$ 位输入排列的 $(2^n)!$ 种组合中的一种。

大多数的分组密码在在加密算法中会重复使用某一函数进行多轮运算,典型的轮数在4-32次之间,每一轮的函数R使用不同的子密钥 $K_i$,由原密钥生成,作为输入:

$M_i = R_{K_i}(M_{i-1})$

其中 $M_{0}$ 是最初的明文,$M_{i}$ 是第 $i$ 轮加密后的密文。

分类

AES

高级加密标准(英语:Advanced Encryption Standard,缩写:AES),又称Rijndael加密法,是美国联邦政府采用的一种区块加密标准。这个标准用来替代原先的DES,已经被多方分析且广为全世界所使用。经过五年的甄选流程,高级加密标准由美国国家标准与技术研究院(NIST)于2001年11月26日发布于FIPS PUB 197,并在2002年5月26日成为有效的标准。现在,高级加密标准已然成为对称密钥加密中最流行的算法之一。

该算法为比利时密码学家Joan Daemen和Vincent Rijmen所设计,结合两位作者的名字,以Rijndael为名投稿高级加密标准的甄选流程。

  • 加密方法

    严格地说,AES和Rijndael加密法并不完全一样(虽然在实际应用中两者可以互换),因为Rijndael加密法可以支持更大范围的区块和密钥长度:AES的区块长度固定为128比特,密钥长度则可以是128,192或256比特;而Rijndael使用的密钥和区块长度均可以是128,192或256比特。加密过程中使用的密钥是由Rijndael密钥生成方案产生。

    大多数AES计算是在一个特别的有限域完成的。

    AES加密过程是在一个4×4的字节矩阵上运作,这个矩阵又称为“体(state)”,其初值就是一个明文区块(矩阵中一个元素大小就是明文区块中的一个Byte)。(Rijndael加密法因支持更大的区块,其矩阵的“列数(Row number)”可视情况增加)加密时,各轮AES加密循环(除最后一轮外)均包含4个步骤:

    1. AddRoundKey 矩阵中的每一个字节都与该次回合密钥(round key)做XOR运算;每个子密钥由密钥生成方案产生。
    2. SubBytes 透过一个非线性的替换函数,用查找表的方式把每个字节替换成对应的字节。
    3. ShiftRows 将矩阵中的每个横列进行循环式移位。
    4. MixColumns 为了充分混合矩阵中各个直行的操作。这个步骤使用线性转换来混合每内联的四个字节。最后一个加密循环中省略MixColumns步骤,而以另一个AddRoundKey取代。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
//Java实现
import java.io.*;
import javax.crypto.spec.SecretKeySpec;
import java.security.MessageDigest;
import java.util.Arrays;
import javax.crypto.Cipher;

class test
{
public static void main (String[] args) throws java.lang.Exception
{
byte[] plain = "flag{xxxxxxxxx}".getBytes();
System.out.println(Arrays.toString(plain));
byte[] key = {-114, 62, 98, 26, 54, -7, -59, -47, 55, 88, 18, -1, -99, 116, -51, 62};
SecretKeySpec secretKeySpec = new SecretKeySpec(key, 0, key.length, "AES");
MessageDigest instance = MessageDigest.getInstance("SHA-256");
instance.reset();
byte[] digest = instance.digest(plain);
Cipher instance2 = Cipher.getInstance("AES/ECB/NoPadding");
instance2.init(1, secretKeySpec);
byte[] cipher = instance2.doFinal(digest);
System.out.println(Arrays.toString(cipher));


byte[] c = {11, -35, 55, 10, 62, 79, 125, 62, -28, 115, 77, 4, 73, 0, 11, 121, -126, 85, -83, 109, 1, -98, 35, -68, -4, -122, 14, 110, -28, 111, 22, -125};
secretKeySpec = new SecretKeySpec(key, 0, key.length, "AES");
instance2 = Cipher.getInstance("AES/ECB/NoPadding");
instance2.init(2, secretKeySpec);
byte[] p = instance2.doFinal(c);
System.out.println(Arrays.toString(p));

String out = Base64.getEncoder().encodeToString(p);
System.out.println(out);

}
}

DES

数据加密标准(英语:Data Encryption Standard,缩写为 DES)是一种对称密钥加密块密码算法,1976年被美国联邦政府的国家标准局确定为联邦资料处理标准(FIPS),随后在国际上广泛流传开来。它基于使用56位密钥的对称算法。这个算法因为包含一些机密设计元素,相对短的密钥长度以及怀疑内含美国国家安全局(NSA)的后门而在开始时有争议,DES因此受到了强烈的学院派式的审查,并以此推动了现代的块密码及其密码分析的发展。

DES现在已经不是一种安全的加密方法,主要因为它使用的56位密钥过短。

  • 加密方法:

    DES是一种典型的块密码—一种将固定长度的明文通过一系列复杂的操作变成同样长度的密文的算法。对DES而言,块长度为64位。同时,DES使用密钥来自定义变换过程,因此算法认为只有持有加密所用的密钥的用户才能解密密文。密钥表面上是64位的,然而只有其中的56位被实际用于算法,其余8位可以被用于奇偶校验,并在算法中被丢弃。因此,DES的有效密钥长度仅为56位。

    算法的整体结有16个相同的处理过程,称为“回次”(round),并在首尾各有一次置换,称为IP与FP(或称IP-1,FP为IP的反函数(即IP“撤销”FP的操作,反之亦然)。IP和FP几乎没有密码学上的重要性,为了在1970年代中期的硬件上简化输入输出数据库的过程而被显式的包括在标准中。

    在主处理回次前,数据块被分成两个32位的半块,并被分别处理;这种交叉的方式被称为费斯妥结构。费斯妥结构保证了加密和解密过程足够相似—唯一的区别在于子密钥在解密时是以反向的顺序应用的,而剩余部分均相同。这样的设计大大简化了算法的实现,尤其是硬件实现,因为没有区分加密和解密算法的需要。

    费斯妥函数(F函数)将数据半块与某个子密钥进行处理。然后,一个F函数的输出与另一个半块异或之后,再与原本的半块组合并交换顺序,进入下一个回次的处理。在最后一个回次完成时,两个半块需要交换顺序,这是费斯妥结构的一个特点,以保证加解密的过程相似。

    费斯妥函数(F函数)每次对半块(32位)进行操作,并包括四个步骤:

    1. 扩张 用扩张置换将32位的半块扩展到48位,其输出包括8个6位的块,每块包含4位对应的输入位,加上两个邻接的块中紧邻的位。
    2. 与密钥混合 用异或操作将扩张的结果和一个子密钥进行混合。16个48位的子密钥—每个用于一个回次的F变换—是利用密钥调度从主密钥生成的。
    3. S盒 在与子密钥混合之后,块被分成8个6位的块,然后使用“S盒”,或称“置换盒”进行处理。8个S盒的每一个都使用以查找表方式提供的非线性的变换将它的6个输入位变成4个输出位。S盒提供了DES的核心安全性—如果没有S盒,密码会是线性的,很容易破解。
    4. 置换 最后,S盒的32个输出位利用固定的置换,“P置换”进行重组。这个设计是为了将每个S盒的4位输出在下一回次的扩张后,使用4个不同的S盒进行处理。

    S盒,P置换和E扩张各自满足了克劳德·香农在1940年代提出的实用密码所需的必要条件,“混淆与扩散”。

加解密工具

  • openssl

    加密

    openssl enc -aes-128-cbc -in plain.txt -out encrypt.txt -iv f123 -K 1223 -p

    -p: 打印加密用的salt,key,iv

    解密

    openssl aes-128-cbc -d -in encrypt.txt -out encrypt_decrypt.txt -S E0DEB1EAFE7F0000 -iv F1230000000000000000000000000000 -K 12230000000000000000000000000000

    openssl enc -d -aes256 -in fl@g.txt -out 1.txt

    -S: salt

常见攻击

ECB模式

最简单的加密模式即为电子密码本(Electronic codebook,ECB)模式。需要加密的消息按照块密码的块大小被分为数个块,并对每个块进行独立加密。

  • 中间人攻击(MITM)

    假如存在一个攻击者,当他作为中间人截获两方的通信时,他能够改变密文的分组顺序,当接收者对密文进行解密时,由于密文分组的顺序被改变了,因此相应的明文分组的顺序也被改变了,那么接收者实际上是解密出了一段被篡改后的密文。在这种场景中,攻击者不需要破译密码,也不需要知道分组密码的算法,他只需要知道哪个分组记录了什么样的数据。

    参考:Boston Key Party CTF 2013 - MITM

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    #python2
    from Crypto.Cipher import AES
    from binascii import hexlify,unhexlify
    from string import printable

    alph = printable
    m = ''
    c = ''
    flag_c = ''
    middle = dict();

    for x in alph:
    for y in alph:
    for z in alph:
    key1 = '%s%s%s%s' % ('0' * 13, x, y, z)
    cipher = AES.new(key1)
    middle.update({cipher.encrypt(m): key1})

    print "\nTable built...\n";

    for x in alph:
    for y in alph:
    for z in alph:
    key2 = '%s%s%s%s' % (x, y, z, '0' * 13)
    cipher = AES.new(key2)
    d = cipher.decrypt(c)
    if d in middle:
    print "\nKeys found: %s; %s\nFlag:" % (middle[d].encode('hex'), key2.encode('hex'))
    cipher1 = AES.new(middle[d])
    print cipher1.decrypt(cipher.decrypt(flag_c))
  • 模式攻击

    动态填充加密+枚举secret字符

    方法一

    1.明文由输入值m+flag+padding组成,$m$ 为空时, $c$ 可分 $k$ 块,不断调整 $m$ 的长度,直到 $m$ 长度为 $l+1$ 时 $c$ 可分 $k+1$ 块,那么说明 $m$ 长度为 $l$ 时 $c$ 刚好可分 $k$ 块,即无padding情况下,$m+flag$ 可分 $k$ 块,则flag长度即为 $8k-l$。

    2.利用上面的思想,在 $m$ 长度为 $l$ 的基础上,长度不断加1,则可以把flag从后开始的每一位推到下一个块中,得到下一个块的密文 $c_i$;

    3.又已爆破出的flag位+padding已知,则下一个块的构成为未知字符1位+已爆破出的flag位(+padding)

    4.根据DES-ECB的性质,相同明文块对应的密文块相同。爆破第一位未知字符,将上面的块构成作为输入值输入,得到对应的密文的第一块,分别与实际密文 $c_i$ 比较,匹配的即为正确的明文字符。

    5.以此类推,得到完整flag。

    参考:

    ECB模式攻击

    1024杯 - 密码系统

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    from pwn import *
    import gmpy2
    import string

    host = 'das.wetolink.com'
    port = 42887
    block = 16
    secret_len = 38
    ori_padding_len = 10
    dic = '{}-'+string.ascii_lowercase+string.digits

    p = connect(host,port)
    flag = ''

    def pad(leng):
    pad_len = block - (leng % block) if leng % block != 0 else 0
    return chr(pad_len) * pad_len

    padding = [pad(k) for k in range(16)]
    padding = padding[1:]+[padding[0]]

    for i in range(secret_len):
    find=0
    payload = ('*'*(ori_padding_len+i+1)).encode('hex')

    group = i//block
    p.recvuntil('Amazing function: ')
    p.sendline(payload)
    data = p.recvline().strip()
    print([data[i:i+32] for i in range(0,len(data),32)])
    print(data)
    if group == 0:
    prob=data[-32:]
    else:
    prob=(data[-32*(group+1):-32*(group+1)+32])
    print(str(i+1)+' prob = '+str(prob))
    for j in dic:
    p.recvuntil('Amazing function: ')
    flag_suffix = flag[:min(len(flag),15)]
    payload = (j + flag_suffix + padding[min(len(flag_suffix),15)]).encode('hex')
    p.sendline(payload)
    data = p.recvline().strip()
    if data[:32]==prob:
    flag = j + flag
    print(str(i+1)+' flag = '+flag)
    print()
    find=1
    break
    if find == 0:
    print(str(i+1)+' cannot find!')
    break

    方法二

    1.由于是ECB的模式,所以当我们输入十五个’0’后,服务会将十五个’0’+flag加密,而此时第一组就是十五个’0’和flag的第一个字符。即,返回的明文的第一组是’0’*15 + flag[0]的密文。

    2.我们遍历0-255,发送’0’*15+chr(i),看返回的密文是不是和最初获得的密文的第一组一致,如果一致,那么此时的chr(i)就是flag的第一位。

    3.有了第一位我们就可以发送’0’*14+flag[0]过去,此时返回的第一组密文就是’0’*14+flag[0]+flag[1]的密文了,我们继续用第2步的方法就可以恢复flag[1]了。

    4.如此循环往复,逐位爆破flag。

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    def exp():  
    sh = remote("0.0.0.0","9999")

    pre="0"*47
    flag=""
    for block in range(41):
    #发送填充,泄露一位flag,并获取密文
    sh.recvuntil("Amazing function: ")
    sh.sendline(pre.encode('hex'))
    target = sh.recvuntil("\n")[:-1][64:96]
    for i in range(256):
    #遍历字符,找到与获取密文一致时的情况时,即得到一位明文
    tmp = '0'*(47-block)+flag+chr(i)
    sh.recvuntil("Amazing function: ")
    sh.sendline(tmp.encode('hex'))
    now = sh.recvuntil("\n")[:-1]
    if now[64:96] == target:
    flag += chr(i)
    #修改填充
    pre = pre[:-1]
    break
    return flag[7:-2]
  • 重排攻击

    在块加密中ECB模式中每个块都是独立加密的。因此攻击者可以在未知密钥的情况下,对密文中的块进行重新排列,组合成合法的可解密的新密文。

    考虑这么一种场景,某CMS的cookie格式为DES-ECB加密后的数据,而明文格式如下:

    1
    admin=0;username=pan 

    由于DES使用的块大小是8字节,因此上述明文可以切分成三个块,其中@为填充符号:

    1
    2
    3
    admin=0;
    username
    =pan@@@@

    假设我们可以控制自己的用户名(在注册时),那么有什么办法可以在不知道密钥的情况下将自己提取为管理员呢(即admin=1)?首先将用户名设置为pan@@@@admin=1;,此时明文块的内容如下:

    1
    2
    3
    4
    admin=0;
    username
    =pan@@@@
    admin=1;

    我们所需要做的,就是在加密完成后,将服务器返回的cookie使用最后一个块替换第一个块,这样一来就获得了一个具有管理员权限的合法cookie了。

CBC模式

IBM发明了密码分组链接(CBC,Cipher-block chaining)模式。在CBC模式中,每个明文块先与前一个密文块进行异或后,再进行加密。在这种方法中,每个密文块都依赖于它前面的所有明文块。同时,为了保证每条消息的唯一性,在第一个块中需要使用初始化向量。

CBC

加密:

Ciphertext-0 = Encrypt(Plaintext XOR IV) ——只用于第一个组块
Ciphertext-N= Encrypt(Plaintext XOR Ciphertext-N-1) ——用于第二及剩下的组块

$\left\{\begin{array} {c} c_1 = \text{Enc}(m_1 \oplus \text{iv}) \newline c_2 = \text{Enc}(m_2 \oplus c_1) \newline \vdots \newline c_i = \text{Enc}(m_i \oplus c_{i-1}) \end{array} \right.$

CBC

解密:

Plaintext-0 = Decrypt(Ciphertext) XOR IV ——只用于第一个组块
Plaintext-N= Decrypt(Ciphertext) XOR Ciphertext-N-1 ——用于第二及剩下的组块

$\left\{\begin{array} {c} m_1 = \text{Dec}(c_1)\oplus \text{iv} \newline m_2 = \text{Dec}(c_2)\oplus c_1 \newline \vdots \newline m_i = \text{Dec}(c_i)\oplus c_{i-1} \end{array} \right.$

  • CBC字节翻转

    Plaintext:明文数据

    IV:初始向量

    Key:分组加密使用的密钥

    Ciphertext:密文数据

    每组解密时,先进行分组加密算法的解密,然后与前一组的密文进行异或才是最初的明文。

    对于第一组则是与IV进行异或。

    上一块密文用来产生下一块明文,如果改变上一块密文的一个字节,然后与下一个解密后的组块异或,就可以得到一个不同的明文。

    CBC

    目标:要把Plain2中的某一字节翻转为另一字节。

    由于C1来自于Cipher2进行Block Cipher Decryption之后的结果,而且Key未知,就不能直接得知C1的值;

    但可通过字节翻转修改上一组密文Cipher1来翻转下一组的明文Plain2,从而可以完全忽视未知的C1值。

    由异或运算可以推导:B1 = A1 ^ C1,则也有:C1 = A1 ^ B1

    假设修改后的上一组密文为A1',要翻转的下一组明文为B1',则有:B1' = A1' ^ C1

    如果能够修改Cipher1,那么就能够修改A1的值为A1',即A1' = A1 ^ B1 ^ B1'

    即:

    1
    2
    3
    4
    5
    6
    7
    8
    B = A ^ C
    B' = A' ^ C
    A' = A ^ B ^ B'

    A=原上一组密文Cipher1
    B=原下一组明文Plain2
    B‘=要翻转的下一组明文Plain2'
    A'=要修改的上一组密文Cipher1'

    要求:1. 对于A1完全可控;2. 已知B1的值。

    由于修改了A1,Cipher1在进行Block Cipher Decryption的时候会得出错误的结果,再与IV异或会导致Plain1出错;

    如果能够得到修改A1之后产生的错误的Plain1的值,而且IV可以完全控制的话,那么就能够再套用一次前面的方法。

    即:

    1
    2
    3
    4
    5
    6
    7
    8
    B = A ^ C
    B' = A' ^ C
    A' = A ^ B ^ B'

    A=原IV值iv
    B=错误的明文Plain1
    B‘=要翻转的明文Plain1'
    A'=要修改的IV值iv'

    参考:SYPUCTF2020 - Yusa的密码学课堂—CBC第一课

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    from pwn import *
    import binascii
    import time

    p = remote('das.wetolink.com',42888) # 连接
    p.recvline()
    p.recvline()
    p.recvline()
    p.recvline()
    p.sendline('1') # 注册
    p.recv()
    p.sendline('Admin') # 用户名为Admin,方便之后修改
    data0 = p.recvline().decode()
    data0 = data0[28:124] # 提取返回数据部分
    iv0 = data0[:32] #返回的IV
    cipher00 = data0[32:64] #'yusayusayusayusa'的加密结果
    cipher01 = data0[64:96] #'Admin'的加密结果
    replacement0 = str(hex(int(cipher00[:2],16)^ord('A')^ord('a')))[2:] # 计算替换密文的值
    payload0 = iv0+replacement0+cipher00[2:]+cipher01 # 发送替换密文
    print('data0: ',data0)
    print('payload0: ',payload0)
    p.recvline()
    p.recvline()
    p.recvline()
    p.recvline()
    p.sendline('2') # 登入
    p.recv()
    p.sendline(payload0) # 发送Payload0
    data1 = p.recvline()[:64+len('Admin')*2] # 得到返回的数据
    data1 = data1.decode()
    plain1 = data1[32:64] # 'yusayusayusayusa'由于密文被替换,解出来的明文是错误的,之后可以进行异或修改
    print('data1: ',data1)
    print('plain1: ',plain1)
    iv1 = str(hex(int(binascii.hexlify('yusa'.encode()).decode()*4,16)^int(plain1,16)^int(iv0,16)))[2:] # 计算IV,用于修改错误的明文
    print('iv1: ',iv1)
    payload1 = iv1+replacement0+cipher00[2:]+cipher01
    print('payload1: ',payload1)
    p.recvline()
    p.recvline()
    p.recvline()
    p.recvline()
    p.sendline('2') # 登入
    p.recv()
    p.sendline(payload1) # 发送Payload1
    p.recvline()
    p.recvline()
    print(p.recvline()) # 得到flag
  • CBC字节翻转(Web)

    参考:bugkuctf–login4字节翻转攻击

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    //原密文修改字符
    <?php
    $enc=base64_decode("bIpgPK29vVQosJ+smzh0pOdq7QrP3H9CN0MBfynL1eKtILs/ayew1snTYbeYSIz8rQctkAUMORS76SWQHXwuKg==");
    $enc[13] = chr(ord($enc[13]) ^ ord("k") ^ ord ("n"));
    echo base64_encode($enc);
    ?>

    //新密文,修改对应iv值保证首块解密无错
    <?php
    $enc=base64_decode("4quudO++PAeVPQfcFJ0bbm1lIjtzOjU6ImFkbWluIjtzOjg6InBhc3N3b3JkIjtzOjM6IjEyMyI7fQ==");
    $iv=base64_decode("TrphJjWLH37sj6+EBqh28A==");
    $cleartext = 'a:2:{s:8:"userna';
    $newiv = '';
    for ($i=0;$i<16;$i++){
    $newiv=$newiv.chr(ord($iv[$i]) ^ ord($enc[$i]) ^ ord ($cleartext[$i]));
    }
    echo base64_encode($newiv);
    ?>
  • Padding Oracle Attack

    BP插件:PaddingOracleHunter

SM4

SM4是一种分组密码算法,其分组长度为128位(即16字节,4字),密钥长度也为128位(即16字节,4字)。其加解密过程采用了32轮迭代机制(与DES、AES类似),每一轮需要一个轮密钥(与DES、AES类似)。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
# Python
class SM4Cipher:
def __init__(self, key: bytes):
if not len(key) == 16:
raise ValueError("SM4 key must be length of 16. ")
self._key_r = self._generate_key(key)
self.block_size = 16

def encrypt(self, plaintext: bytes):
return self._do(plaintext, self._key_r)

def decrypt(self, ciphertext: bytes):
return self._do(ciphertext, self._key_r[::-1])

def _do(self, text: bytes, key_r: list):
text_ = [0 for _ in range(4)]
# 将 128bit 转化成 4x32bit
for i in range(4):
text_[i] = int.from_bytes(text[4 * i:4 * i + 4], 'big')
for i in range(32):
box_in = text_[1] ^ text_[2] ^ text_[3] ^ key_r[i]
box_out = self._s_box(box_in)
temp = text_[0] ^ box_out ^ self._rot_left(box_out, 2) ^ self._rot_left(box_out, 10)
temp = temp ^ self._rot_left(box_out, 18) ^ self._rot_left(box_out, 24)
text_ = text_[1:] + [temp]
text_ = text_[::-1] # 结果逆序
# 将 4x32bit 合并成 128bit
result = bytearray()
for i in range(4):
result.extend(text_[i].to_bytes(4, 'big'))
return bytes(result)

def _generate_key(self, key: bytes):
"""密钥生成"""
key_r, key_temp = [0 for _ in range(32)], [0 for _ in range(4)]
FK = [0xa3b1bac6, 0x56aa3350, 0x677d9197, 0xb27022dc]
CK = [0x00070e15, 0x1c232a31, 0x383f464d, 0x545b6269, 0x70777e85, 0x8c939aa1, 0xa8afb6bd, 0xc4cbd2d9,
0xe0e7eef5, 0xfc030a11, 0x181f262d, 0x343b4249, 0x50575e65, 0x6c737a81, 0x888f969d, 0xa4abb2b9,
0xc0c7ced5, 0xdce3eaf1, 0xf8ff060d, 0x141b2229, 0x30373e45, 0x4c535a61, 0x686f767d, 0x848b9299,
0xa0a7aeb5, 0xbcc3cad1, 0xd8dfe6ed, 0xf4fb0209, 0x10171e25, 0x2c333a41, 0x484f565d, 0x646b7279]
# 将 128bit 拆分成 4x32bit
for i in range(4):
temp = int.from_bytes(key[4 * i:4 * i + 4], 'big')
key_temp[i] = temp ^ FK[i]
# 循环生成轮密钥
for i in range(32):
box_in = key_temp[1] ^ key_temp[2] ^ key_temp[3] ^ CK[i]
box_out = self._s_box(box_in)
key_r[i] = key_temp[0] ^ box_out ^ self._rot_left(box_out, 13) ^ self._rot_left(box_out, 23)
key_temp = key_temp[1:] + [key_r[i]]
return key_r

@staticmethod
def _s_box(n: int):
BOX = [0xD6, 0x90, 0xE9, 0xFE, 0xCC, 0xE1, 0x3D, 0xB7, 0x16, 0xB6, 0x14, 0xC2, 0x28, 0xFB, 0x2C, 0x05, 0x2B,
0x67, 0x9A, 0x76, 0x2A, 0xBE, 0x04, 0xC3, 0xAA, 0x44, 0x13, 0x26, 0x49, 0x86, 0x06, 0x99, 0x9C, 0x42,
0x50, 0xF4, 0x91, 0xEF, 0x98, 0x7A, 0x33, 0x54, 0x0B, 0x43, 0xED, 0xCF, 0xAC, 0x62, 0xE4, 0xB3, 0x1C,
0xA9, 0xC9, 0x08, 0xE8, 0x95, 0x80, 0xDF, 0x94, 0xFA, 0x75, 0x8F, 0x3F, 0xA6, 0x47, 0x07, 0xA7, 0xFC,
0xF3, 0x73, 0x17, 0xBA, 0x83, 0x59, 0x3C, 0x19, 0xE6, 0x85, 0x4F, 0xA8, 0x68, 0x6B, 0x81, 0xB2, 0x71,
0x64, 0xDA, 0x8B, 0xF8, 0xEB, 0x0F, 0x4B, 0x70, 0x56, 0x9D, 0x35, 0x1E, 0x24, 0x0E, 0x5E, 0x63, 0x58,
0xD1, 0xA2, 0x25, 0x22, 0x7C, 0x3B, 0x01, 0x21, 0x78, 0x87, 0xD4, 0x00, 0x46, 0x57, 0x9F, 0xD3, 0x27,
0x52, 0x4C, 0x36, 0x02, 0xE7, 0xA0, 0xC4, 0xC8, 0x9E, 0xEA, 0xBF, 0x8A, 0xD2, 0x40, 0xC7, 0x38, 0xB5,
0xA3, 0xF7, 0xF2, 0xCE, 0xF9, 0x61, 0x15, 0xA1, 0xE0, 0xAE, 0x5D, 0xA4, 0x9B, 0x34, 0x1A, 0x55, 0xAD,
0x93, 0x32, 0x30, 0xF5, 0x8C, 0xB1, 0xE3, 0x1D, 0xF6, 0xE2, 0x2E, 0x82, 0x66, 0xCA, 0x60, 0xC0, 0x29,
0x23, 0xAB, 0x0D, 0x53, 0x4E, 0x6F, 0xD5, 0xDB, 0x37, 0x45, 0xDE, 0xFD, 0x8E, 0x2F, 0x03, 0xFF, 0x6A,
0x72, 0x6D, 0x6C, 0x5B, 0x51, 0x8D, 0x1B, 0xAF, 0x92, 0xBB, 0xDD, 0xBC, 0x7F, 0x11, 0xD9, 0x5C, 0x41,
0x1F, 0x10, 0x5A, 0xD8, 0x0A, 0xC1, 0x31, 0x88, 0xA5, 0xCD, 0x7B, 0xBD, 0x2D, 0x74, 0xD0, 0x12, 0xB8,
0xE5, 0xB4, 0xB0, 0x89, 0x69, 0x97, 0x4A, 0x0C, 0x96, 0x77, 0x7E, 0x65, 0xB9, 0xF1, 0x09, 0xC5, 0x6E,
0xC6, 0x84, 0x18, 0xF0, 0x7D, 0xEC, 0x3A, 0xDC, 0x4D, 0x20, 0x79, 0xEE, 0x5F, 0x3E, 0xD7, 0xCB, 0x39,
0x48]
result = bytearray()
# 将 32bit 拆分成 4x8bit,依次进行S盒变换
for item in list(n.to_bytes(4, 'big')):
result.append(BOX[item])
return int.from_bytes(result, 'big')

@staticmethod
def _rot_left(n, m):
"""循环左移"""
return ((n << m) | (n >> (32 - m))) & 0xFFFFFFFF

key = bytes.fromhex("0123456789ABCDEFFEDCBA9876543210") # 128bit密钥
plaintext = bytes.fromhex("00112233445566778899aabbccddeeff") # 128bit明文
sm4 = SM4Cipher(key)
print(sm4.encrypt(plaintext).hex()) # 09325c4853832dcb9337a5984f671b9a
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
// C
#include <stdio.h>
#include <iostream>
#include<bits/stdc++.h>
#include <string.h>
/************************************固定参数****************************************/
//S盒
const unsigned char Sbox[256] = {
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
};
//CK为固定参数,用于密钥扩展算法
const unsigned int CK[32] = {
0x00070e15, 0x1c232a31, 0x383f464d, 0x545b6269,
0x70777e85, 0x8c939aa1, 0xa8afb6bd, 0xc4cbd2d9,
0xe0e7eef5, 0xfc030a11, 0x181f262d, 0x343b4249,
0x50575e65, 0x6c737a81, 0x888f969d, 0xa4abb2b9,
0xc0c7ced5, 0xdce3eaf1, 0xf8ff060d, 0x141b2229,
0x30373e45, 0x4c535a61, 0x686f767d, 0x848b9299,
0xa0a7aeb5, 0xbcc3cad1, 0xd8dfe6ed, 0xf4fb0209,
0x10171e25, 0x2c333a41, 0x484f565d, 0x646b7279 };
//系统参数FK,密钥扩展算法中会使用到
const unsigned int FK[4]={0xA3B1BAC6, 0x56AA3350, 0x677D9197, 0xB27022DC};
/************************************全局变量****************************************/
unsigned int rk[32];//子密钥
unsigned int X[32];//每一轮加密的结果
unsigned int X_0[32];//每一轮解密的结果
unsigned int y[4];//暂时存放32轮后的密文
unsigned int y2[4];//暂时存放32轮后的明文
/***********************************测试用例*****************************************/
unsigned int key[4]={0x01234567,0x89abcdef,0xfedcba98,0x76543210};//
//unsigned int message[4]={0x01234567,0x89abcdef,0xfedcba98,0x76543210};
//unsigned int message[16]={0xFF, 0xD8, 0xFF, 0xE0, 0x00, 0x10, 0x4A, 0x46, 0x49, 0x46, 0x00, 0x01, 0x01, 0x00, 0x00, 0x01};
/*
*利用S盒非线性置换
*传进来的A(32位)取高位的8位(大端机真实的低位在高位储存)与0xFF做与运算,
*经过Sbox置换后放置低位的8位中,再与其他置换出的数做或运算得到t
*截断用 >>(位数) & 0xff,而拼接用 |
*/
unsigned int T(unsigned int A){
unsigned int t;
t = Sbox[(A)>>24&0xFF]<<24|Sbox[(A)>>16&0xFF]<<16|Sbox[(A)>>8&0xFF]<<8|Sbox[(A)&0xFF];
return t;
}
/*
*循环右移
*x为数,y为右移的位数
*/
unsigned int Rotl(unsigned int x, unsigned int y){
unsigned int t = ((x)>>(y)|(x)<<(32-(y)));
return t;
}
/*
*线性转换L1
*在轮函数中用到
*/
unsigned int L1(unsigned int t){
t = (t)^Rotl(t,2)^Rotl(t,10)^Rotl(t,18)^Rotl(t,24);
return t;
}
/*
*线性转换L2
*在子密钥扩展中用到
*/
unsigned int L2(unsigned int t){
t = (t)^Rotl(t,12)^Rotl(t,22);
return t;
}
/*
*sms4加密算法
*/
void encrypt(unsigned int x[], unsigned int rk[32], int num){
for(int i=0; i<32; i+=4){
x[0+num] = x[0+num]^L1(T(x[1+num]^x[2+num]^x[3+num]^rk[i+0]));
x[1+num] = x[1+num]^L1(T(x[2+num]^x[3+num]^x[0+num]^rk[i+1]));
x[2+num] = x[2+num]^L1(T(x[3+num]^x[0+num]^x[1+num]^rk[i+2]));
x[3+num] = x[3+num]^L1(T(x[0+num]^x[1+num]^x[2+num]^rk[i+3]));
X[i+0] = x[0+num];
X[i+1] = x[1+num];
X[i+2] = x[2+num];
X[i+3] = x[3+num];
}
y[0] = X[31];
y[1] = X[30];
y[2] = X[29];
y[3] = X[28];
}
/*
*sms4解密算法
*/
void decrypt(unsigned int x[], unsigned int rk[32], int num){
for(int i=0; i<32; i+=4){
x[0] = x[0]^L1(T(x[1]^x[2]^x[3]^rk[31-i]));
x[1] = x[1]^L1(T(x[2]^x[3]^x[0]^rk[30-i]));
x[2] = x[2]^L1(T(x[3]^x[0]^x[1]^rk[29-i]));
x[3] = x[3]^L1(T(x[0]^x[1]^x[2]^rk[28-i]));
X_0[i+0] = x[0];
X_0[i+1] = x[1];
X_0[i+2] = x[2];
X_0[i+3] = x[3];
}
y2[0] = X_0[31];
y2[1] = X_0[30];
y2[2] = X_0[29];
y2[3] = X_0[28];
}
/*
*密钥扩展算法
*/
void keyExt(unsigned int key[4]){
unsigned int K[4];
K[0] = key[0]^FK[0];
K[1] = key[1]^FK[1];
K[2] = key[2]^FK[2];
K[3] = key[3]^FK[3];
for(int i=0; i<32; i+=4){
K[0] = K[0]^L2(T(K[1]^K[2]^K[3]^CK[i+0]));
K[1] = K[1]^L2(T(K[2]^K[3]^K[0]^CK[i+1]));
K[2] = K[2]^L2(T(K[3]^K[0]^K[1]^CK[i+2]));
K[3] = K[3]^L2(T(K[0]^K[1]^K[2]^CK[i+3]));
rk[i+0] = K[0];
rk[i+1] = K[1];
rk[i+2] = K[2];
rk[i+3] = K[3];
}
}
int main(){
unsigned int cipher[4];
unsigned int *message_0;
//生成子密钥
keyExt(key);
//开始解密
FILE *p = fopen("./cipher.txt", "r+");
FILE *p2 = fopen("./decrypted_message.txt", "wb");
printf("\n明文为:\n");
for(int j=0;j<494868;j+=4){
for(int i=0;i<4;i++)
fscanf(p,"%08x", &cipher[i]);
decrypt(cipher,rk,j);
message_0 = y2;
for(int i=0;i<4;i++){
printf("%08x ", message_0[i]);
fprintf(p2,"%08x ", message_0[i]);
}
printf("\n");
fprintf(p2,"\n");
}
fclose(p);
fclose(p2);
}