首先是对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:
combined = Ci+Di
return combined,sbkey # ok
def long\_des\_enc(c, k):
assert len(c) % 8 == 0
res = b''
for i in range(0,len(c),8):
#一轮一轮的子密钥进行解密 先用第16轮的最后第1轮的子密钥 所以这里的k是刚刚的倒序给到加密函数 因为对称密码就像当与解密
#密文也是8字节切分解密 这是因为加密的时候对flag进行了切分
res += DES_enc(c[i:i+8], k)
return res
def try\_des(cipher, roundkey):
for t in range(256):
combined,allkey = guess_allsbkey(roundkey, 15, t)
#将子密钥倒序传入
plain = long_des_enc(cipher, allkey[::-1])
if plain.startswith(b'Nep'):
#保留初始的CD
print(combined,plain)
exit()
def PC\_2(key: List[int]) -> List[int]:
return [key[x] for x in __pc2]
还有兄弟不知道网络安全面试可以提前刷题吗？费时一周整理的160+网络安全面试题，金九银十，做网络安全面试里的显眼包！
王岚嵚工程师面试题（附答案），只能帮兄弟们到这儿了！如果你能答对70%，找一个安全工作，问题不大。
对于有1-3年工作经验，想要跳槽的朋友来说，也是很好的温习资料！
【完整版领取方式在文末！！】
***93道网络安全面试题***
内容实在太多，不一一截图了
### 黑客学习资源推荐
最后给大家分享一份全套的网络安全学习资料，给那些想学习 网络安全的小伙伴们一点帮助！
对于从来没有接触过网络安全的同学，我们帮你准备了详细的学习成长路线图。可以说是最科学最系统的学习路线，大家跟着这个大的方向学习准没问题。
😝朋友们如果有需要的话，可以联系领取~
#### 1️⃣零基础入门
##### ① 学习路线
对于从来没有接触过网络安全的同学，我们帮你准备了详细的**学习成长路线图**。可以说是**最科学最系统的学习路线**，大家跟着这个大的方向学习准没问题。
##### ② 路线对应学习视频
同时每个成长路线对应的板块都有配套的视频提供：
#### 2️⃣视频配套工具&国内外网安书籍、文档
##### ① 工具
##### ② 视频
##### ③ 书籍
资源较为敏感，未展示全面，需要的最下面获取
##### ② 简历模板
**因篇幅有限，资料较为敏感仅展示部分资料，添加上方即可获取👆**
**网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。**
**[需要这份系统化资料的朋友，可以点击这里获取](https://bbs.csdn.net/topics/618540462)**
**一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！**
933
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
