Ln=Rn-1
Rn=Ln-1 ^ f(Rn-1,Kn)
然后关于Kn 子密钥的加密流程:
Kn = KS(n,KEY)
其中KS表示一个函数 n表示轮次数 KEY表示密钥 通过KEY生成16个子密钥
首先是对KEY进行排列 每8bit 删除最后一个(奇偶校验位)
根据PC-1盒(8行7列)生成相应位置的数值
举例一个密钥KEY: 0001001100110100010101110111100110011011101111001101111111110001
0 0 0 1 0 0 1 1 #8
0 0 1 1 0 1 0 0 #16
0 1 0 1 0 1 1 1 #24
0 1 1 1 1 0 0 1 #32
1 0 0 1 1 0 1 1 #40
1 0 1 1 1 1 0 0 #48
1 1 0 1 1 1 1 1 #56
1 1 1 1 0 0 0 1 #64
根据PC-1盒的数值选择对应位置 比如第一个是57 则置换之后的结果的第一位就是KEY中的第57位
result:
1 1 1 1 0 0 0
0 1 1 0 0 1 1
0 0 1 0 1 0 1
0 1 0 1 1 1 1
----------------------
0 1 0 1 0 1 0
1 0 1 1 0 0 1
1 0 0 1 1 1 1
0 0 0 1 1 1 1
前4行作为C 后四行作为D
关于C和D的迭替 依靠固定的移位表
此时
C0 = 1111000011001100101010101111
D0 = 0101010101100110011110001111
获得C1 就去按照1去查找 对应的左移位也是1
所以
C1 = 1110000110011001010101011111
D1 = 1010101011001100111100011110
比如C5就是 5对应左移2
左移举个例子:
原始:1,2,3,4,……,27,28
左移:3,4,5,6,……,28,1,2
然后根据PC-2提取Kn
这里就可以说明Kn的第一位是CnDn 组合中的第14位
故K1 = 000110110000001011101111111111000111000001110010
上面我们知道了DES子密钥的生成过程
下面就去了解DES子密钥的逆推过程
前提条件:如果已知两个或者两个以上的子密钥则可以逆推出初始密钥KEY(感觉第一个子密钥就可以捏
但是根据生成的过程我们知道KEY的长度是56bits(去除8个第8位) 但是子密钥的长度是48bits 所以存在8bits未知
每一bit有0和1两种情况 8bits则一共有2^8=256中情况 所以使用暴力破解
那么如何知道我们爆破的结果是正确的呢?就需要根据CTF题目中的部分已知明文进行判断
然后回到主体流程中 f 函数利用密钥继续加密
式子:B1B2…B8 = K + E®
输出:P(S1(B1)S2(B2)…S8(B8)
其中E函数功能:32bits的输入转化为48bits输出
其含义就是根据给出的E这个盒子 我们可以发现盒子里面的数字范围是(1-32)也正是R的比特数,同时也可以发现E的个数正好是6*8=48bits 所以就可以进行置换 比如E中前3位是 32 1 2 就代表输出的对应位置分别放置R的第32位 第1位 第2位 作为输出的前三位bit数
然后将输出的结果与我们获得的Kn密钥进行一次异或
然后48bits的数值 分为8组每组6bits 分别进入到8个不同的S盒中 然后每个S盒给出4bits的输出
S盒的处理原理:
给出一个S1盒举例
其中行编号是0-3 可以用两位二进制数字表示
列编号是0-15 用四位二进制数字表示
同时我们发现在S盒中的数据不超过15 正好4位二进制可以表示的 4位!!我们就可以联想到四位的输出
了解了上面的基础部分之后
我们有六位bits的输入 比如011011
那么我们把第一位和最后一位组合 01 转为十进制 1 就是对应行号为1的那一行
中间四位组合 1101 转为十进制就是13 就是对应列号为13的那一列
十字交叉 我们找到数字5 转为二进制0101 到此我们获得S1盒的输出就是0101
一共是4*8=32bits的数值 然后进入P函数的运算
给出一个P盒实例:
我们暂时把经过S盒处理的32bits排列称为L
则P(L)的输出格式和P盒相同
输出的第一位 就是根据P盒第一位获得的数值16 提取L中第16位的数值
到此回顾整个加密流程就解释清楚了
基本解密流程
因为是对称密码体系,所以在解密的过程中一定要始终保持对称的思想,充分借鉴加密的流程,从上面的output反推回input
相当于现在已知R16L16
然后进行反向解密
Rn-1 = Ln
Ln-1 = Rn ^ f(Ln,Kn) = Rn ^ f(Rn-1,Kn)
同时注意子密钥一定要反着传
这里看概念比较抽象,下面跟着这道优秀的题目好好感受一下DES的魅力吧~
参考优质论文:DES
simple_des
在下面的代码中可以关注一下注释 做出了比较细的解释~
题目源码:
from operator import add
from typing import List
from functools import reduce
from gmpy2 import \*
from Crypto.Util.number import \*
_IP = [57, 49, 41, 33, 25, 17, 9, 1,
59, 51, 43, 35, 27, 19, 11, 3,
61, 53, 45, 37, 29, 21, 13, 5,
63, 55, 47, 39, 31, 23, 15, 7,
56, 48, 40, 32, 24, 16, 8, 0,
58, 50, 42, 34, 26, 18, 10, 2,
60, 52, 44, 36, 28, 20, 12, 4,
62, 54, 46, 38, 30, 22, 14, 6
]
def IP(plain: List[int]) -> List[int]:
return [plain[x] for x in _IP]
__pc1 = [56, 48, 40, 32, 24, 16, 8,
0, 57, 49, 41, 33, 25, 17,
9, 1, 58, 50, 42, 34, 26,
18, 10, 2, 59, 51, 43, 35,
62, 54, 46, 38, 30, 22, 14,
6, 61, 53, 45, 37, 29, 21,
13, 5, 60, 52, 44, 36, 28,
20, 12, 4, 27, 19, 11, 3
]
__pc2 = [
13, 16, 10, 23, 0, 4,
2, 27, 14, 5, 20, 9,
22, 18, 11, 3, 25, 7,
15, 6, 26, 19, 12, 1,
40, 51, 30, 36, 46, 54,
29, 39, 50, 44, 32, 47,
43, 48, 38, 55, 33, 52,
45, 41, 49, 35, 28, 31
]
#这是规定的left shift对照表
ROTATIONS = [1, 1, 2, 2, 2, 2, 2, 2, 1, 2, 2, 2, 2, 2, 2, 1]
def PC\_1(key: List[int]) -> List[int]:
return [key[x] for x in __pc1]
def PC\_2(key: List[int]) -> List[int]:
return [key[x] for x in __pc2]
#通过初始密钥获得16轮子密钥的过程
def get\_sub\_key(key: List[int]) -> List[List[int]]:
#先把原始密钥key进行PC-1盒的处理 64bits->56bits
key = PC_1(key)
#这里的L和R 是生成密钥体系中的C和D
L, R = key[:28], key[28:]
sub_keys = []
#生成16轮子密钥
for i in range(16):
#这是进行lift shift操作 循环次数就是左位移次数
#pop是抛出从列表左侧踢出去的值附加到列表的后面 相当于实现了左移操作
for j in range(ROTATIONS[i]):
L.append(L.pop(0))
R.append(R.pop(0))
combined = L + R
#在PC-2盒中提取密钥
sub_key = PC_2(combined)
sub_keys.append(sub_key)
#还差9位 需要爆破 这里的L和R相当于最后一轮经过处理后的C16和D16
print('LL=',L[:19])
print('Rr=',R)
return sub_keys
#生成密钥时的E函数 expansion\_table
__ep = [31, 0, 1, 2, 3, 4,
3, 4, 5, 6, 7, 8,
7, 8, 9, 10, 11, 12,
11, 12, 13, 14, 15, 16,
15, 16, 17, 18, 19, 20,
19, 20, 21, 22, 23, 24,
23, 24, 25, 26, 27, 28,
27, 28, 29, 30, 31, 0
]
#permutation\_table 32个 是f函数中最后加密的P盒
__p = [15, 6, 19, 20, 28, 11, 27, 16,
0, 14, 22, 25, 4, 17, 30, 9,
1, 7, 23, 13, 31, 26, 2, 8,
18, 12, 29, 5, 21, 10, 3, 24
]
def EP(data: List[int]) -> List[int]:
return [data[x] for x in __ep]
def P(data: List[int]) -> List[int]:
return [data[x] for x in __p]
#S盒
__s_box = [
[
[14, 4, 13, 1, 2, 15, 11, 8, 3, 10, 6, 12, 5, 9, 0, 7],
[ 0, 15, 7, 4, 14, 2, 13, 1, 10, 6, 12, 11, 9, 5, 3, 8],
[ 4, 1, 14, 8, 13, 6, 2, 11, 15, 12, 9, 7, 3, 10, 5, 0],
[15, 12, 8, 2, 4, 9, 1, 7, 5, 11, 3, 14, 10, 0, 6, 13]
],
[
[15, 1, 8, 14, 6, 11, 3, 4, 9, 7, 2, 13, 12, 0, 5, 10],
[ 3, 13, 4, 7, 15, 2, 8, 14, 12, 0, 1, 10, 6, 9, 11, 5],
[ 0, 14, 7, 11, 10, 4, 13, 1, 5, 8, 12, 6, 9, 3, 2, 15],
[13, 8, 10, 1, 3, 15, 4, 2, 11, 6, 7, 12, 0, 5, 14, 9]
],
[
[10, 0, 9, 14, 6, 3, 15, 5, 1, 13, 12, 7, 11, 4, 2, 8],
[13, 7, 0, 9, 3, 4, 6, 10, 2, 8, 5, 14, 12, 11, 15, 1],
[13, 6, 4, 9, 8, 15, 3, 0, 11, 1, 2, 12, 5, 10, 14, 7],
[ 1, 10, 13, 0, 6, 9, 8, 7, 4, 15, 14, 3, 11, 5, 2, 12]
],
[
[ 7, 13, 14, 3, 0, 6, 9, 10, 1, 2, 8, 5, 11, 12, 4, 15],
[13, 8, 11, 5, 6, 15, 0, 3, 4, 7, 2, 12, 1, 10, 14, 9],
[10, 6, 9, 0, 12, 11, 7, 13, 15, 1, 3, 14, 5, 2, 8, 4],
[ 3, 15, 0, 6, 10, 1, 13, 8, 9, 4, 5, 11, 12, 7, 2, 14]
],
[
[ 2, 12, 4, 1, 7, 10, 11, 6, 8, 5, 3, 15, 13, 0, 14, 9],
[14, 11, 2, 12, 4, 7, 13, 1, 5, 0, 15, 10, 3, 9, 8, 6],
[ 4, 2, 1, 11, 10, 13, 7, 8, 15, 9, 12, 5, 6, 3, 0, 14],
[11, 8, 12, 7, 1, 14, 2, 13, 6, 15, 0, 9, 10, 4, 5, 3]
],
[
[12, 1, 10, 15, 9, 2, 6, 8, 0, 13, 3, 4, 14, 7, 5, 11],
[10, 15, 4, 2, 7, 12, 9, 5, 6, 1, 13, 14, 0, 11, 3, 8],
[ 9, 14, 15, 5, 2, 8, 12, 3, 7, 0, 4, 10, 1, 13, 11, 6],
[ 4, 3, 2, 12, 9, 5, 15, 10, 11, 14, 1, 7, 6, 0, 8, 13]
],
[
[ 4, 11, 2, 14, 15, 0, 8, 13, 3, 12, 9, 7, 5, 10, 6, 1],
[13, 0, 11, 7, 4, 9, 1, 10, 14, 3, 5, 12, 2, 15, 8, 6],
[ 1, 4, 11, 13, 12, 3, 7, 14, 10, 15, 6, 8, 0, 5, 9, 2],
[ 6, 11, 13, 8, 1, 4, 10, 7, 9, 5, 0, 15, 14, 2, 3, 12]
],
[
[13, 2, 8, 4, 6, 15, 11, 1, 10, 9, 3, 14, 5, 0, 12, 7],
[ 1, 15, 13, 8, 10, 3, 7, 4, 12, 5, 6, 11, 0, 14, 9, 2],
[ 7, 11, 4, 1, 9, 12, 14, 2, 0, 6, 10, 13, 15, 3, 5, 8],
[ 2, 1, 14, 7, 4, 10, 8, 13, 15, 12, 9, 0, 3, 5, 6, 11]
]
]
def S\_box(data: List[int]) -> List[int]:
output = []
for i in range(0, 48, 6):
row = data[i] \* 2 + data[i + 5]
col = reduce(add, [data[i + j] \* (2 \*\* (4 - j)) for j in range(1, 5)])
output += [int(x) for x in format(__s_box[i // 6][row][col], '04b')]
return output
def encrypt(plain: List[int], sub_keys: List[List[int]]) -> List[int]:
plain = IP(plain)
L, R = plain[:32], plain[32:]
#进行16轮循环加密
for i in range(16):
prev_L = L
L = R
expanded_R = EP(R)
xor_result = [a ^ b for a, b in zip(expanded_R, sub_keys[i])]
substituted = S_box(xor_result)
permuted = P(substituted)
R = [a ^ b for a, b in zip(permuted, prev_L)]
cipher = R + L
cipher = [cipher[x] for x in [39, 7, 47, 15, 55, 23, 63, 31,
38, 6, 46, 14, 54, 22, 62, 30,
37, 5, 45, 13, 53, 21, 61, 29,
36, 4, 44, 12, 52, 20, 60, 28,
35, 3, 43, 11, 51, 19, 59, 27,
34, 2, 42, 10, 50, 18, 58, 26,
33, 1, 41, 9, 49, 17, 57, 25,
32, 0, 40, 8, 48, 16, 56, 24]]
return cipher
def bitxor(plain1: List[int], plain2: List[List[int]]) -> List[int]:
return [int(i) for i in bin(int(''.join(str(i) for i in plain1),2)^int(''.join(str(i) for i in plain2),2))[2:].zfill(64)]
#key的字母表为abcdefghijklmnopqrstuvwsyz
from secret import flag, key
t=[]
z=[[0]\*64]
#对key中的每一位进行循环操作 将该为转为二进制 前置0进行填充到8位
#然后map应用于迭代对象(这里是一个字符串)中的每个元素,将每个二进制位字符转换为整数 然后放到列表里
#reduce(add, ...):这是 functools 模块中的 reduce() 函数,用于将一个二进制位的整数列表合并为一个整数,通过逐步应用 add 函数来实现。
key = reduce(add, [list(map(int, bin(key_byte)[2:].zfill(8))) for key_byte in key])
#对flag进行分段加密 0,1,2 相当于进行了3次的des操作
for i in range(0,3):
#仿照key的方法 提取flag的前8位字符
pt = reduce(add, [list(map(int, bin(flag_byte)[2:].zfill(8))) for flag_byte in flag[ 8\*i:8\*(i+1) ]])
#进行des的加密操作 待加密对象是pt 传入所有子密钥 注意原始的key第一次是key本身 往后则需要与上一次的明文进行异或
#输入时64bits的盒 每一次des输出的ct也是64bits
ct = encrypt(pt, get_sub_key(bitxor(z[i],key)))
#z保存明文
z.append(pt)
#t保存每次des加密的结果
t += ct
print(t)
'''
i=0情况下的LL,Rr
LL= [0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]
Rr= [0, 0, 0, 1, 1, 0, 0, 0, 1, 1, 0, 0, 1, 1, 1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 1, 0]
t=[0, 1, 1, 0, 1, 1, 1, 0, 1, 1, 0, 0, 1, 0, 0, 1, 0, 1, 1, 1, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 1, 0, 1, 0, 1, 0, 0, 1, 0, 1, 1, 0, 1, 0, 0, 1, 0, 0, 1, 1, 1, 0, 1, 0, 0, 0, 0, 1, 1, 0, 0, 1, 1, 0, 1, 0, 0, 0, 0, 1, 0, 0, 1, 0, 0, 1, 1, 1, 0, 1, 1, 0, 0, 1, 1, 1, 1, 1, 0, 1, 0, 0, 1, 1, 1, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 0, 1, 0, 1, 0, 0, 0, 1, 1, 0, 0, 1, 1, 0, 0, 1, 0, 0, 1, 1, 1, 0, 1, 0, 1, 1, 0, 1, 0, 1, 0, 0, 1, 0, 0, 0, 0, 0, 0, 1, 1, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 1, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 1, 1, 0, 1, 1, 1, 0, 1, 1, 1, 1, 1, 0, 1, 1, 0, 1, 0]
'''
参考文章:子密钥的逆推:https://www.freebuf.com/news/topnews/219723.html
出题师傅的思路:
解第一段(i=0):
通过泄露的最后一轮的C16和D16推出一组子密钥
通过已知的一组子密钥进入到guess_allsbkey函数中获得所有子密钥 并记录下C1和D1
将所有子密钥倒序进行des原始的enc加密操作中进行解密
from base64 import b64decode
from itertools import product
from DES import \* # https://github.com/soreatu/Cryptography/blob/master/DES.py 自行导入
from typing import List
from Crypto.Util.number import \*
guess_8bit = list(product(range(2), repeat=8))
#这是在PC2盒中没出现的位置数
not_in_PC2 = [9,18,22,25,35,38,43,54]
def re\_PC2(sbkey):
# 48-bit -> 56-bit
res = ['\*']\*56 #这样不确定的位置更明确一点
for i in range(len(sbkey)):
#这里之所以减1是因为在置换的时候我们是从第一位开始回推CD 但在列表中是从第0位开始的
#但这个地方有个小困惑 就是这个DES加密是出题师傅自己写的 我们发现\_\_pc2盒相比于我们调用库里的PC-2要减了1
#现在明白了 出题师傅构造的盒的位数采用的是列表中的思维 直接从0开始计数
#所以可以写为res[\_\_pc2[i]] = sbkey[i] 就不用再减1了 道理是一样的 还要修改一下上面的not\_in\_PC2列表
res[PC_2_table[i]-1] = sbkey[i]
#sbkey的长度只有48 所以存在8bit不确定的位置
return res # ok
#对这8bit进行猜测 也就是不在PC2的数值对应的位置
def guess\_CiDi16(sbkey, t):
res = re_PC2(sbkey)
for i in range(8):
#填充爆破未知位 其中guess\_8bit包含256种8位二进制的全部组合
res[not_in_PC2[i]-1] = guess_8bit[t][i]
return res # ok
def guess\_allsbkey(roundkey, r, t):
sbkey = [[]]\*16
#因为是列表的形式 所以r传入15 表示的仍为第16轮的子密钥
sbkey[r] = roundkey
CiDi = guess_CiDi16(roundkey, t)
Ci, Di = CiDi[:28], CiDi[28:]
#往后走15次 通过猜出的最后一轮子密钥 推测出全部密钥 注意取模操作
for i in range(r+1,r+16): #16-30
#CD的移位 现在获取的私钥sbkey是第0位 进行对应位移即可 对称密码嘛
Ci, Di = LR(Ci, Di, i%16)
sbkey[i%16] = PC_2(Ci+Di)
#相当于返回初始密钥C1和D1
if i%16 == 0:
本人从事网路安全工作12年,曾在2个大厂工作过,安全服务、售后服务、售前、攻防比赛、安全讲师、销售经理等职位都做过,对这个行业了解比较全面。
最近遍览了各种网络安全类的文章,内容参差不齐,其中不伐有大佬倾力教学,也有各种不良机构浑水摸鱼,在收到几条私信,发现大家对一套完整的系统的网络安全从学习路线到学习资料,甚至是工具有着不小的需求。
最后,我将这部分内容融会贯通成了一套282G的网络安全资料包,所有类目条理清晰,知识点层层递进,需要的小伙伴可以点击下方小卡片领取哦!下面就开始进入正题,如何从一个萌新一步一步进入网络安全行业。
![](https://img-blog.csdnimg.cn/img_convert/311903982dea1d8a5d2c98fc271b5b41.jpeg)
### 学习路线图
其中最为瞩目也是最为基础的就是网络安全学习路线图,这里我给大家分享一份打磨了3个月,已经更新到4.0版本的网络安全学习路线图。
相比起繁琐的文字,还是生动的视频教程更加适合零基础的同学们学习,这里也是整理了一份与上述学习路线一一对应的网络安全视频教程。
![](https://img-blog.csdnimg.cn/img_convert/1ddfaf7dc5879b1120e31fafa1ad4dc7.jpeg)
#### 网络安全工具箱
当然,当你入门之后,仅仅是视频教程已经不能满足你的需求了,你肯定需要学习各种工具的使用以及大量的实战项目,这里也分享一份**我自己整理的网络安全入门工具以及使用教程和实战。**
![](https://img-blog.csdnimg.cn/img_convert/bcd1787ce996787388468bb227d8f959.jpeg)
#### 项目实战
最后就是项目实战,这里带来的是**SRC资料&HW资料**,毕竟实战是检验真理的唯一标准嘛~
![](https://img-blog.csdnimg.cn/img_convert/35fc46df24091ce3c9a5032a9919b755.jpeg)
#### 面试题
归根结底,我们的最终目的都是为了就业,所以这份结合了多位朋友的亲身经验打磨的面试题合集你绝对不能错过!
**网上学习资料一大堆,但如果学到的知识不成体系,遇到问题时只是浅尝辄止,不再深入研究,那么很难做到真正的技术提升。**
**[需要这份系统化资料的朋友,可以点击这里获取](https://bbs.csdn.net/topics/618540462)**
**一个人可以走的很快,但一群人才能走的更远!不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人,都欢迎加入我们的的圈子(技术交流、学习资源、职场吐槽、大厂内推、面试辅导),让我们一起学习成长!**